home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / lifeos2.zip / LIFE-1.02 / SOURCE / ERROR.C < prev    next >
C/C++ Source or Header  |  1996-06-18  |  11KB  |  572 lines
  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. #ifndef lint
  14. static char vcid[] = "$Id: error.c,v 1.3 1995/07/11 01:53:03 duchier Exp $";
  15. #endif /* lint */
  16.  
  17. #include "extern.h"
  18. #include "print.h"
  19. #include "types.h"
  20. #include "login.h"
  21. #include "lefun.h"
  22. #include "parser.h" /*  RM: Feb  1 1993  */
  23. #ifndef OS2_PORT
  24. #include "built_ins.h"
  25. #else
  26. #include "built_in.h"
  27. #endif
  28.  
  29. #ifdef OS2_PORT
  30. #define VarArgInit(format) va_start(VarArg, format); 
  31.  
  32. #define VarArgNext(t)    va_arg(VarArg, t)
  33. #define VarArgEnd()    va_end(VarArg)
  34. #define vinfoline(format, outfile, xxxx)  { \
  35.   for (p=format;p &&  *p; p++) \
  36.   { \
  37.     if (*p == '%') \
  38.     { \ 
  39.       p++; \
  40.       switch (*p) \
  41.       { \
  42.       case 'd': \
  43.       case 'x': \
  44.         buffer[0] = '%'; \
  45.         buffer[1] = *p; \
  46.         buffer[2] = 0; \
  47.         lng2 = VarArgNext(unsigned long); \
  48.         fprintf(outfile, buffer, lng2); \
  49.         break; \
  50.       case 's': \
  51.         buffer[0] = '%'; \
  52.         buffer[1] = *p; \
  53.         buffer[2] = 0; \
  54.         cptr = VarArgNext(char *); \
  55.         fprintf(outfile, buffer, cptr); \
  56.         break; \
  57.       case 'C': \
  58.         /* type coding as bin string */ \
  59.         pil = VarArgNext(ptr_int_list); \
  60.         print_code(outfile,pil); \
  61.         break; \
  62.       case 'P': \
  63.         psi = VarArgNext(ptr_psi_term); \
  64.         display_psi(outfile,psi); \
  65.         break; \
  66.       case 'O': \
  67.         kind = VarArgNext(operator); \
  68.         print_operator_kind(outfile,kind); \
  69.         break; \
  70.       case 'T': \
  71.         assert(outfile==stderr); \
  72.         t = VarArgNext(def_type); \
  73.         print_def_type(t); \
  74.         break; \
  75.       case 'E': \
  76.         assert(outfile==stderr); \
  77.         psi_term_error(); \
  78.         break; \
  79.       case '%': \
  80.         putc(*p,outfile); \
  81.         break; \
  82.       default: \
  83.         fprintf(outfile,"<%c follows %% : report bug >", *p); \
  84.         break; \
  85.       } \
  86.     } \
  87.     else \
  88.       putc(*p,outfile); \
  89.   } \
  90.   VarArgEnd(); \
  91. } 
  92. #endif
  93.  
  94.  
  95. #include "error.h"
  96.  
  97. long warningflag=TRUE;
  98. long quietflag=FALSE; /* 21.1 */
  99. long trace=FALSE;
  100. long verbose=FALSE; /* 21.1 */
  101. long stepflag;
  102. long steptrace;
  103. long stepcount;
  104.  
  105. /* Depth of goal stack */
  106. static long depth_gs()
  107. {
  108.   long i=0;
  109.   ptr_goal g=goal_stack;
  110.  
  111.   while (g) { i++; g=g->next; }
  112.   return i;
  113. }
  114.  
  115.  
  116. /* Depth of choice point stack */
  117. static long depth_cs()
  118. {
  119.   long i=0;
  120.   ptr_choice_point c=choice_stack;
  121.  
  122.   while (c) { i++; c=c->next; }
  123.   return i;
  124. }
  125.  
  126.  
  127. /* Depth of trail (undo) stack */
  128. static long depth_ts()
  129. {
  130.   ptr_stack t=undo_stack;
  131.   long i=0;
  132.  
  133.   while (t) { i++; t=t->next; }
  134.   return i;
  135. }
  136.  
  137.  
  138. void stack_info(outfile)
  139. FILE *outfile;
  140. {
  141.   /* Information about size of embedded stacks */
  142.   if (verbose) {
  143.     long gn,cn,tn;
  144.     fprintf(outfile,"*** Stack depths [");
  145.     gn=depth_gs();
  146.     cn=depth_cs();
  147.     tn=depth_ts();
  148.     fprintf(outfile,"%ld goal%s, %ld choice point%s, %ld trail entr%s",
  149.             gn,(gn!=1?"s":""),
  150.             cn,(cn!=1?"s":""),
  151.             tn,(tn!=1?"ies":"y"));
  152.     fprintf(outfile,"]\n");
  153.   }
  154. }
  155.  
  156.  
  157.  
  158. /* void vinfoline ARGS((char *format, VarArgBaseDecl)); */
  159. #ifndef OS2_PORT
  160. void vinfoline(); /*  RM: Feb 15 1993  */
  161. #endif
  162.  
  163. #ifndef OS2_PORT
  164. void outputline(format,VarArgBase)
  165. char *format;
  166. VarArgBaseDecl
  167. #else
  168. void outputline(char *format,VarArgBase)
  169. #endif
  170. {
  171.   VarArgDecl;
  172.   VarArgInit(format);
  173.   vinfoline(format,output_stream, VarArg);
  174. }
  175. #ifndef OS2_PORT
  176. void traceline(format, VarArgBase)
  177. char *format;
  178. VarArgBaseDecl
  179. #else
  180. void traceline(char *format,VarArgBase)
  181. #endif
  182. {
  183.   VarArgDecl;
  184.  
  185.  
  186.  /* RM: Nov 10 1993  */
  187.   VarArgInit(format);
  188.  
  189.   if ((trace == 2) && (format[0] != 'p')) return;
  190.   tracing();
  191.  
  192.   vinfoline(format, stdout, VarArg);
  193. }
  194. #ifndef OS2_PORT
  195. void infoline(format, VarArgBase)
  196. char *format;
  197. VarArgBaseDecl
  198. #else
  199. void infoline(char *format,VarArgBase)
  200. #endif
  201.  
  202. {
  203.   VarArgDecl;
  204.  
  205.   VarArgInit(format);
  206.  
  207.   vinfoline(format, stdout, VarArg);
  208. }
  209. #ifndef OS2_PORT
  210. void warningline(format, VarArgBase)
  211. char *format;
  212. VarArgBaseDecl
  213. #else
  214. void warningline(char *format,VarArgBase)
  215. #endif
  216. {
  217.   VarArgDecl;
  218.  
  219.  
  220.   VarArgInit(format);
  221.  
  222.   if(quietflag) return; /*  RM: Sep 24 1993  */
  223.   fprintf(stderr,"*** Warning: ");
  224.   vinfoline(format, stderr, VarArg);
  225. }
  226.  
  227. /* New error printing routine */
  228. #ifndef OS2_PORT
  229. void Errorline(format, VarArgBase)
  230. char *format;
  231. VarArgBaseDecl
  232. #else
  233. void Errorline(char *format,VarArgBase)
  234. #endif
  235.  
  236. {
  237.   VarArgDecl;
  238. #ifdef DJD_DEBUG
  239. printf("format = %x %s\n",format,format);fflush(stdout);
  240. #endif
  241.  
  242.   VarArgInit(format);
  243.  
  244.   fprintf(stderr,"*** Error: ");
  245. #ifdef DJD_DEBUG
  246. printf("format2 = %x %s\n",format,format);
  247. #endif
  248.   vinfoline(format, stderr, VarArg);
  249.  
  250. #ifdef CLIFE
  251.   exit(0);
  252. #endif
  253. }
  254. #ifndef OS2_PORT
  255. void Syntaxerrorline(format, VarArgBase)
  256. char *format;
  257. VarArgBaseDecl
  258. #else
  259. void Syntaxerrorline(char *format,VarArgBase)
  260. #endif
  261.  
  262. {
  263.   VarArgDecl;
  264.  
  265.   VarArgInit(format);
  266.  
  267.   if(parse_ok) { /*  RM: Feb  1 1993  */
  268.     parse_ok=FALSE; /*  RM: Feb  1 1993  */
  269.     fprintf(stderr,"*** Syntax error: ");
  270.     vinfoline(format, stderr, VarArg);
  271.   }
  272. }
  273.  
  274.  
  275. /********************************************************************/
  276.  
  277. /* Utilities for tracing and single stepping */
  278.  
  279. /* Initialize all tracing variables */
  280. void init_trace()
  281. {
  282.   trace=FALSE;
  283.   stepflag=FALSE;
  284.   stepcount=0;
  285. }
  286.  
  287. /* Reset stepcount to zero */
  288. /* Should be called when prompt is printed */
  289. void reset_step()
  290. {
  291.   if (stepcount>0) {
  292.     stepcount=0;
  293.     stepflag=TRUE;
  294.   }
  295. }
  296.  
  297. void tracing()
  298. {
  299.   long i;
  300.   long indent;
  301.  
  302.   printf("T%04ld",goal_count);
  303.   printf(" C%02ld",depth_cs());
  304.   indent=depth_gs();
  305.   if (indent>=MAX_TRACE_INDENT) printf(" G%02ld",indent);
  306.   indent = indent % MAX_TRACE_INDENT;
  307.   for (i=indent; i>=0; i--) printf(" ");
  308.   steptrace=TRUE;
  309. }
  310.  
  311.  
  312. void new_trace(newtrace)
  313. long newtrace;
  314. {
  315.   trace = newtrace;
  316.   printf("*** Tracing is turned ");
  317.   printf(trace?"on.":"off.");
  318.   if (trace == 2) printf(" Only for Proves");
  319.   printf("\n");
  320. }
  321.  
  322. void new_step(newstep)
  323. long newstep;
  324. {
  325.   stepflag = newstep;
  326.   printf("*** Single stepping is turned ");
  327.   printf(stepflag?"on.\n":"off.\n");
  328.   new_trace(stepflag);
  329.   steptrace=FALSE;
  330. }
  331.  
  332. void set_trace_to_prove()
  333. {
  334.   new_trace(2);
  335. }
  336.  
  337. void toggle_trace()
  338. {
  339.   new_trace(trace?0:1);
  340. }
  341.  
  342.  
  343. void toggle_step()
  344. {
  345.   new_step(!stepflag);
  346. }
  347.  
  348. /********************************************************************/
  349.  
  350. /* Old error printing routines -- these should be superceded by Errorline */
  351.  
  352. void perr(str)
  353. char *str;
  354. {
  355.   fprintf(stderr,str);
  356. }
  357.  
  358. void perr_s(s1,s2)
  359. char *s1,*s2;
  360. {
  361.   fprintf(stderr,s1,s2);
  362. }
  363.  
  364. void perr_s2(s1,s2,s3)
  365. char *s1,*s2,*s3;
  366. {
  367.   fprintf(stderr,s1,s2,s3);
  368. }
  369.  
  370. void perr_i(str,i)
  371. char *str;
  372. long i;
  373. {
  374.   fprintf(stderr,str,i);
  375. }
  376.  
  377.  
  378. long warning()
  379. {
  380.   if (warningflag) perr("*** Warning: ");
  381.   return warningflag;
  382. }
  383.  
  384.  
  385. long warningx()
  386. {
  387.   if (warningflag) perr("*** Warning");
  388.   return warningflag;
  389. }
  390.  
  391.  
  392. /* Main routine for report_error and report_warning */
  393. void report_error_main(g,s,s2)
  394. ptr_psi_term g;
  395. char *s, *s2;
  396. {
  397.   FILE *f;
  398.  
  399.   perr_s2("*** %s: %s in '",s2,s);
  400.   display_psi_stderr(g);
  401.   perr("'.\n");
  402. }
  403.  
  404.  
  405.  
  406. /******** REPORT_ERROR(g,s)
  407.   Print an appropriate error message. G is the
  408.   psi-term which caused the error, S a message to print.
  409.   Format: '*** Error: %s in 'g'.'
  410. */
  411. void report_error(g,s)
  412. ptr_psi_term g;
  413. char *s;
  414. {
  415.   report_error_main(g,s,"Error");
  416. }
  417.  
  418.  
  419.  
  420. /******** REPORTANDABORT(g,s)
  421.   Print an appropriate error message. G is the
  422.   psi-term which caused the error, S a message to print.
  423.   Format: '*** Error: %s in 'g'.'
  424. */
  425. long reportAndAbort(g,s)
  426. ptr_psi_term g;
  427. char *s;
  428. {
  429.   report_error_main(g,s,"Error");
  430.   return abort_life();
  431. }
  432.  
  433.  
  434. /******** REPORT_WARNING(g,s)
  435.   Print an appropriate error message. G is the
  436.   psi-term which caused the error, S a message to print.
  437.   Format: '*** Warning: %s in 'g'.'
  438. */
  439. void report_warning(g,s)
  440. ptr_psi_term g;
  441. char *s;
  442. {
  443.   if (warningflag) report_error_main(g,s,"Warning");
  444. }
  445.  
  446.  
  447. /* Main routine for report_error2 and report_warning2 */
  448. void report_error2_main(g,s,s2)
  449. ptr_psi_term g;
  450. char *s, *s2;
  451. {
  452.   FILE *f;
  453.  
  454.   perr_s("*** %s: argument '",s2);
  455.   display_psi_stderr(g);
  456.   perr_s("' %s.\n",s);
  457. }
  458.  
  459.  
  460.  
  461. /********* REPORT_ERROR2(g,s)
  462.   Like report_error, with a slightly different format.
  463.   Format: '*** Error: argument 'g' %s.'
  464. */
  465. void report_error2(g,s)
  466. ptr_psi_term g;
  467. char *s;
  468. {
  469.   report_error2_main(g,s,"Error");
  470. }
  471.  
  472.  
  473.  
  474. /********* REPORT_WARNING2(g,s)
  475.   Like report_warning, with a slightly different format.
  476.   Format: '*** Warning: argument 'g' %s.'
  477. */
  478. void report_warning2(g,s)
  479. ptr_psi_term g;
  480. char *s;
  481. {
  482.   if (warningflag) report_error2_main(g,s,"Warning");
  483. }
  484.  
  485.  
  486.  
  487. /* Give error message if there is an argument which cannot unify with */
  488. /* a real number. */
  489. void nonnum_warning(t,arg1,arg2)
  490. ptr_psi_term t,arg1,arg2;
  491. {
  492.   if (!curried && /* PVR 15.9.93 */
  493.       ((arg1 && !overlap_type(arg1->type,real)) ||
  494.        (arg2 && !overlap_type(arg2->type,real)))) {
  495.     report_warning(t,"non-numeric argument(s)");
  496.   }
  497. }
  498.  
  499. /********************************************************************/
  500.  
  501. /* Error checking routines for bit_and, bit_or, shift, and modulo */
  502.  
  503. long nonint_warning(arg, val, msg)
  504. ptr_psi_term arg;
  505. REAL val;
  506. char *msg;
  507. {
  508.   long err=FALSE;
  509.  
  510.   if (val!=floor(val)) {
  511.     report_warning2(arg, msg);
  512.     err=TRUE;
  513.   }
  514.   return err;
  515. }
  516.  
  517. long bit_and_warning(arg, val)
  518. ptr_psi_term arg;
  519. REAL val;
  520. {
  521.   return nonint_warning(arg,val,"of bitwise 'and' operation is not an integer");
  522. }
  523.  
  524. long bit_or_warning(arg, val)
  525. ptr_psi_term arg;
  526. REAL val;
  527. {
  528.   return nonint_warning(arg,val,"of bitwise 'or' operation is not an integer");
  529. }
  530.  
  531. long bit_not_warning(arg, val)
  532. ptr_psi_term arg;
  533. REAL val;
  534. {
  535.   return nonint_warning(arg,val,"of bitwise 'not' operation is not an integer");
  536. }
  537.  
  538. long int_div_warning(arg, val)
  539. ptr_psi_term arg;
  540. REAL val;
  541. {
  542.   return nonint_warning(arg,val,"of integer division is not an integer");
  543. }
  544.  
  545. long mod_warning(arg, val,zero)
  546. ptr_psi_term arg;
  547. REAL val;
  548. int zero;
  549. {
  550.   int err;
  551.  
  552.   err=nonint_warning(arg,val,"of modulo operation is not an integer");
  553.   if(!err && zero && val==0) {
  554.     Errorline("division by 0 in modulo operation\n");
  555.     err=TRUE;
  556.   }
  557.   return err;
  558. }
  559.  
  560. long shift_warning(dir, arg, val)
  561. long dir;
  562. ptr_psi_term arg;
  563. REAL val;
  564. {
  565.   if (dir)
  566.     return nonint_warning(arg,val,"of right shift operation is not an integer");
  567.   else
  568.     return nonint_warning(arg,val,"of left shift operation is not an integer");
  569. }
  570.  
  571. /********************************************************************/
  572.