Wild Life: error.c Source File

Wild Life 2.30

- Main Page
- Data Structures
- Files

- File List
- Globals

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