Wild Life: error.c Source File

Wild Life 2.29

- 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 /* 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
16 long warningflag=TRUE;
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;
29 ptr_goal g=goal_stack;
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;
40 ptr_choice_point c=choice_stack;
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 {
50 ptr_stack t=undo_stack;
51 long i=0;
52
53 while (t) { i++; t=t->next; }
54 return i;
55 }
56
57
58 void stack_info(outfile)
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);
120 print_code(output_stream,pil);
121 break;
122 case 'P':
123 psi = va_arg(VarArg,ptr_psi_term);
124 display_psi(output_stream,psi);
125 break;
126 case 'O':
127 kind = va_arg(VarArg,operator);
128 print_operator_kind(output_stream,kind);
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 */
587 void init_trace()
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 */
596 void reset_step()
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");
635 new_trace(stepflag);
636 steptrace=FALSE;
637 }
638
639 void set_trace_to_prove()
640 {
641 new_trace(2);
642 }
643
644 void toggle_trace()
645 {
646 new_trace(trace?0:1);
647 }
648
649
650 void toggle_step()
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);
707 display_psi_stderr(g);
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);
762 display_psi_stderr(g);
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 */
785 void report_warning2(g,s)
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 /********************************************************************/
warningflag
long warningflag
Definition: error.c:16
perr_s2
void perr_s2(char *s1, char *s2, char *s3)
Definition: error.c:671
stack_info
void stack_info(FILE *outfile)
Definition: error.c:58
depth_gs
static long depth_gs()
Definition: error.c:26
MAX_TRACE_INDENT
#define MAX_TRACE_INDENT
Definition: def_const.h:120
verbose
long verbose
Definition: error.c:19
bit_and_warning
long bit_and_warning(ptr_psi_term arg, REAL val)
Definition: error.c:824
warningline
void warningline(char *format,...)
Definition: error.c:327
depth_ts
static long depth_ts()
Definition: error.c:48
shift_warning
long shift_warning(long dir, ptr_psi_term arg, REAL val)
Definition: error.c:867
wl_choice_point
Definition: def_struct.h:231
goal_stack
ptr_goal goal_stack
Definition: def_glob.h:50
NOTQUIET
#define NOTQUIET
Definition: def_macro.h:10
perr_i
void perr_i(char *str, long i)
Definition: error.c:677
outputline
void outputline(char *format,...)
Definition: error.c:79
wl_goal
Definition: def_struct.h:222
psi_term_line_number
long psi_term_line_number
Definition: def_glob.h:268
set_trace_to_prove
void set_trace_to_prove()
Definition: error.c:639
input_file_name
string input_file_name
Definition: def_glob.h:40
steptrace
long steptrace
Definition: error.c:21
report_error2_main
void report_error2_main(ptr_psi_term g, char *s, char *s2)
Definition: error.c:755
report_warning2
void report_warning2(ptr_psi_term g, char *s)
Definition: error.c:785
display_psi
void display_psi(FILE *s, ptr_psi_term t)
Definition: print.c:1460
report_error_main
void report_error_main(ptr_psi_term g, char *s, char *s2)
Definition: error.c:700
warningx
long warningx()
Definition: error.c:692
defs.h
wl_psi_term
Definition: def_struct.h:161
wl_stack
Definition: def_struct.h:215
new_trace
void new_trace(long newtrace)
Definition: error.c:619
infoline
void infoline(char *format,...)
Definition: error.c:245
traceline
void traceline(char *format,...)
Definition: error.c:157
display_psi_stderr
void display_psi_stderr(ptr_psi_term t)
Definition: print.c:1438
wl_choice_point::next
ptr_choice_point next
Definition: def_struct.h:235
bit_or_warning
long bit_or_warning(ptr_psi_term arg, REAL val)
Definition: error.c:831
overlap_type
long overlap_type(ptr_definition t1, ptr_definition t2)
Definition: types.c:1486
REAL
#define REAL
Definition: def_const.h:72
outfile
FILE * outfile
Definition: def_glob.h:333
perr
void perr(char *str)
Definition: error.c:659
nonint_warning
long nonint_warning(ptr_psi_term arg, REAL val, char *msg)
Definition: error.c:810
report_error2
void report_error2(ptr_psi_term g, char *s)
Definition: error.c:772
abort_life
long abort_life(int nlflag)
Definition: built_ins.c:2124
reset_step
void reset_step()
Definition: error.c:596
new_step
void new_step(long newstep)
Definition: error.c:629
perr_s
void perr_s(char *s1, char *s2)
Definition: error.c:665
wl_int_list
Definition: def_struct.h:53
Errorline
void Errorline(char *format,...)
Definition: error.c:414
bit_not_warning
long bit_not_warning(ptr_psi_term arg, REAL val)
Definition: error.c:838
undo_stack
ptr_stack undo_stack
Definition: def_glob.h:53
goal_count
long goal_count
Definition: def_glob.h:152
real
ptr_definition real
Definition: def_glob.h:102
tracing
void tracing()
Definition: error.c:604
print_code
void print_code(FILE *s, ptr_int_list c)
Definition: print.c:147
TRUE
#define TRUE
Definition: def_const.h:127
report_error
void report_error(ptr_psi_term g, char *s)
Definition: error.c:718
print_def_type
void print_def_type(def_type t)
Definition: types.c:21
mod_warning
long mod_warning(ptr_psi_term arg, REAL val, int zero)
Definition: error.c:852
warning
long warning()
Definition: error.c:685
int_div_warning
long int_div_warning(ptr_psi_term arg, REAL val)
Definition: error.c:845
FALSE
#define FALSE
Definition: def_const.h:128
stepcount
long stepcount
Definition: error.c:22
quietflag
long quietflag
Definition: error.c:17
toggle_step
void toggle_step()
Definition: error.c:650
wl_definition
Definition: def_struct.h:121
curried
long curried
Definition: def_glob.h:223
trace
long trace
Definition: error.c:18
stepflag
long stepflag
Definition: error.c:20
output_stream
FILE * output_stream
Definition: def_glob.h:41
reportAndAbort
long reportAndAbort(ptr_psi_term g, char *s)
Definition: error.c:732
depth_cs
static long depth_cs()
Definition: error.c:37
parse_ok
long parse_ok
Definition: def_glob.h:171
toggle_trace
void toggle_trace()
Definition: error.c:644
Syntaxerrorline
void Syntaxerrorline(char *format,...)
Definition: error.c:498
wl_stack::next
ptr_stack next
Definition: def_struct.h:219
print_operator_kind
void print_operator_kind(FILE *s, long kind)
Definition: print.c:173
init_trace
void init_trace()
Definition: error.c:587
choice_stack
ptr_choice_point choice_stack
Definition: def_glob.h:51
nonnum_warning
void nonnum_warning(ptr_psi_term t, ptr_psi_term arg1, ptr_psi_term arg2)
Definition: error.c:796
report_warning
void report_warning(ptr_psi_term g, char *s)
Definition: error.c:746
assert
#define assert(N)
Definition: memory.c:104
wl_goal::next
ptr_goal next
Definition: def_struct.h:227