home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 3 / AACD03.BIN / AACD / Programming / sofa / archive / SmallEiffel.lha / SmallEiffel / sys / runtime / no_check.c < prev    next >
C/C++ Source or Header  |  1999-09-06  |  9KB  |  423 lines
  1. /*
  2.  * -- This file is  free  software, which  comes  along  with  SmallEiffel. This
  3.  * -- software  is  distributed  in the hope that it will be useful, but WITHOUT 
  4.  * -- ANY  WARRANTY;  without  even  the  implied warranty of MERCHANTABILITY or
  5.  * -- FITNESS  FOR A PARTICULAR PURPOSE. You can modify it as you want, provided
  6.  * -- this header is kept unaltered, and a notification of the changes is added.
  7.  * -- You  are  allowed  to  redistribute  it and sell it, alone or as a part of 
  8.  * -- another product.
  9.  * --          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
  10.  * --            Dominique COLNET and Suzanne COLLIN - colnet@loria.fr 
  11.  * --                       http://www.loria.fr/SmallEiffel
  12.  * --
  13.  */
  14.  
  15. /*
  16.  * This file (no_check.c) is automatically included when `run_control.no_check'
  17.  * is true (ie. all modes ecxept -boost).
  18.  */
  19.  
  20. /*
  21.  * The upper most context (SmallEiffel Dump stack Top) :
  22.  */
  23. se_dump_stack *se_dst = NULL;
  24.  
  25. void 
  26. se_print_run_time_stack(void)
  27. {
  28.     /* GENERAL.print_run_time_stack */
  29.     se_dump_stack *ds = NULL;
  30.     se_dump_stack *ds2;
  31.     int frame_count = 1;
  32.  
  33.     ds = se_dst;
  34.     if (ds == NULL) {
  35.         fprintf(SE_ERR, "Empty stack.\n");
  36.         return;
  37.     } else {
  38.         while (ds->caller != NULL) {
  39.             ds = ds->caller;
  40.             frame_count++;
  41.         }
  42.     }
  43.     fprintf(SE_ERR, "%d frames in current stack.\n", frame_count);
  44.     fprintf(SE_ERR, "=====  Bottom of run-time stack  =====\n");
  45.     while (ds != NULL) {
  46.         if (ds->fd != NULL) {
  47.             se_print_one_frame(ds);
  48.         } else {
  49.             fprintf(SE_ERR, "External CECIL call.\n");
  50.         }
  51.         /* Next frame : */
  52.         if (ds == se_dst) {
  53.             ds = NULL;
  54.         } else {
  55.             ds2 = se_dst;
  56.             while (ds2->caller != ds) {
  57.                 ds2 = ds2->caller;
  58.             }
  59.             ds = ds2;
  60.         }
  61.         if (--frame_count) {
  62.             fprintf(SE_ERR, "======================================\n");
  63.         }
  64.     }
  65.     fprintf(SE_ERR, "=====   Top of run-time stack    =====\n");
  66. }
  67.  
  68. void 
  69. se_print_one_frame(se_dump_stack * ds)
  70. {
  71.     se_frame_descriptor *fd = ds->fd;
  72.     int i = 0;
  73.     int local_count = 0;
  74.     char *local_format = fd->local_format;
  75.     int expanded;
  76.     int id;
  77.     void **var;
  78.     fprintf(SE_ERR, "%s\n", fd->name);
  79.     if (fd->use_current) {
  80.         fprintf(SE_ERR, "Current = ");
  81.         i = 2;
  82.         id = 0;
  83.         while (local_format[i] != '%') {
  84.             id = (id * 10) + (local_format[i] - '0');
  85.             i++;
  86.         }
  87.         i++;
  88.         (se_prinT[id]) (ds->current);
  89.         fprintf(SE_ERR, "\n");
  90.     }
  91.     while (local_count < fd->local_count) {
  92.         while (local_format[i] != '%') {
  93.             fprintf(SE_ERR, "%c", local_format[i]);
  94.             i++;
  95.         }
  96.         i++;
  97.         expanded = ((local_format[i++] == 'E') ? 1 : 0);
  98.         fprintf(SE_ERR, " = ");
  99.         id = 0;
  100.         while (local_format[i] != '%') {
  101.             id = (id * 10) + (local_format[i] - '0');
  102.             i++;
  103.         }
  104.         i++;
  105.         var = (ds->locals)[local_count];
  106.         if (expanded) {
  107.             (se_prinT[id]) ((void **) (var));
  108.         } else if (*var == NULL) {
  109.             fprintf(SE_ERR, "Void");
  110.         } else {
  111.             (se_prinT[((T0 *) (*var))->id]) ((void **) (var));
  112.         }
  113.         fprintf(SE_ERR, "\n");
  114.         local_count++;
  115.     }
  116.     if ((ds->l != 0) && (ds->c != 0)) {
  117.         fprintf(SE_ERR, "line %d ", ds->l);
  118.         fflush(SE_ERR);
  119.         fprintf(SE_ERR, "column %d ", ds->c);
  120.         fflush(SE_ERR);
  121.         fprintf(SE_ERR, "file %s \n", p[ds->f]);
  122.         fflush(SE_ERR);
  123.     }
  124. }
  125.  
  126. void 
  127. se_core_dump(char *msg)
  128. {
  129.     if (msg != NULL) {
  130.         fprintf(SE_ERR, "%s\n", msg);
  131.     }
  132. #ifdef SE_EXCEPTIONS
  133.     print_exception();
  134. #endif
  135.     se_print_run_time_stack();
  136.     exit(1);
  137. }
  138.  
  139. int se_require_uppermost_flag;
  140.  
  141. /*
  142.  * Require Last Result :
  143.  */
  144. int se_require_last_result;
  145.  
  146. int 
  147. se_rci(void *C)
  148. {
  149.     /* Return 1 if class invariant must be checked for Current 
  150.      * before leaving the routine.
  151.      */
  152.     se_dump_stack *ds = se_dst;
  153.     ds = ds->caller;
  154.     if (ds != NULL) {
  155.         se_frame_descriptor *fd = ds->fd;
  156.         if (fd == NULL) {
  157.             /* As for example when coming via CECIL. */
  158.             return 0;
  159.         } else {
  160.             if (fd->use_current) {
  161.                 if (fd->local_format[1] == 'R') {
  162.                     if (((void *) *(ds->current)) == C) {
  163.                         return 0;
  164.                     }
  165.                 }
  166.             }
  167.         }
  168.     }
  169.     return 1;
  170. }
  171.  
  172. void 
  173. error0(char *m, char *vv)
  174. {
  175.     static char *f1 = "*** Error at Run Time *** : %s\n";
  176.     static char *f2 = "*** Error at Run Time *** : %s\n";
  177.     fprintf(SE_ERR, f1, m);
  178.     if (vv != NULL)
  179.         fprintf(SE_ERR, f2, vv);
  180. #ifdef SE_EXCEPTIONS
  181.     print_exception();
  182. #endif
  183.     se_print_run_time_stack();
  184.     fprintf(SE_ERR, f1, m);
  185.     if (vv != NULL)
  186.         fprintf(SE_ERR, f2, vv);
  187.     exit(1);
  188. }
  189.  
  190. void 
  191. error1(char *m, int l, int c, int f)
  192. {
  193.     char *f1 = "Line : %d column %d in %s.\n";
  194.     char *f2 = "*** Error at Run Time *** : %s\n";
  195.     fprintf(SE_ERR, f1, l, c, p[f]);
  196.     fprintf(SE_ERR, f2, m);
  197. #ifdef SE_EXCEPTIONS
  198.     print_exception();
  199. #endif
  200.     se_print_run_time_stack();
  201.     fprintf(SE_ERR, f1, l, c, p[f]);
  202.     fprintf(SE_ERR, f2, m);
  203.     exit(1);
  204. }
  205.  
  206. void 
  207. se_print_string(FILE * stream, T7 * s)
  208. {
  209.     /* To print some Eiffel STRING. */
  210.     if (s == NULL) {
  211.         fprintf(stream, "Void");
  212.     } else {
  213.         int count = s->_count;
  214.         char *storage = s->_storage;
  215.         int i = 0;
  216.         fprintf(stream, "\"");
  217.         while (count != 0) {
  218.             fprintf(stream, "%c", storage[i]);
  219.             i++;
  220.             count--;
  221.         }
  222.         fprintf(stream, "\"");
  223.     }
  224. }
  225.  
  226. void 
  227. se_print_bad_target(FILE * stream, int id, T0 * o, int l, int c, int f)
  228. {
  229.     /* Print Bad Target Type Error Message. */
  230.     if (l != 0) {
  231.         fprintf(stream, "Line : %d column %d in %s.\n", l, c, p[f]);
  232.     }
  233.     fprintf(stream, "*** Error at Run Time *** :\n");
  234.     fprintf(stream, "   Target is not valid (not the good type).\n");
  235.     fprintf(stream, "   Expected: ");
  236.     se_print_string(stream, t[id]);
  237.     fprintf(stream, ", Actual: ");
  238.     se_print_string(stream, t[o->id]);
  239.     fprintf(stream, ".\n");
  240. }
  241.  
  242. void 
  243. error2(T0 * o, int l, int c, int f)
  244. {
  245.     fprintf(SE_ERR, "Target Type ");
  246.     se_print_string(SE_ERR, t[o->id]);
  247.     fprintf(SE_ERR, " is not valid.\n");
  248.     error1("Bad target.", l, c, f);
  249. }
  250.  
  251. T0 *
  252. vc(void *o, int l, int c, int f)
  253. {
  254.     /* VoidCheck for reference target. */
  255.     if (o != NULL) {
  256.         return o;
  257.     } else {
  258. #ifdef SE_EXCEPTIONS
  259.         internal_exception_handler(Void_call_target);
  260. #else
  261.         error1("Call with a Void target.", l, c, f);
  262. #endif
  263.         return NULL;
  264.     }
  265. }
  266.  
  267. T0 *
  268. ci(int id, void *o, int l, int c, int f)
  269. {
  270.     /* Check Id for reference target. */
  271.     vc(o, l, c, f);
  272.     if (id == (((T0 *) o)->id)) {
  273.         return o;
  274.     } else {
  275. #ifdef SE_EXCEPTIONS
  276.         internal_exception_handler(Routine_failure);
  277. #else
  278.         se_print_bad_target(SE_ERR, id, (T0 *) o, l, c, f);
  279.         se_print_run_time_stack();
  280.         se_print_bad_target(SE_ERR, id, (T0 *) o, l, c, f);
  281.         exit(1);
  282. #endif
  283.     }
  284.     return o;
  285. }
  286.  
  287. void 
  288. ac_req(int v, char *vv)
  289. {
  290.     if (!v && se_require_uppermost_flag) {
  291. #ifdef SE_EXCEPTIONS
  292.         internal_exception_handler(Precondition);
  293. #else
  294.         error0("Require Assertion Violated.", vv);
  295. #endif
  296.     }
  297.     se_require_last_result = se_require_last_result && v;
  298. }
  299.  
  300. void 
  301. ac_ens(int v, char *vv)
  302. {
  303.     if (!v) {
  304. #ifdef SE_EXCEPTIONS
  305.         internal_exception_handler(Postcondition);
  306. #else
  307.         error0("Ensure Assertion Violated.", vv);
  308. #endif
  309.     }
  310. }
  311.  
  312. void 
  313. ac_inv(int v, char *vv)
  314. {
  315.     if (!v) {
  316. #ifdef SE_EXCEPTIONS
  317.         internal_exception_handler(Class_invariant);
  318. #else
  319.         error0("Class Invariant Violation.", vv);
  320. #endif
  321.     }
  322. }
  323.  
  324. void 
  325. ac_liv(int v, char *vv)
  326. {
  327.     /* Assertion Check : Loop Invariant check. */
  328.     if (!v) {
  329. #ifdef SE_EXCEPTIONS
  330.         internal_exception_handler(Loop_invariant);
  331. #else
  332.         error0("Loop Invariant Violation.", vv);
  333. #endif
  334.     }
  335. }
  336.  
  337. int 
  338. ac_lvc(int lc, int lv1, int lv2)
  339. {
  340.     /* Assertion Check : Loop Variant check. */
  341.     if (lc == 0) {
  342.         if (lv2 < 0) {
  343. #ifdef SE_EXCEPTIONS
  344.             internal_exception_handler(Loop_variant);
  345. #else
  346.             se_print_run_time_stack();
  347.             fprintf(SE_ERR, "Bad First Variant Value = %d\n", lv2);
  348.             exit(1);
  349. #endif
  350.         } else {
  351.             return lv2;
  352.         }
  353.     } else if ((lv2 < 0) || (lv2 >= lv1)) {
  354. #ifdef SE_EXCEPTIONS
  355.         internal_exception_handler(Loop_variant);
  356. #else
  357.         se_print_run_time_stack();
  358.         fprintf(SE_ERR, "Loop Body Count = %d (done)\n", lc);
  359.         fprintf(SE_ERR, "New Variant = %d\n", lv2);
  360.         fprintf(SE_ERR, "Previous Variant = %d\n", lv1);
  361.         exit(1);
  362. #endif
  363.     } else {
  364.         return lv2;
  365.     }
  366. }
  367.  
  368. void 
  369. ac_civ(int v, char *vv)
  370. {
  371.     if (!v) {
  372. #ifdef SE_EXCEPTIONS
  373.         internal_exception_handler(Check_instruction);
  374. #else
  375.         error0("Check Assertion Violated.", vv);
  376. #endif
  377.     }
  378. }
  379.  
  380. void 
  381. se_evobt(void *o, int l, int c, int f)
  382. {
  383.     /* Error Void Or Bad Type. */
  384.     if (!o) {
  385. #ifdef SE_EXCEPTIONS
  386.         internal_exception_handler(Void_call_target);
  387. #else
  388.         error1("Target is Void.", l, c, f);
  389. #endif
  390.     } else {
  391. #ifdef SE_EXCEPTIONS
  392.         internal_exception_handler(Void_call_target);
  393. #else
  394.         error2(o, l, c, f);
  395. #endif
  396.     }
  397. }
  398.  
  399. void 
  400. sigrsp(int sig)
  401. {
  402.     printf("Received signal %d (man signal).\n", sig);
  403.     se_print_run_time_stack();
  404.     exit(1);
  405. }
  406.  
  407. void 
  408. se_gc_check_id(void *o, int id)
  409. {
  410.     if (id != (((T0 *) o)->id)) {
  411. #ifdef SE_EXCEPTIONS
  412.         internal_exception_handler(Routine_failure);
  413. #else
  414.         fprintf(SE_ERR, "System-validity error detected during GC cycle.\n");
  415.         se_print_bad_target(SE_ERR, id, (T0 *) o, 0, 0, 0);
  416.         se_print_run_time_stack();
  417.         fprintf(SE_ERR, "System-validity error detected during GC cycle.\n");
  418.         se_print_bad_target(SE_ERR, id, (T0 *) o, 0, 0, 0);
  419.         exit(1);
  420. #endif
  421.     }
  422. }
  423.