Wild Life  2.30
 All Data Structures Files Functions Variables Typedefs Macros
error.c
Go to the documentation of this file.
1 
6 /* Copyright 1991 Digital Equipment Corporation.
7  * All Rights Reserved.
8  *
9  * History:
10  * SCG 21 Tue Jun 2 14:15:36 1992
11  * added newTrace which allows a trace line to be one function call
12  * SCG 14 Wed May 27 13:37:51 1992
13  * added reportAndAbort() which is like report_error followed by
14  * an c_abort.
15  *****************************************************************/
16 
17 #include "defs.h"
18 
19 long warningflag=TRUE;
20 long quietflag=FALSE; /* 21.1 */
21 long trace=FALSE;
22 long verbose=FALSE; /* 21.1 */
23 long stepflag = 0;
24 long steptrace = 0;
25 long stepcount = 0;
26 
33 static long depth_gs()
34 {
35  long i=0;
36  ptr_goal g=goal_stack;
37 
38  while (g) { i++; g=g->next; }
39  return i;
40 }
41 
47 static long depth_cs()
48 {
49  long i=0;
50  ptr_choice_point c=choice_stack;
51 
52  while (c) { i++; c=c->next; }
53  return i;
54 }
55 
62 static long depth_ts()
63 {
64  ptr_stack t=undo_stack;
65  long i=0;
66 
67  while (t) { i++; t=t->next; }
68  return i;
69 }
70 
77 void stack_info(FILE *outfile)
78 {
79  /* Information about size of embedded stacks */
80  if (verbose) {
81  long gn,cn,tn;
82  fprintf(outfile,"*** Stack depths [");
83  gn=depth_gs();
84  cn=depth_cs();
85  tn=depth_ts();
86  fprintf(outfile,"%ld goal%s, %ld choice point%s, %ld trail entr%s",
87  gn,(gn!=1?"s":""),
88  cn,(cn!=1?"s":""),
89  tn,(tn!=1?"ies":"y"));
90  fprintf(outfile,"]\n");
91  }
92 }
93 
101 void outputline(char *format,...)
102 {
103  va_list VarArg;
104  // int l;
105  char buffer_loc[5];
106  char *p;
107  unsigned long lng2;
108  char *cptr;
109  ptr_int_list pil;
110  ptr_psi_term psi;
111  operator kind;
112  def_type t ;
113  va_start(VarArg,format);
114  // vinfoline(format,output_stream, VarArg);
115  // #define vinfoline(format, outfile, xxxx) {
116  for (p=format;p && *p; p++)
117  {
118  if (*p == '%')
119  {
120  p++;
121  switch (*p)
122  {
123  case 'd':
124  case 'x':
125  buffer_loc[0] = '%';
126  buffer_loc[1] = 'l';
127  buffer_loc[2] = *p;
128  buffer_loc[3] = 0;
129  lng2 = va_arg(VarArg, long);
130  fprintf(output_stream, buffer_loc, lng2);
131  break;
132  case 's':
133  buffer_loc[0] = '%';
134  buffer_loc[1] = *p;
135  buffer_loc[2] = 0;
136  cptr = va_arg(VarArg,char *);
137  fprintf(output_stream, buffer_loc, cptr);
138  break;
139  case 'C':
140  /* type coding as bin string */
141  pil = va_arg(VarArg,ptr_int_list);
142  print_code(output_stream,pil);
143  break;
144  case 'P':
145  psi = va_arg(VarArg,ptr_psi_term);
146  display_psi(output_stream,psi);
147  break;
148  case 'O':
149  kind = va_arg(VarArg,operator);
150  print_operator_kind(output_stream,kind);
151  break;
152  case 'T':
153  assert(output_stream==stderr);
154  t = va_arg(VarArg,def_type);
155  print_def_type(t);
156  break;
157  case 'E':
158  assert(output_stream==stderr);
159  perr_i("near line %ld",psi_term_line_number);
160  if (strcmp(input_file_name,"stdin")) {
161  perr_s(" in file \042%s\042",input_file_name);
162  }
163  parse_ok=FALSE;
164  break;
165  case '%':
166  (void)putc(*p,output_stream);
167  break;
168  default:
169  fprintf(output_stream,"<%c follows %% : report bug >", *p);
170  break;
171  }
172  }
173  else
174  (void)putc(*p,output_stream);
175  }
176  va_end(VarArg);
177 }
178 
186 void traceline(char *format,...)
187 {
188  va_list VarArg;
189  // int l;
190  char buffer_loc[5];
191  char *p;
192  unsigned long lng2;
193  char *cptr;
194  ptr_int_list pil;
195  ptr_psi_term psi;
196  operator kind;
197  def_type t ;
198 
199  va_start(VarArg,format);
200 
201  if (trace) // DJD
202  {
203  /* RM: Nov 10 1993 */
204 
205  if ((trace == 2) && (format[0] != 'p')) return;
206  tracing();
207 
208  // vinfoline(format, stdout, VarArg);
209  // #define vinfoline(format, outfile, xxxx) {
210  for (p=format;p && *p; p++)
211  {
212  if (*p == '%')
213  {
214  p++;
215  switch (*p)
216  {
217  case 'd':
218  case 'x':
219  buffer_loc[0] = '%';
220  buffer_loc[1] = 'l';
221  buffer_loc[2] = *p;
222  buffer_loc[3] = 0;
223  lng2 = va_arg(VarArg, long);
224  fprintf(stdout, buffer_loc, lng2);
225  break;
226  case 's':
227  buffer_loc[0] = '%';
228  buffer_loc[1] = *p;
229  buffer_loc[2] = 0;
230  cptr = va_arg(VarArg,char *);
231  fprintf(stdout, buffer_loc, cptr);
232  break;
233  case 'C':
234  /* type coding as bin string */
235  pil = va_arg(VarArg,ptr_int_list);
236  print_code(stdout,pil);
237  break;
238  case 'P':
239  psi = va_arg(VarArg,ptr_psi_term);
240  display_psi(stdout,psi);
241  break;
242  case 'O':
243  kind = va_arg(VarArg,operator);
244  print_operator_kind(stdout,kind);
245  break;
246  case 'T':
247  assert(stdout==stderr);
248  t = va_arg(VarArg,def_type);
249  print_def_type(t);
250  break;
251  case 'E':
252  assert(stdout==stderr);
253  perr_i("near line %ld",psi_term_line_number);
254  if (strcmp(input_file_name,"stdin")) {
255  perr_s(" in file \042%s\042",input_file_name);
256  }
257  parse_ok=FALSE;
258  break;
259  case '%':
260  (void)putc(*p,stdout);
261  break;
262  default:
263  fprintf(stdout,"<%c follows %% : report bug >", *p);
264  break;
265  }
266  }
267  else
268  (void)putc(*p,stdout);
269  }
270  }
271  va_end(VarArg);
272 }
273 
281 void infoline(char *format,...)
282 {
283  va_list VarArg;
284  // int l;
285  char buffer_loc[5];
286  char *p;
287  unsigned long lng2;
288  char *cptr;
289  ptr_int_list pil;
290  ptr_psi_term psi;
291  operator kind;
292  def_type t ;
293 
294  va_start(VarArg,format);
295  if (NOTQUIET)
296  {
297 
298  // vinfoline(format, stdout, VarArg);
299  //#define vinfoline(format, outfile, xxxx) {
300  for (p=format;p && *p; p++)
301  {
302  if (*p == '%')
303  {
304  p++;
305  switch (*p)
306  {
307  case 'd':
308  case 'x':
309  buffer_loc[0] = '%';
310  buffer_loc[1] = 'l';
311  buffer_loc[2] = *p;
312  buffer_loc[3] = 0;
313  lng2 = va_arg(VarArg,long);
314  fprintf(stdout, buffer_loc, lng2);
315  break;
316  case 's':
317  buffer_loc[0] = '%';
318  buffer_loc[1] = *p;
319  buffer_loc[2] = 0;
320  cptr = va_arg(VarArg,char *);
321  fprintf(stdout, buffer_loc, cptr);
322  break;
323  case 'C':
324  /* type coding as bin string */
325  pil = va_arg(VarArg,ptr_int_list);
326  print_code(stdout,pil);
327  break;
328  case 'P':
329  psi = va_arg(VarArg,ptr_psi_term);
330  display_psi(stdout,psi);
331  break;
332  case 'O':
333  kind = va_arg(VarArg,operator);
334  print_operator_kind(stdout,kind);
335  break;
336  case 'T':
337  assert(stdout==stderr);
338  t = va_arg(VarArg,def_type);
339  print_def_type(t);
340  break;
341  case 'E':
342  assert(stdout==stderr);
343  perr_i("near line %ld",psi_term_line_number);
344  if (strcmp(input_file_name,"stdin")) {
345  perr_s(" in file 042%s042",input_file_name);
346  }
347  parse_ok=FALSE;
348  break;
349  case '%':
350  (void)putc(*p,stdout);
351  break;
352  default:
353  fprintf(stdout,"<%c follows %% : report bug >", *p);
354  break;
355  }
356  }
357  else
358  (void)putc(*p,stdout);
359  }
360  }
361  va_end(VarArg);
362 }
363 
371 void warningline(char *format,...)
372 {
373  va_list VarArg;
374  // int l;
375  char buffer_loc[5];
376  char *p;
377  unsigned long lng2;
378  char *cptr;
379  ptr_int_list pil;
380  ptr_psi_term psi;
381  operator kind;
382  def_type t ;
383 
384  va_start(VarArg,format);
385 
386  if (warningflag) { // macro would not work
387 
388 
389  if(quietflag) return; /* RM: Sep 24 1993 */
390  fprintf(stderr,"*** Warning: ");
391  // vinfoline(format, stderr, VarArg);
392  // #define vinfoline(format, stderr, xxxx) {
393  for (p=format;p && *p; p++)
394  {
395  if (*p == '%')
396  {
397  p++;
398  switch (*p)
399  {
400  case 'd':
401  case 'x':
402  buffer_loc[0] = '%';
403  buffer_loc[1] = 'l';
404  buffer_loc[2] = *p;
405  buffer_loc[3] = 0;
406  lng2 = va_arg(VarArg,long);
407  fprintf(stderr, buffer_loc, lng2);
408  break;
409  case 's':
410  buffer_loc[0] = '%';
411  buffer_loc[1] = *p;
412  buffer_loc[2] = 0;
413  cptr = va_arg(VarArg,char *);
414  fprintf(stderr, buffer_loc, cptr);
415  break;
416  case 'C':
417  /* type coding as bin string */
418  pil = va_arg(VarArg,ptr_int_list);
419  print_code(stderr,pil);
420  break;
421  case 'P':
422  psi = va_arg(VarArg,ptr_psi_term);
423  display_psi(stderr,psi);
424  break;
425  case 'O':
426  kind = va_arg(VarArg,operator);
427  print_operator_kind(stderr,kind);
428  break;
429  case 'T':
430  assert(stderr==stderr);
431  t = va_arg(VarArg,def_type);
432  print_def_type(t);
433  break;
434  case 'E':
435  assert(stderr==stderr);
436  perr_i("near line %ld",psi_term_line_number);
437  if (strcmp(input_file_name,"stdin")) {
438  perr_s(" in file 042%s042",input_file_name);
439  }
440  parse_ok=FALSE;
441  break;
442  case '%':
443  (void)putc(*p,stderr);
444  break;
445  default:
446  fprintf(stderr,"<%c follows %% : report bug >", *p);
447  break;
448  }
449  }
450  else
451  (void)putc(*p,stderr);
452  }
453  }
454  va_end(VarArg);
455 }
456 
465 void Errorline(char *format,...)
466 {
467  va_list VarArg;
468  // int l;
469  char buffer_loc[5];
470  char *p;
471  unsigned long lng2;
472  char *cptr;
473  ptr_int_list pil;
474  ptr_psi_term psi;
475  operator kind;
476  def_type t ;
477 
478  va_start(VarArg,format);
479  // fprintf(stderr,"format = %lx %s\n",(long)format,format);fflush(stdout);
480  fprintf(stderr,"*** Error: ");
481  // fprintf(stderr,"format2 = %lx %s\n",(long)format,format);
482  // vinfoline(format, stderr, VarArg);
483  //#define vinfoline(format, stderr, xxxx) {
484  for (p=format;p && *p; p++)
485  {
486  if (*p == '%')
487  {
488  p++;
489  switch (*p)
490  {
491  case 'd':
492  case 'x':
493  buffer_loc[0] = '%';
494  buffer_loc[1] = 'l';
495  buffer_loc[2] = *p;
496  buffer_loc[3] = 0;
497  lng2 = va_arg(VarArg,long);
498  fprintf(stderr, buffer_loc, lng2);
499  break;
500  case 's':
501  buffer_loc[0] = '%';
502  buffer_loc[1] = *p;
503  buffer_loc[2] = 0;
504  cptr = va_arg(VarArg,char *);
505  fprintf(stderr, buffer_loc, cptr);
506  break;
507  case 'C':
508  /* type coding as bin string */
509  pil = va_arg(VarArg,ptr_int_list);
510  print_code(stderr,pil);
511  break;
512  case 'P':
513  psi = va_arg(VarArg,ptr_psi_term);
514  display_psi(stderr,psi);
515  break;
516  case 'O':
517  kind = va_arg(VarArg,operator);
518  print_operator_kind(stderr,kind);
519  break;
520  case 'T':
521  assert(stderr==stderr);
522  t = va_arg(VarArg,def_type);
523  print_def_type(t);
524  break;
525  case 'E':
526  assert(stderr==stderr);
527  perr_i("near line %ld",psi_term_line_number);
528  if (strcmp(input_file_name,"stdin")) {
529  perr_s(" in file \042%s\042",input_file_name);
530  }
531  parse_ok=FALSE;
532  break;
533  case '%':
534  (void)putc(*p,stderr);
535  break;
536  default:
537  fprintf(stderr,"<%c follows %% : report bug >", *p);
538  break;
539  }
540  }
541  else
542  (void)putc(*p,stderr);
543  }
544  va_end(VarArg);
545 #ifdef CLIFE
546  exit(0);
547 #endif
548 }
549 
557 void Syntaxerrorline(char *format,...)
558 {
559  va_list VarArg;
560  // int l;
561  char buffer_loc[5];
562  char *p;
563  unsigned long lng2;
564  char *cptr;
565  ptr_int_list pil;
566  ptr_psi_term psi;
567  operator kind;
568  def_type t ;
569  va_start(VarArg,format);
570  // fprintf(stderr,"format = %lx %s\n",(long)format,format);fflush(stdout);
571  if(parse_ok) { /* RM: Feb 1 1993 */
572  parse_ok=FALSE; /* RM: Feb 1 1993 */
573  fprintf(stderr,"*** Syntax error: ");
574  // fprintf(stderr,"format2 = %lx %s\n",(long)format,format);
575  // vinfoline(format, stderr, VarArg);
576  //#define vinfoline(format, outfile, xxxx) {
577  for (p=format;p && *p; p++)
578  {
579  if (*p == '%')
580  {
581  p++;
582  switch (*p)
583  {
584  case 'd':
585  case 'x':
586  buffer_loc[0] = '%';
587  buffer_loc[1] = 'l';
588  buffer_loc[2] = *p;
589  buffer_loc[3] = 0;
590  lng2 = va_arg(VarArg,long);
591  fprintf(stderr, buffer_loc, lng2);
592  break;
593  case 's':
594  buffer_loc[0] = '%';
595  buffer_loc[1] = *p;
596  buffer_loc[2] = 0;
597  cptr = va_arg(VarArg,char *);
598  fprintf(stderr, buffer_loc, cptr);
599  break;
600  case 'C':
601  /* type coding as bin string */
602  pil = va_arg(VarArg,ptr_int_list);
603  print_code(stderr,pil);
604  break;
605  case 'P':
606  psi = va_arg(VarArg,ptr_psi_term);
607  display_psi(stderr,psi);
608  break;
609  case 'O':
610  kind = va_arg(VarArg,operator);
611  print_operator_kind(stderr,kind);
612  break;
613  case 'T':
614  assert(stderr==stderr);
615  t = va_arg(VarArg,def_type);
616  print_def_type(t);
617  break;
618  case 'E':
619  assert(stderr==stderr);
620  perr_i("near line %ld",psi_term_line_number);
621  if (strcmp(input_file_name,"stdin")) {
622  perr_s(" in file \042%s\042",input_file_name);
623  }
624  parse_ok=FALSE;
625  break;
626  case '%':
627  (void)putc(*p,stderr);
628  break;
629  default:
630  fprintf(stderr,"<%c follows %% : report bug >", *p);
631  break;
632  }
633  }
634  else
635  (void)putc(*p,stderr);
636  }
637  }
638  va_end(VarArg);
639 }
640 
641 /********************************************************************/
642 
643 /* Utilities for tracing and single stepping */
644 
651 void init_trace()
652 {
653  trace=FALSE;
654  stepflag=FALSE;
655  stepcount=0;
656 }
657 
665 void reset_step()
666 {
667  if (stepcount>0) {
668  stepcount=0;
669  stepflag=TRUE;
670  }
671 }
672 
678 void tracing()
679 {
680  long i;
681  long indent_loc;
682 
683  printf("T%04ld",goal_count);
684  printf(" C%02ld",depth_cs());
685  indent_loc=depth_gs();
686  if (indent_loc>=MAX_TRACE_INDENT) printf(" G%02ld",indent_loc);
687  indent_loc = indent_loc % MAX_TRACE_INDENT;
688  for (i=indent_loc; i>=0; i--) printf(" ");
689  steptrace=TRUE;
690 }
691 
698 void new_trace(long newtrace)
699 {
700  trace = newtrace;
701  printf("*** Tracing is turned ");
702  printf(trace?"on.":"off.");
703  if (trace == 2) printf(" Only for Proves");
704  printf("\n");
705 }
706 
713 void new_step(long newstep)
714 {
715  stepflag = newstep;
716  printf("*** Single stepping is turned ");
717  printf(stepflag?"on.\n":"off.\n");
718  new_trace(stepflag);
719  steptrace=FALSE;
720 }
721 
727 void set_trace_to_prove()
728 {
729  new_trace(2);
730 }
731 
737 void toggle_trace()
738 {
739  new_trace(trace?0:1);
740 }
741 
747 void toggle_step()
748 {
749  new_step(!stepflag);
750 }
751 
752 /********************************************************************/
753 
754 /* Old error printing routines -- these should be superceded by Errorline */
755 // They are still used in places - 12/11/2016 DJD
756 
763 void perr(char *str)
764 {
765  (void)fputs(str, stderr);
766 }
767 
775 void perr_s(char *s1,char *s2)
776 {
777  fprintf(stderr,s1,s2);
778 }
779 
788 void perr_s2(char *s1,char *s2,char *s3)
789 {
790  fprintf(stderr,s1,s2,s3);
791 }
792 
800 void perr_i(char *str,long i)
801 {
802  fprintf(stderr,str,i);
803 }
804 
810 long warning()
811 {
812  if (warningflag) perr("*** Warning: ");
813  return warningflag;
814 }
815 
821 long warningx()
822 {
823  if (warningflag) perr("*** Warning");
824  return warningflag;
825 }
826 
836 void report_error_main(ptr_psi_term g,char *s,char *s2)
837 {
838  // FILE *f;
839 
840  perr_s2("*** %s: %s in '",s2,s);
841  display_psi_stderr(g);
842  perr("'.\n");
843 }
844 
856 void report_error(ptr_psi_term g,char *s)
857 {
858  report_error_main(g,s,"Error");
859 }
860 
872 long reportAndAbort(ptr_psi_term g,char *s)
873 {
874  report_error_main(g,s,"Error");
875  return abort_life(TRUE); // djd added TRUE
876 }
877 
878 
890 void report_warning(ptr_psi_term g,char *s)
891 {
892  if (warningflag) report_error_main(g,s,"Warning");
893 }
894 
904 void report_error2_main(ptr_psi_term g,char *s,char *s2)
905 {
906  // FILE *f;
907 
908  perr_s("*** %s: argument '",s2);
909  display_psi_stderr(g);
910  perr_s("' %s.\n",s);
911 }
912 
923 void report_error2(ptr_psi_term g,char *s)
924 {
925  report_error2_main(g,s,"Error");
926 }
927 
938 void report_warning2(ptr_psi_term g,char *s)
939 {
940  if (warningflag) report_error2_main(g,s,"Warning");
941 }
942 
953 void nonnum_warning(ptr_psi_term t,ptr_psi_term arg1,ptr_psi_term arg2)
954 {
955  if (!curried && /* PVR 15.9.93 */
956  ((arg1 && !overlap_type(arg1->type,real)) ||
957  (arg2 && !overlap_type(arg2->type,real)))) {
958  report_warning(t,"non-numeric argument(s)");
959  }
960 }
961 
962 /********************************************************************/
963 
964 /* Error checking routines for bit_and, bit_or, shift, and modulo */
965 
974 long nonint_warning(ptr_psi_term arg, REAL val, char *msg)
975 {
976  long err=FALSE;
977 
978  if (val!=floor(val)) {
979  report_warning2(arg, msg);
980  err=TRUE;
981  }
982  return err;
983 }
984 
992 long bit_and_warning(ptr_psi_term arg, REAL val)
993 {
994  return nonint_warning(arg,val,"of bitwise 'and' operation is not an integer");
995 }
996 
1004 long bit_or_warning(ptr_psi_term arg, REAL val)
1005 {
1006  return nonint_warning(arg,val,"of bitwise 'or' operation is not an integer");
1007 }
1008 
1016 long bit_not_warning(ptr_psi_term arg, REAL val)
1017 {
1018  return nonint_warning(arg,val,"of bitwise 'not' operation is not an integer");
1019 }
1020 
1028 long int_div_warning(ptr_psi_term arg, REAL val)
1029 {
1030  return nonint_warning(arg,val,"of integer division is not an integer");
1031 }
1032 
1041 long mod_warning(ptr_psi_term arg, REAL val,int zero)
1042 {
1043  int err;
1044 
1045  err=nonint_warning(arg,val,"of modulo operation is not an integer");
1046  if(!err && zero && val==0) {
1047  Errorline("division by 0 in modulo operation\n");
1048  err=TRUE;
1049  }
1050  return err;
1051 }
1052 
1061 long shift_warning(long dir, ptr_psi_term arg, REAL val)
1062 {
1063  if (dir)
1064  return nonint_warning(arg,val,"of right shift operation is not an integer");
1065  else
1066  return nonint_warning(arg,val,"of left shift operation is not an integer");
1067 }
1068 
1069 /********************************************************************/
warningflag
long warningflag
Definition: error.c:19
perr_s2
void perr_s2(char *s1, char *s2, char *s3)
perr_s2
Definition: error.c:788
stack_info
void stack_info(FILE *outfile)
stack_info
Definition: error.c:77
depth_gs
static long depth_gs()
depth_gs
Definition: error.c:33
MAX_TRACE_INDENT
#define MAX_TRACE_INDENT
Maximum goal indentation during tracing.
Definition: def_const.h:247
verbose
long verbose
Definition: error.c:22
bit_and_warning
long bit_and_warning(ptr_psi_term arg, REAL val)
bit_and_warning
Definition: error.c:992
warningline
void warningline(char *format,...)
warningline
Definition: error.c:371
depth_ts
static long depth_ts()
depth_ts
Definition: error.c:62
shift_warning
long shift_warning(long dir, ptr_psi_term arg, REAL val)
shift_warning
Definition: error.c:1061
wl_choice_point
Definition: def_struct.h:246
goal_stack
ptr_goal goal_stack
Definition: def_glob.h:1025
NOTQUIET
#define NOTQUIET
Definition: def_macro.h:15
perr_i
void perr_i(char *str, long i)
perr_i
Definition: error.c:800
outputline
void outputline(char *format,...)
void outputline(char *format,...)
Definition: error.c:101
wl_goal
Definition: def_struct.h:237
psi_term_line_number
long psi_term_line_number
Definition: def_glob.h:909
set_trace_to_prove
void set_trace_to_prove()
set_trace_to_prove
Definition: error.c:727
input_file_name
string input_file_name
Definition: def_glob.h:1016
steptrace
long steptrace
Definition: error.c:24
report_error2_main
void report_error2_main(ptr_psi_term g, char *s, char *s2)
report_error2_main
Definition: error.c:904
report_warning2
void report_warning2(ptr_psi_term g, char *s)
report_warning2
Definition: error.c:938
display_psi
void display_psi(FILE *s, ptr_psi_term t)
display_psi
Definition: print.c:1579
report_error_main
void report_error_main(ptr_psi_term g, char *s, char *s2)
report_error_main
Definition: error.c:836
warningx
long warningx()
warningx
Definition: error.c:821
defs.h
includes
wl_psi_term
Definition: def_struct.h:177
wl_stack
Definition: def_struct.h:230
new_trace
void new_trace(long newtrace)
new_trace
Definition: error.c:698
infoline
void infoline(char *format,...)
infoline
Definition: error.c:281
traceline
void traceline(char *format,...)
traceline
Definition: error.c:186
REAL
#define REAL
Which C type to use to represent reals and integers in Wild_Life.
Definition: def_const.h:132
parse_ok
long parse_ok
indicates whether there was a syntax error
Definition: def_glob.h:765
display_psi_stderr
void display_psi_stderr(ptr_psi_term t)
display_psi_stderr
Definition: print.c:1550
wl_choice_point::next
ptr_choice_point next
Definition: def_struct.h:250
bit_or_warning
long bit_or_warning(ptr_psi_term arg, REAL val)
bit_or_warning
Definition: error.c:1004
overlap_type
long overlap_type(ptr_definition t1, ptr_definition t2)
overlap_type
Definition: types.c:1579
outfile
FILE * outfile
Definition: def_glob.h:974
perr
void perr(char *str)
perr
Definition: error.c:763
nonint_warning
long nonint_warning(ptr_psi_term arg, REAL val, char *msg)
nonint_warning
Definition: error.c:974
report_error2
void report_error2(ptr_psi_term g, char *s)
report_error2
Definition: error.c:923
abort_life
long abort_life(int nlflag)
abort_life
Definition: built_ins.c:2259
reset_step
void reset_step()
reset_step
Definition: error.c:665
new_step
void new_step(long newstep)
new_step
Definition: error.c:713
perr_s
void perr_s(char *s1, char *s2)
perr_s
Definition: error.c:775
wl_int_list
Definition: def_struct.h:84
real
ptr_definition real
symbol in bi module
Definition: def_glob.h:375
Errorline
void Errorline(char *format,...)
Errorline.
Definition: error.c:465
bit_not_warning
long bit_not_warning(ptr_psi_term arg, REAL val)
bit_not_warning
Definition: error.c:1016
undo_stack
ptr_stack undo_stack
Definition: def_glob.h:1027
goal_count
long goal_count
Definition: def_glob.h:678
tracing
void tracing()
tracing
Definition: error.c:678
print_code
void print_code(FILE *s, ptr_int_list c)
print_code
Definition: print.c:167
TRUE
#define TRUE
Standard boolean.
Definition: def_const.h:268
report_error
void report_error(ptr_psi_term g, char *s)
report_error
Definition: error.c:856
print_def_type
void print_def_type(def_type t)
print_def_type
Definition: types.c:24
mod_warning
long mod_warning(ptr_psi_term arg, REAL val, int zero)
mod_warning
Definition: error.c:1041
warning
long warning()
warning
Definition: error.c:810
int_div_warning
long int_div_warning(ptr_psi_term arg, REAL val)
int_div_warning
Definition: error.c:1028
FALSE
#define FALSE
Standard boolean.
Definition: def_const.h:275
stepcount
long stepcount
Definition: error.c:25
quietflag
long quietflag
Definition: error.c:20
toggle_step
void toggle_step()
toggle_step
Definition: error.c:747
wl_definition
Definition: def_struct.h:145
curried
long curried
Definition: def_glob.h:868
trace
long trace
Definition: error.c:21
stepflag
long stepflag
Definition: error.c:23
output_stream
FILE * output_stream
Definition: def_glob.h:1017
reportAndAbort
long reportAndAbort(ptr_psi_term g, char *s)
reportAndAbort
Definition: error.c:872
depth_cs
static long depth_cs()
depth_cs
Definition: error.c:47
toggle_trace
void toggle_trace()
toggle_trace
Definition: error.c:737
Syntaxerrorline
void Syntaxerrorline(char *format,...)
Syntaxerrorline.
Definition: error.c:557
wl_psi_term::type
ptr_definition type
Definition: def_struct.h:181
wl_stack::next
ptr_stack next
Definition: def_struct.h:234
print_operator_kind
void print_operator_kind(FILE *s, long kind)
print_operator_kind
Definition: print.c:192
init_trace
void init_trace()
init_trace
Definition: error.c:651
choice_stack
ptr_choice_point choice_stack
Definition: def_glob.h:1026
nonnum_warning
void nonnum_warning(ptr_psi_term t, ptr_psi_term arg1, ptr_psi_term arg2)
nonnum_warning
Definition: error.c:953
report_warning
void report_warning(ptr_psi_term g, char *s)
report_warning
Definition: error.c:890
assert
#define assert(N)
Definition: memory.c:114
wl_goal::next
ptr_goal next
Definition: def_struct.h:242
Generated on Thu Dec 22 2016 20:59:54 for Wild Life by   doxygen 1.8.6