Wild Life  2.29
 All Data Structures Files Functions Variables Typedefs Macros
error.c
Go to the documentation of this file.
1 /* Copyright 1991 Digital Equipment Corporation.
2  * All Rights Reserved.
3  *
4  * History:
5  * SCG 21 Tue Jun 2 14:15:36 1992
6  * added newTrace which allows a trace line to be one function call
7  * SCG 14 Wed May 27 13:37:51 1992
8  * added reportAndAbort() which is like report_error followed by
9  * an c_abort.
10  *****************************************************************/
11 /* $Id: error.c,v 1.3 1995/07/11 01:53:03 duchier Exp $ */
12 
13 #include "defs.h"
14 
15 
17 long quietflag=FALSE; /* 21.1 */
18 long trace=FALSE;
19 long verbose=FALSE; /* 21.1 */
20 long stepflag = 0;
21 long steptrace = 0;
22 long stepcount = 0;
23 
24 
25 /* Depth of goal stack */
26 static long depth_gs()
27 {
28  long i=0;
30 
31  while (g) { i++; g=g->next; }
32  return i;
33 }
34 
35 
36 /* Depth of choice point stack */
37 static long depth_cs()
38 {
39  long i=0;
41 
42  while (c) { i++; c=c->next; }
43  return i;
44 }
45 
46 
47 /* Depth of trail (undo) stack */
48 static long depth_ts()
49 {
51  long i=0;
52 
53  while (t) { i++; t=t->next; }
54  return i;
55 }
56 
57 
59  FILE *outfile;
60 {
61  /* Information about size of embedded stacks */
62  if (verbose) {
63  long gn,cn,tn;
64  fprintf(outfile,"*** Stack depths [");
65  gn=depth_gs();
66  cn=depth_cs();
67  tn=depth_ts();
68  fprintf(outfile,"%ld goal%s, %ld choice point%s, %ld trail entr%s",
69  gn,(gn!=1?"s":""),
70  cn,(cn!=1?"s":""),
71  tn,(tn!=1?"ies":"y"));
72  fprintf(outfile,"]\n");
73  }
74 }
75 
76 
77 
78 
79 void outputline(char *format,...)
80 {
81  va_list VarArg;
82  // int l;
83  char buffer_loc[5];
84  char *p;
85  unsigned long lng2;
86  char *cptr;
87  ptr_int_list pil;
88  ptr_psi_term psi;
89  operator kind;
90  def_type t ;
91  va_start(VarArg,format);
92  // vinfoline(format,output_stream, VarArg);
93  // #define vinfoline(format, outfile, xxxx) {
94  for (p=format;p && *p; p++)
95  {
96  if (*p == '%')
97  {
98  p++;
99  switch (*p)
100  {
101  case 'd':
102  case 'x':
103  buffer_loc[0] = '%';
104  buffer_loc[1] = 'l';
105  buffer_loc[2] = *p;
106  buffer_loc[3] = 0;
107  lng2 = va_arg(VarArg, long);
108  fprintf(output_stream, buffer_loc, lng2);
109  break;
110  case 's':
111  buffer_loc[0] = '%';
112  buffer_loc[1] = *p;
113  buffer_loc[2] = 0;
114  cptr = va_arg(VarArg,char *);
115  fprintf(output_stream, buffer_loc, cptr);
116  break;
117  case 'C':
118  /* type coding as bin string */
119  pil = va_arg(VarArg,ptr_int_list);
121  break;
122  case 'P':
123  psi = va_arg(VarArg,ptr_psi_term);
125  break;
126  case 'O':
127  kind = va_arg(VarArg,operator);
129  break;
130  case 'T':
131  assert(output_stream==stderr);
132  t = va_arg(VarArg,def_type);
133  print_def_type(t);
134  break;
135  case 'E':
136  assert(output_stream==stderr);
137  perr_i("near line %ld",psi_term_line_number);
138  if (strcmp(input_file_name,"stdin")) {
139  perr_s(" in file \042%s\042",input_file_name);
140  }
141  parse_ok=FALSE;
142  break;
143  case '%':
144  (void)putc(*p,output_stream);
145  break;
146  default:
147  fprintf(output_stream,"<%c follows %% : report bug >", *p);
148  break;
149  }
150  }
151  else
152  (void)putc(*p,output_stream);
153  }
154  va_end(VarArg);
155 }
156 
157 void traceline(char *format,...)
158 {
159  va_list VarArg;
160  // int l;
161  char buffer_loc[5];
162  char *p;
163  unsigned long lng2;
164  char *cptr;
165  ptr_int_list pil;
166  ptr_psi_term psi;
167  operator kind;
168  def_type t ;
169 
170  va_start(VarArg,format);
171 
172  if (trace) // DJD
173  {
174  /* RM: Nov 10 1993 */
175 
176  if ((trace == 2) && (format[0] != 'p')) return;
177  tracing();
178 
179  // vinfoline(format, stdout, VarArg);
180  // #define vinfoline(format, outfile, xxxx) {
181  for (p=format;p && *p; p++)
182  {
183  if (*p == '%')
184  {
185  p++;
186  switch (*p)
187  {
188  case 'd':
189  case 'x':
190  buffer_loc[0] = '%';
191  buffer_loc[1] = 'l';
192  buffer_loc[2] = *p;
193  buffer_loc[3] = 0;
194  lng2 = va_arg(VarArg, long);
195  fprintf(stdout, buffer_loc, lng2);
196  break;
197  case 's':
198  buffer_loc[0] = '%';
199  buffer_loc[1] = *p;
200  buffer_loc[2] = 0;
201  cptr = va_arg(VarArg,char *);
202  fprintf(stdout, buffer_loc, cptr);
203  break;
204  case 'C':
205  /* type coding as bin string */
206  pil = va_arg(VarArg,ptr_int_list);
207  print_code(stdout,pil);
208  break;
209  case 'P':
210  psi = va_arg(VarArg,ptr_psi_term);
211  display_psi(stdout,psi);
212  break;
213  case 'O':
214  kind = va_arg(VarArg,operator);
215  print_operator_kind(stdout,kind);
216  break;
217  case 'T':
218  assert(stdout==stderr);
219  t = va_arg(VarArg,def_type);
220  print_def_type(t);
221  break;
222  case 'E':
223  assert(stdout==stderr);
224  perr_i("near line %ld",psi_term_line_number);
225  if (strcmp(input_file_name,"stdin")) {
226  perr_s(" in file \042%s\042",input_file_name);
227  }
228  parse_ok=FALSE;
229  break;
230  case '%':
231  (void)putc(*p,stdout);
232  break;
233  default:
234  fprintf(stdout,"<%c follows %% : report bug >", *p);
235  break;
236  }
237  }
238  else
239  (void)putc(*p,stdout);
240  }
241  }
242  va_end(VarArg);
243 }
244 
245 void infoline(char *format,...)
246 {
247  va_list VarArg;
248  // int l;
249  char buffer_loc[5];
250  char *p;
251  unsigned long lng2;
252  char *cptr;
253  ptr_int_list pil;
254  ptr_psi_term psi;
255  operator kind;
256  def_type t ;
257 
258  va_start(VarArg,format);
259  if (NOTQUIET)
260  {
261 
262  // vinfoline(format, stdout, VarArg);
263  //#define vinfoline(format, outfile, xxxx) {
264  for (p=format;p && *p; p++)
265  {
266  if (*p == '%')
267  {
268  p++;
269  switch (*p)
270  {
271  case 'd':
272  case 'x':
273  buffer_loc[0] = '%';
274  buffer_loc[1] = 'l';
275  buffer_loc[2] = *p;
276  buffer_loc[3] = 0;
277  lng2 = va_arg(VarArg,long);
278  fprintf(stdout, buffer_loc, lng2);
279  break;
280  case 's':
281  buffer_loc[0] = '%';
282  buffer_loc[1] = *p;
283  buffer_loc[2] = 0;
284  cptr = va_arg(VarArg,char *);
285  fprintf(stdout, buffer_loc, cptr);
286  break;
287  case 'C':
288  /* type coding as bin string */
289  pil = va_arg(VarArg,ptr_int_list);
290  print_code(stdout,pil);
291  break;
292  case 'P':
293  psi = va_arg(VarArg,ptr_psi_term);
294  display_psi(stdout,psi);
295  break;
296  case 'O':
297  kind = va_arg(VarArg,operator);
298  print_operator_kind(stdout,kind);
299  break;
300  case 'T':
301  assert(stdout==stderr);
302  t = va_arg(VarArg,def_type);
303  print_def_type(t);
304  break;
305  case 'E':
306  assert(stdout==stderr);
307  perr_i("near line %ld",psi_term_line_number);
308  if (strcmp(input_file_name,"stdin")) {
309  perr_s(" in file 042%s042",input_file_name);
310  }
311  parse_ok=FALSE;
312  break;
313  case '%':
314  (void)putc(*p,stdout);
315  break;
316  default:
317  fprintf(stdout,"<%c follows %% : report bug >", *p);
318  break;
319  }
320  }
321  else
322  (void)putc(*p,stdout);
323  }
324  }
325  va_end(VarArg);
326 }
327 void warningline(char *format,...)
328 {
329  va_list VarArg;
330  // int l;
331  char buffer_loc[5];
332  char *p;
333  unsigned long lng2;
334  char *cptr;
335  ptr_int_list pil;
336  ptr_psi_term psi;
337  operator kind;
338  def_type t ;
339 
340  va_start(VarArg,format);
341 
342  if (warningflag) { // macro would not work
343 
344 
345  if(quietflag) return; /* RM: Sep 24 1993 */
346  fprintf(stderr,"*** Warning: ");
347  // vinfoline(format, stderr, VarArg);
348  // #define vinfoline(format, stderr, xxxx) {
349  for (p=format;p && *p; p++)
350  {
351  if (*p == '%')
352  {
353  p++;
354  switch (*p)
355  {
356  case 'd':
357  case 'x':
358  buffer_loc[0] = '%';
359  buffer_loc[1] = 'l';
360  buffer_loc[2] = *p;
361  buffer_loc[3] = 0;
362  lng2 = va_arg(VarArg,long);
363  fprintf(stderr, buffer_loc, lng2);
364  break;
365  case 's':
366  buffer_loc[0] = '%';
367  buffer_loc[1] = *p;
368  buffer_loc[2] = 0;
369  cptr = va_arg(VarArg,char *);
370  fprintf(stderr, buffer_loc, cptr);
371  break;
372  case 'C':
373  /* type coding as bin string */
374  pil = va_arg(VarArg,ptr_int_list);
375  print_code(stderr,pil);
376  break;
377  case 'P':
378  psi = va_arg(VarArg,ptr_psi_term);
379  display_psi(stderr,psi);
380  break;
381  case 'O':
382  kind = va_arg(VarArg,operator);
383  print_operator_kind(stderr,kind);
384  break;
385  case 'T':
386  assert(stderr==stderr);
387  t = va_arg(VarArg,def_type);
388  print_def_type(t);
389  break;
390  case 'E':
391  assert(stderr==stderr);
392  perr_i("near line %ld",psi_term_line_number);
393  if (strcmp(input_file_name,"stdin")) {
394  perr_s(" in file 042%s042",input_file_name);
395  }
396  parse_ok=FALSE;
397  break;
398  case '%':
399  (void)putc(*p,stderr);
400  break;
401  default:
402  fprintf(stderr,"<%c follows %% : report bug >", *p);
403  break;
404  }
405  }
406  else
407  (void)putc(*p,stderr);
408  }
409  }
410  va_end(VarArg);
411 }
412 
413 /* New error printing routine */
414 void Errorline(char *format,...)
415 {
416  va_list VarArg;
417  // int l;
418  char buffer_loc[5];
419  char *p;
420  unsigned long lng2;
421  char *cptr;
422  ptr_int_list pil;
423  ptr_psi_term psi;
424  operator kind;
425  def_type t ;
426 
427  va_start(VarArg,format);
428  // fprintf(stderr,"format = %lx %s\n",(long)format,format);fflush(stdout);
429  fprintf(stderr,"*** Error: ");
430  // fprintf(stderr,"format2 = %lx %s\n",(long)format,format);
431  // vinfoline(format, stderr, VarArg);
432  //#define vinfoline(format, stderr, xxxx) {
433  for (p=format;p && *p; p++)
434  {
435  if (*p == '%')
436  {
437  p++;
438  switch (*p)
439  {
440  case 'd':
441  case 'x':
442  buffer_loc[0] = '%';
443  buffer_loc[1] = 'l';
444  buffer_loc[2] = *p;
445  buffer_loc[3] = 0;
446  lng2 = va_arg(VarArg,long);
447  fprintf(stderr, buffer_loc, lng2);
448  break;
449  case 's':
450  buffer_loc[0] = '%';
451  buffer_loc[1] = *p;
452  buffer_loc[2] = 0;
453  cptr = va_arg(VarArg,char *);
454  fprintf(stderr, buffer_loc, cptr);
455  break;
456  case 'C':
457  /* type coding as bin string */
458  pil = va_arg(VarArg,ptr_int_list);
459  print_code(stderr,pil);
460  break;
461  case 'P':
462  psi = va_arg(VarArg,ptr_psi_term);
463  display_psi(stderr,psi);
464  break;
465  case 'O':
466  kind = va_arg(VarArg,operator);
467  print_operator_kind(stderr,kind);
468  break;
469  case 'T':
470  assert(stderr==stderr);
471  t = va_arg(VarArg,def_type);
472  print_def_type(t);
473  break;
474  case 'E':
475  assert(stderr==stderr);
476  perr_i("near line %ld",psi_term_line_number);
477  if (strcmp(input_file_name,"stdin")) {
478  perr_s(" in file \042%s\042",input_file_name);
479  }
480  parse_ok=FALSE;
481  break;
482  case '%':
483  (void)putc(*p,stderr);
484  break;
485  default:
486  fprintf(stderr,"<%c follows %% : report bug >", *p);
487  break;
488  }
489  }
490  else
491  (void)putc(*p,stderr);
492  }
493  va_end(VarArg);
494 #ifdef CLIFE
495 exit(0);
496 #endif
497 }
498 void Syntaxerrorline(char *format,...)
499 {
500  va_list VarArg;
501  // int l;
502  char buffer_loc[5];
503  char *p;
504  unsigned long lng2;
505  char *cptr;
506  ptr_int_list pil;
507  ptr_psi_term psi;
508  operator kind;
509  def_type t ;
510  va_start(VarArg,format);
511  // fprintf(stderr,"format = %lx %s\n",(long)format,format);fflush(stdout);
512  if(parse_ok) { /* RM: Feb 1 1993 */
513  parse_ok=FALSE; /* RM: Feb 1 1993 */
514  fprintf(stderr,"*** Syntax error: ");
515  // fprintf(stderr,"format2 = %lx %s\n",(long)format,format);
516  // vinfoline(format, stderr, VarArg);
517  //#define vinfoline(format, outfile, xxxx) {
518  for (p=format;p && *p; p++)
519  {
520  if (*p == '%')
521  {
522  p++;
523  switch (*p)
524  {
525  case 'd':
526  case 'x':
527  buffer_loc[0] = '%';
528  buffer_loc[1] = 'l';
529  buffer_loc[2] = *p;
530  buffer_loc[3] = 0;
531  lng2 = va_arg(VarArg,long);
532  fprintf(stderr, buffer_loc, lng2);
533  break;
534  case 's':
535  buffer_loc[0] = '%';
536  buffer_loc[1] = *p;
537  buffer_loc[2] = 0;
538  cptr = va_arg(VarArg,char *);
539  fprintf(stderr, buffer_loc, cptr);
540  break;
541  case 'C':
542  /* type coding as bin string */
543  pil = va_arg(VarArg,ptr_int_list);
544  print_code(stderr,pil);
545  break;
546  case 'P':
547  psi = va_arg(VarArg,ptr_psi_term);
548  display_psi(stderr,psi);
549  break;
550  case 'O':
551  kind = va_arg(VarArg,operator);
552  print_operator_kind(stderr,kind);
553  break;
554  case 'T':
555  assert(stderr==stderr);
556  t = va_arg(VarArg,def_type);
557  print_def_type(t);
558  break;
559  case 'E':
560  assert(stderr==stderr);
561  perr_i("near line %ld",psi_term_line_number);
562  if (strcmp(input_file_name,"stdin")) {
563  perr_s(" in file \042%s\042",input_file_name);
564  }
565  parse_ok=FALSE;
566  break;
567  case '%':
568  (void)putc(*p,stderr);
569  break;
570  default:
571  fprintf(stderr,"<%c follows %% : report bug >", *p);
572  break;
573  }
574  }
575  else
576  (void)putc(*p,stderr);
577  }
578  }
579  va_end(VarArg);
580 }
581 
582 /********************************************************************/
583 
584 /* Utilities for tracing and single stepping */
585 
586 /* Initialize all tracing variables */
588 {
589  trace=FALSE;
590  stepflag=FALSE;
591  stepcount=0;
592 }
593 
594 /* Reset stepcount to zero */
595 /* Should be called when prompt is printed */
597 {
598  if (stepcount>0) {
599  stepcount=0;
600  stepflag=TRUE;
601  }
602 }
603 
604 void tracing()
605 {
606  long i;
607  long indent_loc;
608 
609  printf("T%04ld",goal_count);
610  printf(" C%02ld",depth_cs());
611  indent_loc=depth_gs();
612  if (indent_loc>=MAX_TRACE_INDENT) printf(" G%02ld",indent_loc);
613  indent_loc = indent_loc % MAX_TRACE_INDENT;
614  for (i=indent_loc; i>=0; i--) printf(" ");
615  steptrace=TRUE;
616 }
617 
618 
619 void new_trace(newtrace)
620  long newtrace;
621 {
622  trace = newtrace;
623  printf("*** Tracing is turned ");
624  printf(trace?"on.":"off.");
625  if (trace == 2) printf(" Only for Proves");
626  printf("\n");
627 }
628 
629 void new_step(newstep)
630  long newstep;
631 {
632  stepflag = newstep;
633  printf("*** Single stepping is turned ");
634  printf(stepflag?"on.\n":"off.\n");
637 }
638 
640 {
641  new_trace(2);
642 }
643 
645 {
646  new_trace(trace?0:1);
647 }
648 
649 
651 {
652  new_step(!stepflag);
653 }
654 
655 /********************************************************************/
656 
657 /* Old error printing routines -- these should be superceded by Errorline */
658 
659 void perr(str)
660  char *str;
661 {
662  (void)fputs(str, stderr);
663 }
664 
665 void perr_s(s1,s2)
666  char *s1,*s2;
667 {
668  fprintf(stderr,s1,s2);
669 }
670 
671 void perr_s2(s1,s2,s3)
672  char *s1,*s2,*s3;
673 {
674  fprintf(stderr,s1,s2,s3);
675 }
676 
677 void perr_i(str,i)
678  char *str;
679  long i;
680 {
681  fprintf(stderr,str,i);
682 }
683 
684 
685 long warning()
686 {
687  if (warningflag) perr("*** Warning: ");
688  return warningflag;
689 }
690 
691 
692 long warningx()
693 {
694  if (warningflag) perr("*** Warning");
695  return warningflag;
696 }
697 
698 
699 /* Main routine for report_error and report_warning */
700 void report_error_main(g,s,s2)
701  ptr_psi_term g;
702  char *s, *s2;
703 {
704  // FILE *f;
705 
706  perr_s2("*** %s: %s in '",s2,s);
708  perr("'.\n");
709 }
710 
711 
712 
713 /******** REPORT_ERROR(g,s)
714  Print an appropriate error message. G is the
715  psi-term which caused the error, S a message to print.
716  Format: '*** Error: %s in 'g'.'
717 */
718 void report_error(g,s)
719  ptr_psi_term g;
720  char *s;
721 {
722  report_error_main(g,s,"Error");
723 }
724 
725 
726 
727 /******** REPORTANDABORT(g,s)
728  Print an appropriate error message. G is the
729  psi-term which caused the error, S a message to print.
730  Format: '*** Error: %s in 'g'.'
731 */
732 long reportAndAbort(g,s)
733  ptr_psi_term g;
734  char *s;
735 {
736  report_error_main(g,s,"Error");
737  return abort_life(TRUE); // djd added TRUE
738 }
739 
740 
741 /******** REPORT_WARNING(g,s)
742  Print an appropriate error message. G is the
743  psi-term which caused the error, S a message to print.
744  Format: '*** Warning: %s in 'g'.'
745 */
746 void report_warning(g,s)
747  ptr_psi_term g;
748  char *s;
749 {
750  if (warningflag) report_error_main(g,s,"Warning");
751 }
752 
753 
754 /* Main routine for report_error2 and report_warning2 */
755 void report_error2_main(g,s,s2)
756  ptr_psi_term g;
757  char *s, *s2;
758 {
759  // FILE *f;
760 
761  perr_s("*** %s: argument '",s2);
763  perr_s("' %s.\n",s);
764 }
765 
766 
767 
768 /********* REPORT_ERROR2(g,s)
769  Like report_error, with a slightly different format.
770  Format: '*** Error: argument 'g' %s.'
771 */
772 void report_error2(g,s)
773  ptr_psi_term g;
774  char *s;
775 {
776  report_error2_main(g,s,"Error");
777 }
778 
779 
780 
781 /********* REPORT_WARNING2(g,s)
782  Like report_warning, with a slightly different format.
783  Format: '*** Warning: argument 'g' %s.'
784 */
786  ptr_psi_term g;
787  char *s;
788 {
789  if (warningflag) report_error2_main(g,s,"Warning");
790 }
791 
792 
793 
794 /* Give error message if there is an argument which cannot unify with */
795 /* a real number. */
796 void nonnum_warning(t,arg1,arg2)
797  ptr_psi_term t,arg1,arg2;
798 {
799  if (!curried && /* PVR 15.9.93 */
800  ((arg1 && !overlap_type(arg1->type,real)) ||
801  (arg2 && !overlap_type(arg2->type,real)))) {
802  report_warning(t,"non-numeric argument(s)");
803  }
804 }
805 
806 /********************************************************************/
807 
808 /* Error checking routines for bit_and, bit_or, shift, and modulo */
809 
810 long nonint_warning(arg, val, msg)
811  ptr_psi_term arg;
812  REAL val;
813  char *msg;
814 {
815  long err=FALSE;
816 
817  if (val!=floor(val)) {
818  report_warning2(arg, msg);
819  err=TRUE;
820  }
821  return err;
822 }
823 
824 long bit_and_warning(arg, val)
825  ptr_psi_term arg;
826  REAL val;
827 {
828  return nonint_warning(arg,val,"of bitwise 'and' operation is not an integer");
829 }
830 
831 long bit_or_warning(arg, val)
832  ptr_psi_term arg;
833  REAL val;
834 {
835  return nonint_warning(arg,val,"of bitwise 'or' operation is not an integer");
836 }
837 
838 long bit_not_warning(arg, val)
839  ptr_psi_term arg;
840  REAL val;
841 {
842  return nonint_warning(arg,val,"of bitwise 'not' operation is not an integer");
843 }
844 
845 long int_div_warning(arg, val)
846  ptr_psi_term arg;
847  REAL val;
848 {
849  return nonint_warning(arg,val,"of integer division is not an integer");
850 }
851 
852 long mod_warning(arg, val,zero)
853  ptr_psi_term arg;
854  REAL val;
855  int zero;
856 {
857  int err;
858 
859  err=nonint_warning(arg,val,"of modulo operation is not an integer");
860  if(!err && zero && val==0) {
861  Errorline("division by 0 in modulo operation\n");
862  err=TRUE;
863  }
864  return err;
865 }
866 
867 long shift_warning(dir, arg, val)
868  long dir;
869  ptr_psi_term arg;
870  REAL val;
871 {
872  if (dir)
873  return nonint_warning(arg,val,"of right shift operation is not an integer");
874  else
875  return nonint_warning(arg,val,"of left shift operation is not an integer");
876 }
877 
878 /********************************************************************/
long warningflag
Definition: error.c:16
void perr_s2(char *s1, char *s2, char *s3)
Definition: error.c:671
void stack_info(FILE *outfile)
Definition: error.c:58
static long depth_gs()
Definition: error.c:26
#define MAX_TRACE_INDENT
Definition: def_const.h:120
long verbose
Definition: error.c:19
long bit_and_warning(ptr_psi_term arg, REAL val)
Definition: error.c:824
void warningline(char *format,...)
Definition: error.c:327
static long depth_ts()
Definition: error.c:48
long shift_warning(long dir, ptr_psi_term arg, REAL val)
Definition: error.c:867
ptr_goal goal_stack
Definition: def_glob.h:50
#define NOTQUIET
Definition: def_macro.h:10
void perr_i(char *str, long i)
Definition: error.c:677
void outputline(char *format,...)
Definition: error.c:79
long psi_term_line_number
Definition: def_glob.h:268
void set_trace_to_prove()
Definition: error.c:639
string input_file_name
Definition: def_glob.h:40
long steptrace
Definition: error.c:21
void report_error2_main(ptr_psi_term g, char *s, char *s2)
Definition: error.c:755
void report_warning2(ptr_psi_term g, char *s)
Definition: error.c:785
void display_psi(FILE *s, ptr_psi_term t)
Definition: print.c:1460
void report_error_main(ptr_psi_term g, char *s, char *s2)
Definition: error.c:700
long warningx()
Definition: error.c:692
void new_trace(long newtrace)
Definition: error.c:619
void infoline(char *format,...)
Definition: error.c:245
void traceline(char *format,...)
Definition: error.c:157
void display_psi_stderr(ptr_psi_term t)
Definition: print.c:1438
ptr_choice_point next
Definition: def_struct.h:235
long bit_or_warning(ptr_psi_term arg, REAL val)
Definition: error.c:831
long overlap_type(ptr_definition t1, ptr_definition t2)
Definition: types.c:1486
#define REAL
Definition: def_const.h:72
FILE * outfile
Definition: def_glob.h:333
void perr(char *str)
Definition: error.c:659
long nonint_warning(ptr_psi_term arg, REAL val, char *msg)
Definition: error.c:810
void report_error2(ptr_psi_term g, char *s)
Definition: error.c:772
long abort_life(int nlflag)
Definition: built_ins.c:2124
void reset_step()
Definition: error.c:596
void new_step(long newstep)
Definition: error.c:629
void perr_s(char *s1, char *s2)
Definition: error.c:665
void Errorline(char *format,...)
Definition: error.c:414
long bit_not_warning(ptr_psi_term arg, REAL val)
Definition: error.c:838
ptr_stack undo_stack
Definition: def_glob.h:53
long goal_count
Definition: def_glob.h:152
ptr_definition real
Definition: def_glob.h:102
void tracing()
Definition: error.c:604
void print_code(FILE *s, ptr_int_list c)
Definition: print.c:147
#define TRUE
Definition: def_const.h:127
void report_error(ptr_psi_term g, char *s)
Definition: error.c:718
void print_def_type(def_type t)
Definition: types.c:21
long mod_warning(ptr_psi_term arg, REAL val, int zero)
Definition: error.c:852
long warning()
Definition: error.c:685
long int_div_warning(ptr_psi_term arg, REAL val)
Definition: error.c:845
#define FALSE
Definition: def_const.h:128
long stepcount
Definition: error.c:22
long quietflag
Definition: error.c:17
void toggle_step()
Definition: error.c:650
long curried
Definition: def_glob.h:223
long trace
Definition: error.c:18
long stepflag
Definition: error.c:20
FILE * output_stream
Definition: def_glob.h:41
long reportAndAbort(ptr_psi_term g, char *s)
Definition: error.c:732
static long depth_cs()
Definition: error.c:37
long parse_ok
Definition: def_glob.h:171
void toggle_trace()
Definition: error.c:644
void Syntaxerrorline(char *format,...)
Definition: error.c:498
ptr_stack next
Definition: def_struct.h:219
void print_operator_kind(FILE *s, long kind)
Definition: print.c:173
void init_trace()
Definition: error.c:587
ptr_choice_point choice_stack
Definition: def_glob.h:51
void nonnum_warning(ptr_psi_term t, ptr_psi_term arg1, ptr_psi_term arg2)
Definition: error.c:796
void report_warning(ptr_psi_term g, char *s)
Definition: error.c:746
#define assert(N)
Definition: memory.c:104
ptr_goal next
Definition: def_struct.h:227