home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #1 / NN_1993_1.iso / spool / comp / os / minix / 5125 / patch4.2b.Z / patch4.2b
Encoding:
Text File  |  1993-01-11  |  32.5 KB  |  1,330 lines
  1. *** src/expr.c.o    Tue Dec 01 23:26:23 1992
  2. --- src/expr.c    Wed Dec 09 18:29:45 1992
  3. ***************
  4. *** 190,195 ****
  5. --- 190,196 ----
  6.       tp1 = tp->btp;
  7.       tp = mk_type(bt_pointer, tp_pointer.size);
  8.       tp->btp = tp1;
  9. +     tp->val_flag = 1;
  10.       }
  11.       return tp;
  12.   }
  13. ***************
  14. *** 246,252 ****
  15.           ep->esize = 4;
  16.           break;
  17.           }
  18. !         /* FALLTHU */
  19.         case sc_global:
  20.         case sc_external:
  21.           *node = ep = mk_node(en_nacon, NIL_ENODE, NIL_ENODE);
  22. --- 247,253 ----
  23.           ep->esize = 4;
  24.           break;
  25.           }
  26. !         /*FALLTHRU*/
  27.         case sc_global:
  28.         case sc_external:
  29.           *node = ep = mk_node(en_nacon, NIL_ENODE, NIL_ENODE);
  30. ***************
  31. *** 379,393 ****
  32.       enum e_sym      st;
  33.   {
  34.       struct sym     *sp;
  35. !     if (st == kw_char || st == kw_short || st == kw_int ||
  36. !     st == kw_long || st == kw_float || st == kw_double ||
  37. !     st == kw_struct || st == kw_union || st == kw_unsigned ||
  38. !     st == kw_const || st == kw_volatile ||
  39. !     st == kw_void || st == kw_enum)
  40. !     return 1;
  41. !     if (st == id && (sp = gsearch(lastid)) != 0 &&
  42. !     sp->storage_class == sc_typedef)
  43. !     return 1;
  44.       return 0;
  45.   }
  46.   
  47. --- 380,406 ----
  48.       enum e_sym      st;
  49.   {
  50.       struct sym     *sp;
  51. !     switch (st) {
  52. !       case kw_char:
  53. !       case kw_short:
  54. !       case kw_int:
  55. !       case kw_long:
  56. !       case kw_float:
  57. !       case kw_double:
  58. !       case kw_struct:
  59. !       case kw_union:
  60. !       case kw_unsigned:
  61. !       case kw_const:
  62. !       case kw_volatile:
  63. !       case kw_signed:
  64. !       case kw_void:
  65. !       case kw_enum:
  66. !       return 1;
  67. !       default:
  68. !       if (st == id && (sp = gsearch(lastid)) != 0 &&
  69. !           sp->storage_class == sc_typedef)
  70. !       return 1;
  71. !     }
  72.       return 0;
  73.   }
  74.   
  75. ***************
  76. *** 404,409 ****
  77. --- 417,424 ----
  78.    * primary.id
  79.    * primary->id
  80.    * primary( parameter list )
  81. +  * primary++
  82. +  * primary--
  83.    * -- or just a semicolon, yields empty expression --
  84.    *
  85.    */
  86. ***************
  87. *** 413,418 ****
  88. --- 428,434 ----
  89.       struct sym     *sp;
  90.       TYP            *tptr;
  91.       TYP            *tp1,*tp2;
  92. +     int        i;
  93.       switch (lastst) {
  94.   
  95.         case id:
  96. ***************
  97. *** 431,452 ****
  98.       }
  99.       break;
  100.         case iconst:
  101.         case uconst:
  102.         case lconst:
  103.       pnode = mk_icon((long)ival);
  104. !     if (lastst == uconst) {
  105. !         tptr = &tp_uint;
  106. !         pnode->etype = tp_uint.type;
  107. !         pnode->esize = tp_uint.size;
  108. !     } else if (lastst == lconst) {
  109. !         tptr = &tp_long;
  110. !         pnode->etype = bt_long;
  111. !         pnode->esize = 4;
  112. !     } else {
  113. !         tptr = &tp_int;
  114. !         pnode->etype = tp_int.type;
  115. !         pnode->esize = tp_int.size;
  116. !     }
  117.       getsym();
  118.       break;
  119.         case rconst:
  120. --- 447,466 ----
  121.       }
  122.       break;
  123.         case iconst:
  124. +     tptr = &tp_int;
  125. +     goto const1;
  126.         case uconst:
  127. +     tptr = &tp_uint;
  128. +     goto const1;
  129.         case lconst:
  130. +     tptr = &tp_long;
  131. +     goto const1;
  132. +       case ulconst:
  133. +     tptr = &tp_ulong;
  134. + const1:
  135.       pnode = mk_icon((long)ival);
  136. !     pnode->etype = tptr->type;
  137. !     pnode->esize = tptr->size;
  138.       getsym();
  139.       break;
  140.         case rconst:
  141. ***************
  142. *** 479,485 ****
  143.           needpunc(closepa);
  144.       } else {        /* cast operator */
  145.           struct typ *local_head = head, *local_tail=tail;
  146. !         decl((TABLE *) 0);    /* do cast declaration */
  147.           decl1();
  148.           tptr = head;
  149.           needpunc(closepa);
  150. --- 493,499 ----
  151.           needpunc(closepa);
  152.       } else {        /* cast operator */
  153.           struct typ *local_head = head, *local_tail=tail;
  154. !         decl();    /* do cast declaration */
  155.           decl1();
  156.           tptr = head;
  157.           needpunc(closepa);
  158. ***************
  159. *** 516,521 ****
  160. --- 530,537 ----
  161.           tp1 = expression(&pnode);
  162.           tptr = tp1;
  163.           }
  164. +         if (!integral(tp2))
  165. +         message(ERR_INTEGER);
  166.   
  167.   /*
  168.    * now, pnode and tp1 describe the pointer,
  169. ***************
  170. *** 533,539 ****
  171.   /*
  172.    * qnode is the size of the referenced object
  173.    */
  174. !         (void) cast_op(&rnode, tp2, &tp_long, 0);
  175.           /*
  176.            * we could check the type of the expression here...
  177.            */
  178. --- 549,555 ----
  179.   /*
  180.    * qnode is the size of the referenced object
  181.    */
  182. !         VOIDCAST cast_op(&rnode, tp2, &tp_long, 1);
  183.           /*
  184.            * we could check the type of the expression here...
  185.            */
  186. ***************
  187. *** 540,546 ****
  188.           qnode = mk_node(en_mul, qnode, rnode);
  189.           qnode->etype = bt_long;
  190.           qnode->esize = 4;
  191. !         (void) cast_op(&qnode, &tp_long, tp1, 0);
  192.           pnode = mk_node(en_add, qnode, pnode);
  193.           pnode->etype = bt_pointer;
  194.           pnode->esize = 4;
  195. --- 556,562 ----
  196.           qnode = mk_node(en_mul, qnode, rnode);
  197.           qnode->etype = bt_long;
  198.           qnode->esize = 4;
  199. !         VOIDCAST cast_op(&qnode, &tp_long, tp1, 1);
  200.           pnode = mk_node(en_add, qnode, pnode);
  201.           pnode->etype = bt_pointer;
  202.           pnode->esize = 4;
  203. ***************
  204. *** 613,618 ****
  205. --- 629,672 ----
  206.           pnode->esize = tptr->size;
  207.           needpunc(closepa);
  208.           break;
  209. +       case autodec:
  210. +       case autoinc:
  211. +         if (tptr->type == bt_pointer)
  212. +         i = tptr->btp->size;
  213. +         else
  214. +         i = 1;
  215. +         if (i == UNKNOWN_SIZE)
  216. +         message (ERR_SIZE);
  217. +         if (lvalue(pnode)) {
  218. +         if (floating(tptr)) {
  219. +             qnode = mk_node(en_fcon, NIL_ENODE, NIL_ENODE);
  220. + #ifndef NOFLOAT
  221. +             qnode->v.f = ((double)1);
  222. + #endif
  223. +             if (tptr->type == bt_float) {
  224. +             qnode->etype = tp_float.type;
  225. +             qnode->esize = tp_float.size;
  226. +             } else {
  227. +             qnode->etype = tp_double.type;
  228. +             qnode->esize = tp_double.size;
  229. +             }
  230. +         } else {
  231. +             qnode = mk_icon((long) i);
  232. +             qnode->etype = bt_long;
  233. +             qnode->esize = 4;
  234. +         }
  235. +         if (lastst == autodec)
  236. +             pnode = mk_node(en_adec, pnode, qnode);
  237. +         else
  238. +             pnode = mk_node(en_ainc, pnode, qnode);
  239. +         pnode->etype = tptr->type;
  240. +         pnode->esize = tptr->size;
  241. +         } else
  242. +         message(ERR_LVALUE);
  243. +         getsym();
  244. +         if (trad_option && lastst == pointsto)
  245. +         needpunc(lastst+1);    /* force an error as K&R doesn't allow this*/
  246. +         break;
  247.         default:
  248.           goto fini;
  249.       }
  250. ***************
  251. *** 628,635 ****
  252.    * evaluated. unary expressions are any of:
  253.    *
  254.    * primary
  255. -  * primary++
  256. -  * primary--
  257.    * !unary
  258.    * ~unary
  259.    * ++unary
  260. --- 682,687 ----
  261. ***************
  262. *** 673,679 ****
  263.           } else if (floating(tp)) {
  264.               ep2 = mk_node(en_fcon, NIL_ENODE, NIL_ENODE);
  265.   #ifndef NOFLOAT
  266. !             ep2->v.f = 1.0;
  267.   #endif
  268.               if (tp->type == bt_float) {
  269.               ep2->etype = tp_float.type;
  270. --- 725,731 ----
  271.           } else if (floating(tp)) {
  272.               ep2 = mk_node(en_fcon, NIL_ENODE, NIL_ENODE);
  273.   #ifndef NOFLOAT
  274. !             ep2->v.f = ((double)1);
  275.   #endif
  276.               if (tp->type == bt_float) {
  277.               ep2->etype = tp_float.type;
  278. ***************
  279. *** 792,797 ****
  280. --- 844,851 ----
  281.           }
  282.       } else if (tp->type == bt_pointer && tp->btp->type == bt_func) {
  283.           message(WARN_ADDFUNC);
  284. +     } else if (tp->type == bt_pointer && tp->val_flag) {
  285. +         message(WARN_ADDARRAY);
  286.       } else
  287.           message(ERR_LVALUE);
  288.       break;
  289. ***************
  290. *** 812,818 ****
  291.                */
  292.               tp1 = head;
  293.               tp  = tail;
  294. !             decl((TABLE *) 0);
  295.               decl1();
  296.           i = head->size;
  297.           tail = tp;
  298. --- 866,872 ----
  299.                */
  300.               tp1 = head;
  301.               tp  = tail;
  302. !             decl();
  303.               decl1();
  304.           i = head->size;
  305.           tail = tp;
  306. ***************
  307. *** 857,868 ****
  308.           if (ep1->v.i == 0) {
  309.           message(WARN_SIZEOF0);
  310.       }
  311. !     if (short_option && ep1->v.i > 65535) {
  312.           message(WARN_SIZEOFBIG);
  313.       }
  314. !     tp = &tp_uint;
  315. !     ep1->etype = tp_uint.type;
  316. !     ep1->esize = tp_uint.size;
  317.       break;
  318.         case plus:
  319.       if (trad_option == 0) {
  320. --- 911,922 ----
  321.           if (ep1->v.i == 0) {
  322.           message(WARN_SIZEOF0);
  323.       }
  324. !     if (((ep1->v.i)>>(TP_SIZE.size * 4))>>(TP_SIZE.size*4) != 0) {
  325.           message(WARN_SIZEOFBIG);
  326.       }
  327. !     tp = &TP_SIZE;
  328. !     ep1->etype = TP_SIZE.type;
  329. !     ep1->esize = TP_SIZE.size;
  330.       break;
  331.         case plus:
  332.       if (trad_option == 0) {
  333. ***************
  334. *** 878,920 ****
  335.       /*FALLTHRU*/
  336.         default:
  337.       tp = primary(&ep1);
  338. -     if (tp != 0) {
  339. -         if (tp->type == bt_pointer)
  340. -         i = tp->btp->size;
  341. -         else
  342. -         i = 1;
  343. -         if (lastst == autodec || lastst == autoinc) {
  344. -         if (i == -1)
  345. -             message (ERR_SIZE);
  346. -         if (lvalue(ep1)) {
  347. -             if (floating(tp)) {
  348. -             ep2 = mk_node(en_fcon, NIL_ENODE, NIL_ENODE);
  349. - #ifndef NOFLOAT
  350. -             ep2->v.f = 1.0;
  351. - #endif
  352. -             if (tp->type == bt_float) {
  353. -                 ep2->etype = tp_float.type;
  354. -                 ep2->esize = tp_float.size;
  355. -             } else {
  356. -                 ep2->etype = tp_double.type;
  357. -                 ep2->esize = tp_double.size;
  358. -             }
  359. -             } else {
  360. -             ep2 = mk_icon((long) i);
  361. -             ep2->etype = bt_long;
  362. -             ep2->esize = 4;
  363. -             }
  364. -             if (lastst == autodec)
  365. -                 ep1 = mk_node(en_adec, ep1, ep2);
  366. -             else
  367. -                 ep1 = mk_node(en_ainc, ep1, ep2);
  368. -             ep1->etype = tp->type;
  369. -             ep1->esize = tp->size;
  370. -         } else
  371. -             message(ERR_LVALUE);
  372. -         getsym();
  373. -         }
  374. -     }
  375.       break;
  376.       }
  377.       *node = ep1;
  378. --- 932,937 ----
  379. ***************
  380. *** 1041,1047 ****
  381.       switch (tp2->type) {
  382.         case bt_char:
  383.         case bt_uchar:
  384. !         (void) cast_op(node1, tp1, &tp_short, 0);
  385.           return cast_op(node2, tp2, &tp_short, 0);
  386.         case bt_short:
  387.         case bt_long:
  388. --- 1058,1064 ----
  389.       switch (tp2->type) {
  390.         case bt_char:
  391.         case bt_uchar:
  392. !         VOIDCAST cast_op(node1, tp1, &tp_short, 0);
  393.           return cast_op(node2, tp2, &tp_short, 0);
  394.         case bt_short:
  395.         case bt_long:
  396. ***************
  397. *** 1062,1068 ****
  398.               if (short_option)
  399.                  return cast_op (node1, tp1, &tp_ushort, 0);
  400.               else {
  401. !                (void) cast_op (node1, tp1, &tp_long, 0);
  402.                  return cast_op (node2, tp2, &tp_long, 0);
  403.               }
  404.         case bt_short:
  405. --- 1079,1085 ----
  406.               if (short_option)
  407.                  return cast_op (node1, tp1, &tp_ushort, 0);
  408.               else {
  409. !                VOIDCAST cast_op (node1, tp1, &tp_long, 0);
  410.                  return cast_op (node2, tp2, &tp_long, 0);
  411.               }
  412.         case bt_short:
  413. ***************
  414. *** 1069,1075 ****
  415.           if (short_option)
  416.           return cast_op(node2, tp2, &tp_ushort, 0);
  417.           else {
  418. !                (void) cast_op (node1, tp1, &tp_long, 0);
  419.                  return cast_op (node2, tp2, &tp_long, 0);
  420.               }
  421.         case bt_long:
  422. --- 1086,1092 ----
  423.           if (short_option)
  424.           return cast_op(node2, tp2, &tp_ushort, 0);
  425.           else {
  426. !                VOIDCAST cast_op (node1, tp1, &tp_long, 0);
  427.                  return cast_op (node2, tp2, &tp_long, 0);
  428.               }
  429.         case bt_long:
  430. ***************
  431. *** 1218,1224 ****
  432.           ep1 = mk_node(en_sub, ep1, ep2);
  433.           ep1->etype = bt_pointer;
  434.           ep1->esize = 4;
  435. !         (void) cast_op(&ep1, tp1, &tp_long, 0);
  436.           /* divide the result by the size */
  437.           ep2 = mk_icon((long) tp1->btp->size);
  438.           ep2->etype = bt_long;
  439. --- 1235,1241 ----
  440.           ep1 = mk_node(en_sub, ep1, ep2);
  441.           ep1->etype = bt_pointer;
  442.           ep1->esize = 4;
  443. !         VOIDCAST cast_op(&ep1, tp1, &tp_long, 1);
  444.           /* divide the result by the size */
  445.           ep2 = mk_icon((long) tp1->btp->size);
  446.           ep2->etype = bt_long;
  447. ***************
  448. *** 1232,1240 ****
  449.            * an 68000 with 32-bit pointers and 16-bit ints. In my opinion,
  450.            * it should remain "long".
  451.            */
  452. !         if (short_option)
  453.           message(WARN_PTRDIFF16);
  454. !         tp1 = cast_op(&ep1, &tp_long, &tp_int, short_option);
  455.           *node = ep1;
  456.           continue;
  457.       }
  458. --- 1249,1257 ----
  459.            * an 68000 with 32-bit pointers and 16-bit ints. In my opinion,
  460.            * it should remain "long".
  461.            */
  462. !         if (TP_PTRDIFF.size == 2)
  463.           message(WARN_PTRDIFF16);
  464. !         tp1 = cast_op(&ep1, &tp_long, &TP_PTRDIFF, TP_PTRDIFF.size == 2);
  465.           *node = ep1;
  466.           continue;
  467.       }
  468. ***************
  469. *** 1244,1250 ****
  470.           message(ERR_INTEGER);
  471.           if (tp1->btp->size == UNKNOWN_SIZE)
  472.           message (ERR_SIZE);
  473. !         (void) cast_op(&ep2, tp2, &tp_long, 0);
  474.           ep3 = mk_icon((long) tp1->btp->size);
  475.           ep3->etype = bt_long;
  476.           ep3->esize = 4;
  477. --- 1261,1267 ----
  478.           message(ERR_INTEGER);
  479.           if (tp1->btp->size == UNKNOWN_SIZE)
  480.           message (ERR_SIZE);
  481. !         VOIDCAST cast_op(&ep2, tp2, &tp_long, 0);
  482.           ep3 = mk_icon((long) tp1->btp->size);
  483.           ep3->etype = bt_long;
  484.           ep3->esize = 4;
  485. ***************
  486. *** 1262,1268 ****
  487.           message(ERR_INTEGER);
  488.           if (tp2->btp->size == UNKNOWN_SIZE)
  489.           message (ERR_SIZE);
  490. !         (void) cast_op(&ep1, tp1, &tp_long, 0);
  491.           ep3 = mk_icon((long) tp2->btp->size);
  492.           ep3->etype = bt_long;
  493.           ep3->esize = 4;
  494. --- 1279,1285 ----
  495.           message(ERR_INTEGER);
  496.           if (tp2->btp->size == UNKNOWN_SIZE)
  497.           message (ERR_SIZE);
  498. !         VOIDCAST cast_op(&ep1, tp1, &tp_long, 0);
  499.           ep3 = mk_icon((long) tp2->btp->size);
  500.           ep3->etype = bt_long;
  501.           ep3->esize = 4;
  502. ***************
  503. *** 1592,1598 ****
  504.           if (tp1->type == bt_pointer && integral(tp2)) {
  505.           if (tp1->btp->size == UNKNOWN_SIZE)
  506.               message (ERR_SIZE);
  507. !         (void) cast_op(&ep2, tp2, &tp_long, 0);
  508.           ep3 = mk_icon((long) tp1->btp->size);
  509.           ep3->etype = bt_long;
  510.           ep3->esize = 4;
  511. --- 1609,1615 ----
  512.           if (tp1->type == bt_pointer && integral(tp2)) {
  513.           if (tp1->btp->size == UNKNOWN_SIZE)
  514.               message (ERR_SIZE);
  515. !         VOIDCAST cast_op(&ep2, tp2, &tp_long, 1);
  516.           ep3 = mk_icon((long) tp1->btp->size);
  517.           ep3->etype = bt_long;
  518.           ep3->esize = 4;
  519. ***************
  520. *** 1599,1605 ****
  521.           ep2 = mk_node(en_mul, ep2, ep3);
  522.           ep2->etype = bt_long;
  523.           ep2->esize = 4;
  524. !         tp2 = cast_op(&ep2, &tp_long, tp1, 0);
  525.           }
  526.           goto ascomm2;
  527.         case asminus:
  528. --- 1616,1622 ----
  529.           ep2 = mk_node(en_mul, ep2, ep3);
  530.           ep2->etype = bt_long;
  531.           ep2->esize = 4;
  532. !         tp2 = cast_op(&ep2, &tp_long, tp1, 1);
  533.           }
  534.           goto ascomm2;
  535.         case asminus:
  536. ***************
  537. *** 1737,1743 ****
  538.       return tp2;
  539.       }
  540.   
  541. !     if ((*ep)->nodetype == en_icon)
  542.       if (integral(tp2) || tp2->type == bt_pointer || tp2->type == bt_void) {
  543.           long            j = (*ep)->v.i;
  544.           (*ep)->etype = tp2->type;
  545. --- 1754,1761 ----
  546.       return tp2;
  547.       }
  548.   
  549. !     switch ((*ep)->nodetype) {
  550. !       case en_icon:
  551.       if (integral(tp2) || tp2->type == bt_pointer || tp2->type == bt_void) {
  552.           long            j = (*ep)->v.i;
  553.           (*ep)->etype = tp2->type;
  554. ***************
  555. *** 1763,1775 ****
  556.           message(ERR_CASTCON);
  557.           return 0;
  558.       }
  559. !     if (tp2->type != bt_void  && tp2->type != bt_float
  560. !      && tp1->size > tp2->size  && (flag==0))
  561. !     message(WARN_NARROWER);
  562. !     else if (tp2->type == bt_pointer && tp1->size < tp_pointer.size)
  563.       message(WARN_SHORTPTR);
  564.   
  565. - 
  566.       ep2 = mk_node(en_cast, *ep, NIL_ENODE);
  567.       ep2->etype = tp2->type;
  568.       ep2->esize = tp2->size;
  569. --- 1781,1814 ----
  570.           message(ERR_CASTCON);
  571.           return 0;
  572.       }
  573. !       case en_fcon:
  574. !     if (integral(tp2)) {
  575. !         long            j = (*ep)->v.f;
  576. !         (*ep)->nodetype = en_icon;
  577. !         (*ep)->etype = tp2->type;
  578. !         (*ep)->esize = tp2->size;
  579. !         (*ep)->v.i = strip_icon(j, tp2->type);
  580. !         if (j != (*ep)->v.f ) {
  581. !         message(WARN_CONSTCAST, j, (*ep)->v.i);
  582. !         }
  583. !         return tp2;
  584. !     }
  585. !     }
  586. !     if(tp2->type == bt_struct || tp2->type == bt_union ||
  587. !        tp1->type == bt_struct || tp1->type == bt_union ) {
  588. !     message(ERR_ILLCAST);
  589. !     return(tp2);
  590. !     }
  591. !     if (flag == 0) {
  592. !     if (tp2->type == bt_pointer || tp1->type == bt_pointer)
  593. !         message(WARN_TYPECAST);
  594. !     if (tp2->type != bt_void  && tp2->type != bt_float
  595. !      && tp1->size > tp2->size )
  596. !         message(WARN_NARROWER);
  597. !     }
  598. !     if (tp2->type == bt_pointer && tp1->size < tp_pointer.size)
  599.       message(WARN_SHORTPTR);
  600.   
  601.       ep2 = mk_node(en_cast, *ep, NIL_ENODE);
  602.       ep2->etype = tp2->type;
  603.       ep2->esize = tp2->size;
  604. ***************
  605. *** 1820,1823 ****
  606. --- 1859,1910 ----
  607.       }
  608.       return i;
  609.   }
  610. + 
  611. +   
  612. + #ifdef TRACE
  613. + void
  614. + traceexpr(node)
  615. +     struct enode  **node;
  616. + {
  617. +     struct enode   *pnode;
  618. +     struct enode   *ep1, *ep2;
  619. +     static struct enode   *ep;
  620. +     extern int act_line;
  621. +     extern char act_file[];
  622. + 
  623. +     if (ep == 0) {
  624. +     struct sym     *sp;
  625. +     ++global_flag;
  626. +     sp = (struct sym *) xalloc((int) sizeof(struct sym));
  627. +     sp->tp = &tp_func;
  628. +     sp->name = strsave(".stmttrace");
  629. +     sp->storage_class = sc_external;
  630. +     ep = mk_node(en_nacon, NIL_ENODE, NIL_ENODE);
  631. +     ep->v.sp = sp->name;
  632. +     ep->etype = bt_pointer;
  633. +     ep->esize = 4;
  634. +     --global_flag;
  635. +     }
  636. + 
  637. +     /* create line number parameter */
  638. +     ep2 = mk_icon((long)act_line);
  639. +     ep2->etype = tp_int.type;
  640. +     ep2->esize = tp_int.size;
  641. +     ep1 = mk_node(en_list, ep2, NIL_ENODE);
  642. + 
  643. +     /* create file name parameter */
  644. +     ep2 = mk_node(en_labcon, NIL_ENODE, NIL_ENODE);
  645. +     ep2->v.i = stringlit(act_file, (int)strlen(act_file));
  646. +     ep2->etype = bt_pointer;
  647. +     ep2->esize = 4;
  648. +     ep1 = mk_node(en_list, ep2, ep1);
  649. + 
  650. +     /* do function call */
  651. +     pnode = mk_node(en_fcall, ep, ep1);
  652. +     pnode->etype = bt_void;
  653. +     pnode->esize = 0;
  654. +     *node = pnode;
  655. +     return;
  656. + }
  657. + #endif /* TRACE */
  658.   
  659. *** src/gen68k.c.o    Mon Dec  7 13:11:20 1992
  660. --- src/gen68k.c    Sun Dec  6 19:38:18 1992
  661. ***************
  662. *** 601,607 ****
  663.       if (!(flags & F_NOVALUE)) {
  664.           ap = temp_addr();
  665.           g_code(op_move, 4, mk_reg(RESULT), ap);
  666. !         ap->mode = am_ind;
  667.           return mk_legal(ap, flags, node->esize);
  668.       } else {
  669.       return 0;
  670. --- 601,608 ----
  671.       if (!(flags & F_NOVALUE)) {
  672.           ap = temp_addr();
  673.           g_code(op_move, 4, mk_reg(RESULT), ap);
  674. !         ap=copy_addr(ap);
  675. !     ap->mode = am_ind;
  676.           return mk_legal(ap, flags, node->esize);
  677.       } else {
  678.       return 0;
  679. ***************
  680. *** 1925,1931 ****
  681.       /*
  682.        * if (!tworegs)
  683.        * saves a function call result in D0
  684. !      * it is assumed that flags contain either F_DREG or F_AREG
  685.        *
  686.        * if (tworegs)
  687.        * saves a function call result in D0/D1
  688. --- 1926,1932 ----
  689.       /*
  690.        * if (!tworegs)
  691.        * saves a function call result in D0
  692. !      * it is assumed that flags contain either F_MEM, F_DREG or F_AREG
  693.        *
  694.        * if (tworegs)
  695.        * saves a function call result in D0/D1
  696. ***************
  697. *** 1966,1973 ****
  698.           g_code(op_move, 4, mk_reg(RESULT), ap);
  699.           return ap;
  700.           }
  701. !     }
  702. !     fatal("gen68k/func_result","illegal addressing mode");
  703.       return 0;
  704.   }
  705.   #endif /* NODOUBLE */
  706. --- 1967,1979 ----
  707.           g_code(op_move, 4, mk_reg(RESULT), ap);
  708.           return ap;
  709.           }
  710. !     if (flags & F_MEM) {
  711. !             ap = mk_scratch(4l);
  712. !         g_code(op_move, 4, mk_reg(RESULT), ap);
  713. !         return ap;
  714. !     }
  715. !     }
  716. !     fatal("gen68k/func_result","illegal addressing mode (%d, %d)", tworegs,flags);
  717.       return 0;
  718.   }
  719.   #endif /* NODOUBLE */
  720. ***************
  721. *** 2598,2606 ****
  722.       p->label = lab0;
  723.       p->value = node->v.f;
  724.       p->less = p->more = NULL;
  725. !     if (q == NULL)
  726. !         fptree = p;
  727. !     else if (q->value < node->v.f)
  728.           q->less = p;
  729.       else
  730.           q->more = p;
  731. --- 2604,2615 ----
  732.       p->label = lab0;
  733.       p->value = node->v.f;
  734.       p->less = p->more = NULL;
  735. !     if (q == NULL) {
  736. !         if (node->etype == bt_double)
  737. !         dfptree=p;
  738. !         else
  739. !             fptree=p;
  740. !     } else if (q->value < node->v.f)
  741.           q->less = p;
  742.       else
  743.           q->more = p;
  744. *** src/genstmt.c.o    Mon Dec  7 13:12:04 1992
  745. --- src/genstmt.c    Mon Dec  7 13:12:08 1992
  746. ***************
  747. *** 40,46 ****
  748.   /* genstmt.c */
  749.   static struct amode *mk_strlab P_((char *s));
  750.   static void genwhile P_((struct snode *stmt));
  751. ! static void g_for P_((struct snode *stmt));
  752.   static void genif P_((struct snode *stmt));
  753.   static void gendo P_((struct snode *stmt));
  754.   static void genswitch P_((struct snode *stmt));
  755. --- 40,46 ----
  756.   /* genstmt.c */
  757.   static struct amode *mk_strlab P_((char *s));
  758.   static void genwhile P_((struct snode *stmt));
  759. ! static void genfor P_((struct snode *stmt));
  760.   static void genif P_((struct snode *stmt));
  761.   static void gendo P_((struct snode *stmt));
  762.   static void genswitch P_((struct snode *stmt));
  763. ***************
  764. *** 126,131 ****
  765. --- 126,132 ----
  766.       return ap;
  767.   }
  768.   
  769. + #if 0
  770.   static void
  771.   genwhile(stmt)
  772.   /*
  773. ***************
  774. *** 177,250 ****
  775.       }
  776.       contlab = lab1;        /* restore old continue label */
  777.   }
  778. ! 
  779. ! static void
  780. ! g_for(stmt)
  781. ! /*
  782. !  * generate code to evaluate a for loop
  783.    */
  784.       struct snode   *stmt;
  785.   {
  786. !     unsigned int    old_break, old_cont, exit_label, loop_label;
  787.       old_break = breaklab;
  788.       old_cont = contlab;
  789.       loop_label = nextlabel++;
  790. !     exit_label = nextlabel++;
  791. !     if (stmt->v2.e != 0)
  792. !     contlab = nextlabel++;
  793. !     else
  794. !     contlab = loop_label;
  795.   #ifdef ICODE
  796.       if (icode_option) {
  797.       if (stmt->exp != 0)
  798.           g_icode(stmt->exp);
  799. !     iprintf("\tL%u:\n", loop_label);
  800.       }
  801.   #endif
  802.       initstack();
  803.       if (stmt->exp != 0) {
  804. !     (void) g_expr(stmt->exp, F_ALL | F_NOVALUE);
  805. !         checkstack();
  806. !     }
  807. !     g_label(loop_label);
  808. !     initstack();
  809. !     if (stmt->v1.e != 0) {
  810. ! #ifdef ICODE
  811. !     if (icode_option) {
  812. !         iprintf("*falsejp L%u\n", exit_label);
  813. !         g_icode(stmt->v1.e);
  814. !     }
  815. ! #endif
  816. !     falsejp(stmt->v1.e, exit_label);
  817. !         checkstack();
  818. !     }
  819. !     if (stmt->s1 != 0) {
  820. !     breaklab = exit_label;
  821. !     genstmt(stmt->s1);
  822. !     }
  823. ! #ifdef ICODE
  824. !     if (icode_option) {
  825. !     if (stmt->v2.e != 0) {
  826. !         iprintf("\tL%u:\n", contlab);
  827. !         g_icode(stmt->v2.e);
  828. !     }
  829. !     iprintf("\tbranch_unconditional\tL%u\n", loop_label);
  830. !     }
  831. ! #endif
  832. !     initstack();
  833. !     if (stmt->v2.e != 0) {
  834. !     g_label(contlab);
  835. !     (void) g_expr(stmt->v2.e, F_ALL | F_NOVALUE);
  836. !         checkstack();
  837. !     }
  838. !     g_code(op_bra, 0, mk_label(loop_label), NIL_AMODE);
  839. !     breaklab = old_break;
  840. !     contlab = old_cont;
  841. !     g_label(exit_label);
  842. ! #ifdef ICODE
  843. !     if (icode_option)
  844. !     iprintf("\tL%u:\n", exit_label);
  845. ! #endif
  846.   }
  847.   
  848.   static void
  849. --- 178,300 ----
  850.       }
  851.       contlab = lab1;        /* restore old continue label */
  852.   }
  853. ! #endif
  854. ! 
  855. ! static void
  856. ! genwhile(stmt)
  857. ! /*
  858. !  * generate code to evaluate a while statement.
  859.    */
  860.       struct snode   *stmt;
  861.   {
  862. !     unsigned int    lab1, lab2, looplab;
  863. !     initstack();        /* initialize temp registers */
  864. !     lab1 = contlab;        /* save old continue label */
  865. !     lab2 = breaklab;        /* save old break label */
  866. !     looplab = nextlabel++;    /* loop pabel */
  867. !     contlab = nextlabel++;    /* new continue label */
  868. !     breaklab = nextlabel++;    /* new break label */
  869. ! #ifdef ICODE
  870. !     if (icode_option) {
  871. !     iprintf("\tbranch_unconditional\tL%u\n", contlab);
  872. !     iprintf("\tL%u:\n", looplab);
  873. !     }
  874. ! #endif
  875. !     g_code(op_bra, 0, mk_label(contlab), NIL_AMODE);
  876. !     g_label(looplab);
  877. ! #ifdef ICODE
  878. !     if (icode_option)
  879. !     g_icode(stmt->exp);
  880. ! #endif
  881. !     genstmt(stmt->s1);
  882. ! #ifdef ICODE
  883. !     if (icode_option) {
  884. !     iprintf("\tL%u:\n", contlab);
  885. !     iprintf("*truejp L%u\n", looplab);
  886. !     }
  887. ! #endif
  888. !     g_label(contlab);
  889. !     initstack();
  890. !     truejp(stmt->exp, looplab);
  891. !     checkstack();
  892. ! #ifdef ICODE
  893. !     if (icode_option)
  894. !     iprintf("\tL%u:\n", breaklab);
  895. ! #endif
  896. !     g_label(breaklab);
  897. !     breaklab = lab2;    /* restore old break label */
  898. !     contlab = lab1;        /* restore old continue label */
  899. ! }
  900. ! 
  901. ! static void
  902. ! genfor(stmt)
  903. ! /*
  904. !  * generate code to evaluate a for loop
  905. !  */
  906. !     struct snode   *stmt;
  907. ! {
  908. !     unsigned int    old_break, old_cont, loop_label, entry_label;
  909.       old_break = breaklab;
  910.       old_cont = contlab;
  911.       loop_label = nextlabel++;
  912. !     entry_label = nextlabel++;
  913. !     breaklab = nextlabel++;
  914. !     contlab = nextlabel++;
  915.   #ifdef ICODE
  916.       if (icode_option) {
  917.       if (stmt->exp != 0)
  918.           g_icode(stmt->exp);
  919. !     iprintf("\tbranch_unconditional\tL%u\n", entry_label);
  920.       }
  921.   #endif
  922.       initstack();
  923.       if (stmt->exp != 0) {
  924. !     VOIDCAST g_expr(stmt->exp, F_ALL | F_NOVALUE);
  925. !         checkstack();
  926. !     }
  927. !     g_code(op_bra, 0, mk_label(entry_label), NIL_AMODE);
  928. !     g_label(loop_label);
  929. ! #ifdef ICODE
  930. !     if (icode_option) {
  931. !     g_icode(stmt->v1.e);
  932. !     iprintf("\tL%u:\n", contlabel);
  933. !     }
  934. ! #endif
  935. !     genstmt(stmt->s1);
  936. !     g_label(contlab);
  937. !     initstack();
  938. ! #ifdef ICODE
  939. !     if (icode_option) {
  940. !     if (stmt->v2.e != 0)
  941. !         g_icode(stmt->v2.e);
  942. !     iprintf("\tL%u:\n", entry_lab);
  943. !     }
  944. ! #endif
  945. !     if (stmt->v2.e != 0) {
  946. !     VOIDCAST g_expr(stmt->v2.e, F_ALL | F_NOVALUE);
  947. !         checkstack();
  948. !     }
  949. !     g_label(entry_label);
  950. !     initstack();
  951. !     if (stmt->v1.e == 0) {
  952. ! #ifdef ICODE
  953. !     if (icode_option)
  954. !         iprintf("\tbranch_unconditional\tL%u\n", entry_label);
  955. ! #endif
  956. !     g_code(op_bra, 0, mk_label(loop_label), NIL_AMODE);
  957. !     } else {
  958. ! #ifdef ICODE
  959. !     if (icode_option) {
  960. !         g_icode(stmt->v1.e);
  961. !         iprintf("*truejp L%u\n", loop_label);
  962. !     }
  963. ! #endif
  964. !     truejp(stmt->v1.e, loop_label);
  965. !         checkstack();
  966. !     }
  967. !     g_label(breaklab);
  968. !     breaklab = old_break;
  969. !     contlab = old_cont;
  970.   }
  971.   
  972.   static void
  973. ***************
  974. *** 371,381 ****
  975.   #ifdef MC680X0
  976.       struct amode   *ap2;
  977.   #endif
  978. !     struct enode   *ep,*stmtexp;
  979.       long            size;
  980.       enum e_bt        type;
  981.       long            min_caselabel, max_caselabel, nxt_caselabel;
  982.       int             number_of_cases;
  983.       defcase = 0;
  984.   #ifdef ICODE
  985.       if (icode_option) {
  986. --- 421,436 ----
  987.   #ifdef MC680X0
  988.       struct amode   *ap2;
  989.   #endif
  990. ! #ifdef INTEL_386
  991. !     struct enode   *ep;
  992. ! #endif
  993. !     struct enode   *stmtexp;
  994.       long            size;
  995.       enum e_bt        type;
  996.       long            min_caselabel, max_caselabel, nxt_caselabel;
  997.       int             number_of_cases;
  998. +     struct swtab   *sw;
  999. +     int           *labels;
  1000.       defcase = 0;
  1001.   #ifdef ICODE
  1002.       if (icode_option) {
  1003. ***************
  1004. *** 543,568 ****
  1005.           iprintf("default             ==> L%u\n",
  1006.               (unsigned int) deflab);
  1007.   #endif
  1008. ! #ifdef SEPARATE_I_D
  1009. !     dseg();
  1010. ! #else
  1011. !     cseg();
  1012. ! #endif    
  1013. !     nl();
  1014. !         put_align(AL_POINTER);
  1015. !     put_label(tablab);
  1016. !     ep = mk_node(en_labcon, NIL_ENODE, NIL_ENODE);
  1017.       while (min_caselabel <= max_caselabel) {
  1018.           nxt_caselabel = max_caselabel + 1;
  1019.           s = stmt;
  1020.           while (s != 0) {
  1021.           if (s->stype != st_default) {
  1022.               if (s->v2.i == min_caselabel) {
  1023. !             ep->v.i = nextlabel;
  1024. !             s->v2.i = nextlabel++;
  1025. !             /* remove statment from the list */
  1026. !             s->stype = st_default;
  1027. !             genptr(ep);
  1028.   #ifdef ICODE
  1029.               if (icode_option)
  1030.                   iprintf("case-value %8ld ==> L%u\n",
  1031. --- 598,618 ----
  1032.           iprintf("default             ==> L%u\n",
  1033.               (unsigned int) deflab);
  1034.   #endif
  1035. !     sw = xalloc((int)sizeof(struct swtab));
  1036. !     sw->tablab = tablab;
  1037. !     sw->numlabs = max_caselabel-min_caselabel +1;
  1038. !     sw->labels = labels = xalloc((int)sizeof(int) * sw->numlabs);
  1039. !     sw->next = swtables;
  1040. !     swtables = sw;
  1041.       while (min_caselabel <= max_caselabel) {
  1042.           nxt_caselabel = max_caselabel + 1;
  1043.           s = stmt;
  1044.           while (s != 0) {
  1045.           if (s->stype != st_default) {
  1046.               if (s->v2.i == min_caselabel) {
  1047. !             s->v2.i = *labels++ = nextlabel++;
  1048. !             /* remove statment from the list */
  1049. !             s->stype = st_default;
  1050.   #ifdef ICODE
  1051.               if (icode_option)
  1052.                   iprintf("case-value %8ld ==> L%u\n",
  1053. ***************
  1054. *** 575,582 ****
  1055.           }
  1056.           /* fill the holes */
  1057.           for (i = min_caselabel + 1; i < nxt_caselabel; i++) {
  1058. !         ep->v.i = deflab;
  1059. !         genptr(ep);
  1060.   #ifdef ICODE
  1061.           if (icode_option)
  1062.               iprintf("case-value %8ld ==> L%u\n",
  1063. --- 625,631 ----
  1064.           }
  1065.           /* fill the holes */
  1066.           for (i = min_caselabel + 1; i < nxt_caselabel; i++) {
  1067. !         *labels++ = deflab;
  1068.   #ifdef ICODE
  1069.           if (icode_option)
  1070.               iprintf("case-value %8ld ==> L%u\n",
  1071. ***************
  1072. *** 715,721 ****
  1073.           ep1 = mk_node(en_assign, ep1, stmt->exp);
  1074.           ep1->etype = ret_type->type;
  1075.           ep1->esize = ret_type->size;
  1076. !         (void) g_expr(ep1, F_ALL | F_NOVALUE);
  1077.   #ifdef MC680X0
  1078.           /* move pointer to D0 */
  1079.               ap = g_expr(ep, F_ALL);
  1080. --- 764,770 ----
  1081.           ep1 = mk_node(en_assign, ep1, stmt->exp);
  1082.           ep1->etype = ret_type->type;
  1083.           ep1->esize = ret_type->size;
  1084. !         VOIDCAST g_expr(ep1, F_ALL | F_NOVALUE);
  1085.   #ifdef MC680X0
  1086.           /* move pointer to D0 */
  1087.               ap = g_expr(ep, F_ALL);
  1088. ***************
  1089. *** 742,748 ****
  1090.             case bt_float:
  1091.   #ifdef INTEL_386
  1092.               /* return floating point value on top of fpu stack */
  1093. !             (void) g_expr(stmt->exp, F_FPSTACK);
  1094.   #ifdef FUNCS_USE_387
  1095.           if (!fpu_option)
  1096.   /*
  1097. --- 791,797 ----
  1098.             case bt_float:
  1099.   #ifdef INTEL_386
  1100.               /* return floating point value on top of fpu stack */
  1101. !             VOIDCAST g_expr(stmt->exp, F_FPSTACK);
  1102.   #ifdef FUNCS_USE_387
  1103.           if (!fpu_option)
  1104.   /*
  1105. ***************
  1106. *** 895,901 ****
  1107.           g_icode(stmt->exp);
  1108.   #endif
  1109.           initstack();
  1110. !         (void) g_expr(stmt->exp, F_ALL | F_NOVALUE);
  1111.               checkstack();
  1112.           break;
  1113.         case st_return:
  1114. --- 944,950 ----
  1115.           g_icode(stmt->exp);
  1116.   #endif
  1117.           initstack();
  1118. !         VOIDCAST g_expr(stmt->exp, F_ALL | F_NOVALUE);
  1119.               checkstack();
  1120.           break;
  1121.         case st_return:
  1122. ***************
  1123. *** 911,917 ****
  1124.           gendo(stmt);
  1125.           break;
  1126.         case st_for:
  1127. !         g_for(stmt);
  1128.           break;
  1129.         case st_continue:
  1130.           g_code(op_bra, 0, mk_label(contlab), NIL_AMODE);
  1131. --- 960,966 ----
  1132.           gendo(stmt);
  1133.           break;
  1134.         case st_for:
  1135. !         genfor(stmt);
  1136.           break;
  1137.         case st_continue:
  1138.           g_code(op_bra, 0, mk_label(contlab), NIL_AMODE);
  1139. ***************
  1140. *** 962,973 ****
  1141.       if (lc_auto % AL_DEFAULT != 0)
  1142.       lc_auto += AL_DEFAULT - (lc_auto % AL_DEFAULT);
  1143.   #ifdef VERBOSE
  1144. !     (void) times(&tms_buf);
  1145.       ltime = tms_buf.tms_utime;
  1146.   #endif                /* VERBOSE */
  1147.       opt1(stmt);
  1148.   #ifdef VERBOSE
  1149. !     (void) times(&tms_buf);
  1150.       opt_time += tms_buf.tms_utime - ltime;
  1151.   #endif                /* VERBOSE */
  1152.       genstmt(stmt);
  1153. --- 1011,1022 ----
  1154.       if (lc_auto % AL_DEFAULT != 0)
  1155.       lc_auto += AL_DEFAULT - (lc_auto % AL_DEFAULT);
  1156.   #ifdef VERBOSE
  1157. !     VOIDCAST times(&tms_buf);
  1158.       ltime = tms_buf.tms_utime;
  1159.   #endif                /* VERBOSE */
  1160.       opt1(stmt);
  1161.   #ifdef VERBOSE
  1162. !     VOIDCAST times(&tms_buf);
  1163.       opt_time += tms_buf.tms_utime - ltime;
  1164.   #endif                /* VERBOSE */
  1165.       genstmt(stmt);
  1166. *** src/init.c.o    Mon Dec  7 13:12:39 1992
  1167. --- src/init.c    Sat Nov 28 09:17:12 1992
  1168. ***************
  1169. *** 61,67 ****
  1170.       else
  1171.       g_strlab(sp->name);
  1172.       getsym();
  1173. !     (void) inittype(sp->tp);
  1174.       sp->used |= SYM_DEFINED;
  1175.   }
  1176.   
  1177. --- 61,67 ----
  1178.       else
  1179.       g_strlab(sp->name);
  1180.       getsym();
  1181. !     VOIDCAST inittype(sp->tp);
  1182.       sp->used |= SYM_DEFINED;
  1183.   }
  1184.   
  1185. ***************
  1186. *** 130,140 ****
  1187.       if (( lastst == sconst)
  1188.       &&  (tp->btp->type == bt_char || tp->btp->type == bt_uchar)) {
  1189.       len = lstrlen;
  1190. !     nbytes = len + 1;
  1191.       p = laststr;
  1192.       while (len--)
  1193.           genbyte((int)*p++);
  1194. !     genbyte(0);
  1195.       while (nbytes < tp->size) {
  1196.           genbyte(0);
  1197.           nbytes++;
  1198. --- 130,141 ----
  1199.       if (( lastst == sconst)
  1200.       &&  (tp->btp->type == bt_char || tp->btp->type == bt_uchar)) {
  1201.       len = lstrlen;
  1202. !     nbytes = len;
  1203.       p = laststr;
  1204.       while (len--)
  1205.           genbyte((int)*p++);
  1206. !       if (tp->size == 0)
  1207. !           tp->size = nbytes+1;
  1208.       while (nbytes < tp->size) {
  1209.           genbyte(0);
  1210.           nbytes++;
  1211. ***************
  1212. *** 146,151 ****
  1213. --- 147,154 ----
  1214.           if (lastst == comma)
  1215.           getsym();
  1216.           if (lastst == end || lastst == semicolon) {
  1217. +         if (nbytes < tp->size)
  1218. +             message(WARN_INCOMPLETE);
  1219.           while (nbytes < tp->size) {
  1220.               genbyte(0);
  1221.               nbytes++;
  1222. ***************
  1223. *** 202,209 ****
  1224.       nbytes += inittype(sp->tp);
  1225.       if (lastst == comma)
  1226.           getsym();
  1227. !     if (lastst == end || lastst == semicolon)
  1228. !         break;
  1229.       sp = sp->next;
  1230.       }
  1231.       while (nbytes < tp->size) {
  1232. --- 205,215 ----
  1233.       nbytes += inittype(sp->tp);
  1234.       if (lastst == comma)
  1235.           getsym();
  1236. !     if (lastst == end || lastst == semicolon) {
  1237. !         if (sp->next != NULL)
  1238. !         message (WARN_INCOMPLETE);
  1239. !         break;
  1240. !     }
  1241.       sp = sp->next;
  1242.       }
  1243.       while (nbytes < tp->size) {
  1244. ***************
  1245. *** 216,229 ****
  1246.   static int
  1247.   initchar()
  1248.   {
  1249. !     genbyte((int) intexpr());
  1250.       return 1;
  1251.   }
  1252.   
  1253.   static int
  1254.   initshort()
  1255.   {
  1256. !     genword((int) intexpr());
  1257.       return 2;
  1258.   }
  1259.   
  1260. --- 222,235 ----
  1261.   static int
  1262.   initchar()
  1263.   {
  1264. !     genbyte((int) arithexpr());
  1265.       return 1;
  1266.   }
  1267.   
  1268.   static int
  1269.   initshort()
  1270.   {
  1271. !     genword((int) arithexpr());
  1272.       return 2;
  1273.   }
  1274.   
  1275. *** src/intexpr.c.o    Mon Dec  7 13:12:50 1992
  1276. --- src/intexpr.c    Mon Dec  7 13:12:52 1992
  1277. ***************
  1278. *** 55,61 ****
  1279.   #endif /* !NOFLOAT */
  1280.   
  1281.   long
  1282. ! intexpr()
  1283.   {
  1284.       struct enode   *ep;
  1285.       struct typ     *tp;
  1286. --- 55,62 ----
  1287.   #endif /* !NOFLOAT */
  1288.   
  1289.   long
  1290. ! arithexpr()
  1291. ! /* integer arithmetic expression */
  1292.   {
  1293.       struct enode   *ep;
  1294.       struct typ     *tp;
  1295. ***************
  1296. *** 63,68 ****
  1297. --- 64,95 ----
  1298.       tp = exprnc(&ep);
  1299.       if (tp == 0) {
  1300.       message(ERR_INTEXPR);
  1301. +     return (double) 0;
  1302. +     }
  1303. + 
  1304. +     opt4(&ep);
  1305. + 
  1306. +     if (ep->nodetype == en_icon)
  1307. +         return ep->v.i;
  1308. + 
  1309. + #ifndef NOFLOAT
  1310. +     if (ep->nodetype == en_fcon)
  1311. +         return (long) ep->v.f;
  1312. + #endif /* !NOFLOAT */
  1313. + 
  1314. +     message (ERR_CONSTEXPR);
  1315. +     return 0;
  1316. + }
  1317. + 
  1318. + long
  1319. + intexpr()
  1320. + {
  1321. +     struct enode   *ep;
  1322. +     struct typ     *tp;
  1323. + 
  1324. +     tp = exprnc(&ep);
  1325. +     if (tp == 0) {
  1326. +     message(ERR_INTEXPR);
  1327.       /*
  1328.        * any return value is wrong, but 1 is 
  1329.        * less likely than 0 to cause spurious
  1330.