home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #1 / NN_1993_1.iso / spool / comp / os / minix / 5126 / patch4.2c.Z / patch4.2c
Encoding:
Text File  |  1993-01-11  |  32.6 KB  |  1,424 lines
  1. *** src/msgout.c.o    Mon Dec  7 13:13:17 1992
  2. --- src/msgout.c    Mon Dec  7 13:13:20 1992
  3. ***************
  4. *** 49,55 ****
  5.   # define VA_START(a,s)    va_start(a,s)
  6.   # ifdef __STDC__
  7.   #  define P1(p1, p2)    (p1 p2, ...)
  8. ! #  define P2(p1, p2, p3, p4)    (p1 p2, p3, p4, ...)
  9.   # else
  10.   #  define P1(p1, p2)    (p2) p1 p2;
  11.   #  define P2(p1, p2, p3, p4)    (p2, p4) p1 p2; p3 p4;
  12. --- 49,55 ----
  13.   # define VA_START(a,s)    va_start(a,s)
  14.   # ifdef __STDC__
  15.   #  define P1(p1, p2)    (p1 p2, ...)
  16. ! #  define P2(p1, p2, p3, p4)    (p1 p2, p3 p4, ...)
  17.   # else
  18.   #  define P1(p1, p2)    (p2) p1 p2;
  19.   #  define P2(p1, p2, p3, p4)    (p2, p4) p1 p2; p3 p4;
  20. ***************
  21. *** 128,133 ****
  22. --- 128,134 ----
  23.   /* ERR_FIELD     */    "no field allowed here",
  24.   /* ERR_FPCON    */     "illegal floating-point constant",
  25.   /* ERR_IDEXPECT     */    "identifier expected",
  26. + /* ERR_ILLCAST    */     "illegal cast operation",
  27.   /* ERR_ILLCHAR    */     "illegal character '%c'",
  28.   /* ERR_ILLCLASS    */    "illegal storage class",
  29.   /* ERR_ILLINIT    */    "illegal initialization",
  30. ***************
  31. *** 186,196 ****
  32. --- 187,199 ----
  33.    *    code, but are quite likely not be an error.
  34.    */
  35.   /* WARN_0TYPEDEF */    "zero-sized typedef may be changed by initialisations",
  36. + /* WARN_ADDARRAY */    "& operator on array ignored",
  37.   /* WARN_ADDFUNC */    "& operator on function ignored",
  38.   /* WARN_EMPTY */    "empty statment",
  39.   /* WARN_HIDE */        "definition of '%s' hides an earlier definition",
  40.   /* WARN_IMPLICIT */    "argument '%s' implicitly declared 'int'",
  41.   /* WARN_IMPLICITFN */    "implicitly declared function: 'int %s()'",
  42. + /* WARN_INCOMPLETE */    "initialisation incomplete - remaining fields zeroed",
  43.   /* WARN_NOTKANDR */    "the use of '%s' is not allowed under strict K&R C",
  44.   /* WARN_NOTUSED */    "variable/function '%s' not used",
  45.   /*
  46. ***************
  47. *** 224,230 ****
  48.   /* WARN_FLDTYPE    */    "bit field type should be unsigned or int",
  49.   /* WARN_NOCOPY */    "didn't copy local struct/union in save_type",
  50.   /* WARN_PRAGMA */    "#pragma ignored",
  51. - /* WARN_STRINGCUT */    "string constant cut as it exceeds %d characters",
  52.   /*
  53.    *    Messages below this point are output without file/line number details
  54.    */
  55. --- 227,232 ----
  56. ***************
  57. *** 286,292 ****
  58.   va_list ap;
  59.   
  60.     VA_START (ap, formatstr);
  61. !   (void) vfprintf (stderr, formatstr, ap);
  62.     va_end(ap);
  63.   }
  64.   
  65. --- 288,294 ----
  66.   va_list ap;
  67.   
  68.     VA_START (ap, formatstr);
  69. !   VOIDCAST vfprintf (stderr, formatstr, ap);
  70.     va_end(ap);
  71.   }
  72.   
  73. ***************
  74. *** 301,307 ****
  75.   va_list ap;
  76.   
  77.     VA_START (ap, formatstr);
  78. !   (void) vfprintf (icode, formatstr, ap);
  79.     va_end(ap);
  80.   }
  81.   #endif /* ICODE */
  82. --- 303,309 ----
  83.   va_list ap;
  84.   
  85.     VA_START (ap, formatstr);
  86. !   VOIDCAST vfprintf (icode, formatstr, ap);
  87.     va_end(ap);
  88.   }
  89.   #endif /* ICODE */
  90. ***************
  91. *** 316,322 ****
  92.   va_list ap;
  93.   
  94.     VA_START (ap, formatstr);
  95. !   (void) vfprintf (list, formatstr, ap);
  96.     va_end(ap);
  97.   }
  98.   
  99. --- 318,324 ----
  100.   va_list ap;
  101.   
  102.     VA_START (ap, formatstr);
  103. !   VOIDCAST vfprintf (list, formatstr, ap);
  104.     va_end(ap);
  105.   }
  106.   
  107. ***************
  108. *** 330,336 ****
  109.   va_list ap;
  110.   
  111.     VA_START (ap, formatstr);
  112. !   (void) vfprintf (output, formatstr, ap);
  113.     va_end(ap);
  114.   }
  115.   
  116. --- 332,338 ----
  117.   va_list ap;
  118.   
  119.     VA_START (ap, formatstr);
  120. !   VOIDCAST vfprintf (output, formatstr, ap);
  121.     va_end(ap);
  122.   }
  123.   
  124. ***************
  125. *** 344,350 ****
  126.   
  127.     VA_START(ap,msgnum);
  128.     open_message("C68");
  129. !   (void) vfprintf (list,get_message(msgnum),ap);
  130.     lprintf ("\n");
  131.     va_end(ap);
  132.   }
  133. --- 346,352 ----
  134.   
  135.     VA_START(ap,msgnum);
  136.     open_message("C68");
  137. !   VOIDCAST vfprintf (list,get_message(msgnum),ap);
  138.     lprintf ("\n");
  139.     va_end(ap);
  140.   }
  141. ***************
  142. *** 398,409 ****
  143.       if (list_option) {
  144.           /* output details to listing file */
  145.       lprintf (" *** %s",get_message(errtype));
  146. !     (void) vfprintf(list, get_message(msgnum), ap);
  147.       lprintf ("\n");
  148.       }
  149.     }
  150.     /* finally we output text + newline */
  151. !   (void) vfprintf (stderr, get_message(msgnum), ap);
  152.     eprintf ("\n");
  153.   
  154.     if (msgnum < WARN_BASE) {
  155. --- 400,411 ----
  156.       if (list_option) {
  157.           /* output details to listing file */
  158.       lprintf (" *** %s",get_message(errtype));
  159. !     VOIDCAST vfprintf(list, get_message(msgnum), ap);
  160.       lprintf ("\n");
  161.       }
  162.     }
  163.     /* finally we output text + newline */
  164. !   VOIDCAST vfprintf (stderr, get_message(msgnum), ap);
  165.     eprintf ("\n");
  166.   
  167.     if (msgnum < WARN_BASE) {
  168. ***************
  169. *** 428,438 ****
  170.       static int      beenhere = 0;
  171.   
  172.       VA_START (ap,msg);
  173. !     message(MSG_FATAL,routine);
  174. !     (void) vfprintf(stderr,msg,ap);
  175. !     message(MSG_MISSING);
  176. !     if (!beenhere) {
  177. !     beenhere = 1;
  178.       flush_peep();
  179.       }
  180.       va_end(ap);
  181. --- 430,440 ----
  182.       static int      beenhere = 0;
  183.   
  184.       VA_START (ap,msg);
  185. !     if (!beenhere) {
  186. !     beenhere = 1;
  187. !     message(MSG_FATAL,routine);
  188. !     VOIDCAST vfprintf(stderr,msg,ap);
  189. !     message(MSG_MISSING);
  190.       flush_peep();
  191.       }
  192.       va_end(ap);
  193. *** src/optimize.c.o    Mon Dec  7 13:13:36 1992
  194. --- src/optimize.c    Mon Dec  7 13:13:40 1992
  195. ***************
  196. *** 80,86 ****
  197.               epf = ep0->v.f * ep1->v.f;
  198.               break;
  199.             case en_div:
  200. !         if (ep1->v.f == 0.0) {
  201.               message(GWARN_DIVZERO);
  202.               ep->nodetype = en_div;
  203.           } else {
  204. --- 80,86 ----
  205.               epf = ep0->v.f * ep1->v.f;
  206.               break;
  207.             case en_div:
  208. !         if (ep1->v.f == ((double) 0)) {
  209.               message(GWARN_DIVZERO);
  210.               ep->nodetype = en_div;
  211.           } else {
  212. *** src/out386_bas.c.o    Mon Dec  7 13:13:50 1992
  213. --- src/out386_bas.c    Mon Dec  7 13:13:54 1992
  214. ***************
  215. *** 64,69 ****
  216. --- 64,70 ----
  217.   
  218.   #define    BI    1
  219.   #define SP    2
  220. + #define FP    4
  221.   
  222.   static struct oplst {
  223.       char           *s;
  224. ***************
  225. *** 71,76 ****
  226. --- 72,78 ----
  227.       int            sa;    /* special addressing modes:
  228.                    *    BI    immediate is bracketed,
  229.                    *    SP    size prefix needed.
  230. +              *    FP    387 op
  231.                    */
  232.   }               opl[] =
  233.   
  234. ***************
  235. *** 119,139 ****
  236.   "rep",        op_rep,        SP,
  237.   "movs",        op_smov,    BI | SP,
  238.   "test",        op_test,    BI | SP,
  239. ! "fadd",        op_fadd,    BI | SP,
  240. ! "fsub",        op_fsub,    BI | SP,
  241. ! "fsubr",    op_fsubr,    BI | SP,
  242. ! "fmul",        op_fmul,    BI | SP,
  243. ! "fdiv",        op_fdiv,    BI | SP,
  244. ! "fdivr",    op_fdivr,    BI | SP,
  245. ! "fchs",        op_fchs,    BI | SP,
  246. ! "fld",        op_fld,        BI | SP,
  247. ! "fild",        op_fild,    BI | SP,
  248. ! "fst",        op_fst,        BI | SP,
  249. ! "fstp",        op_fstp,    BI | SP,
  250. ! "fstp %st(0)",    op_fpop,    BI | SP,
  251. ! "fcompp",    op_fcompp,    BI | SP,
  252. ! "ftst",        op_ftst,    BI | SP,
  253. ! "fnstsw",    op_fnstsw,    BI | SP,
  254.   "sahf",        op_sahf,    BI | SP,
  255.   0,        0,        0
  256.   };
  257. --- 121,143 ----
  258.   "rep",        op_rep,        SP,
  259.   "movs",        op_smov,    BI | SP,
  260.   "test",        op_test,    BI | SP,
  261. ! #ifndef NOFLOAT
  262. ! "fadd",        op_fadd,    BI | SP | FP,
  263. ! "fsub",        op_fsub,    BI | SP | FP,
  264. ! "fsubr",    op_fsubr,    BI | SP | FP,
  265. ! "fmul",        op_fmul,    BI | SP | FP,
  266. ! "fdiv",        op_fdiv,    BI | SP | FP,
  267. ! "fdivr",    op_fdivr,    BI | SP | FP,
  268. ! "fchs",        op_fchs,    BI | SP | FP,
  269. ! "fld",        op_fld,        BI | SP | FP,
  270. ! "fild",        op_fild,    BI | SP | FP,
  271. ! "fst",        op_fst,        BI | SP | FP,
  272. ! "fstp",        op_fstp,    BI | SP | FP,
  273. ! "fstp st(0)",    op_fpop,    BI | SP | FP,
  274. ! "fcompp",    op_fcompp,    BI | SP | FP,
  275. ! "ftst",        op_ftst,    BI | SP | FP,
  276. ! "fnstsw",    op_fnstsw,    BI | SP | FP,
  277. ! #endif
  278.   "sahf",        op_sahf,    BI | SP,
  279.   0,        0,        0
  280.   };
  281. ***************
  282. *** 257,262 ****
  283. --- 261,276 ----
  284.           break;
  285.       }
  286.       }    
  287. + #ifndef NOFLOAT
  288. +     if (sa & FP) {
  289. +     /* assume that st(n) never appears explicitly as an operand here */
  290. +     if (len >= 8)
  291. +         oprintf("qword ptr ");
  292. +     else if (len >= 4)
  293. +         oprintf("dword ptr ");
  294. +     /* else fnstsw should not need a length? */
  295. +     }
  296. + #endif
  297.       switch (ap->mode) {
  298.         case am_immed:
  299.       oprintf("#");
  300. ***************
  301. *** 290,296 ****
  302.           oprintf("[%s+%s]",regname[ap->preg],regname[ap->sreg]);
  303.           break;
  304.         default:
  305. !     fatal("out386_bas/putamdoe","illegal address mode %d",ap->mode);
  306.       break;
  307.       }
  308.   }
  309. --- 304,310 ----
  310.           oprintf("[%s+%s]",regname[ap->preg],regname[ap->sreg]);
  311.           break;
  312.         default:
  313. !     fatal("out386_bas/putamode","illegal address mode %d",ap->mode);
  314.       break;
  315.       }
  316.   }
  317. ***************
  318. *** 414,427 ****
  319.   genfloat(val)
  320.       double          val;
  321.   {
  322. !     oprintf("\t.float %20.15e\n",val);
  323.   }
  324.   
  325.   void
  326.   gendouble(val)
  327.       double          val;
  328.   {
  329. !     oprintf("\t.double %20.15e\n",val);
  330.   }
  331.   #endif
  332.   
  333. --- 428,453 ----
  334.   genfloat(val)
  335.       double          val;
  336.   {
  337. ! #ifndef NO_FLOAT_PRINTF
  338. !     oprintf("\t.float %14.7e\n",val);
  339. ! #else
  340. !     float fval;
  341. !     fval = (float) val;
  342. !     /* this type transfer won't cross compile, of course. */
  343. !     oprintf("\t.long %d\n", ((long *)&fval)[0]);
  344. ! #endif
  345.   }
  346.   
  347.   void
  348.   gendouble(val)
  349.       double          val;
  350.   {
  351. ! #ifndef NO_FLOAT_PRINTF
  352. !     oprintf("\t.double %23.16e\n",val);
  353. ! #else
  354. !     /* this type transfer won't cross compile, of course. */
  355. !     oprintf("\t.long %d, %d\n", ((long *)&val)[0], ((long *)&val)[1]);
  356. ! #endif
  357.   }
  358.   #endif
  359.   
  360. ***************
  361. *** 585,594 ****
  362.       if (*s == '.')
  363.           return s;
  364.   #ifdef QDOS
  365. !     (void) strcpy(symbol, s);
  366. ! #else
  367. !     symbol[0] = '_';
  368. !     (void) strcpy(symbol + 1, s);
  369.   #endif
  370.       return symbol;
  371.   }
  372. --- 611,620 ----
  373.       if (*s == '.')
  374.           return s;
  375.   #ifdef QDOS
  376. !     VOIDCAST strcpy(symbol, s);
  377. ! #else
  378. !     symbol[0] = '_';
  379. !     VOIDCAST strcpy(symbol + 1, s);
  380.   #endif
  381.       return symbol;
  382.   }
  383. *** src/out386_gas.c.o    Mon Dec  7 13:14:05 1992
  384. --- src/out386_gas.c    Mon Dec  7 13:14:08 1992
  385. ***************
  386. *** 86,95 ****
  387.       if (*s == '.')
  388.           return s;
  389.   #ifdef QDOS
  390. !     (void) strcpy(symbol, s);
  391. ! #else
  392. !     symbol[0] = '_';
  393. !     (void) strcpy(symbol + 1, s);
  394.   #endif
  395.       return symbol;
  396.   }
  397. --- 86,95 ----
  398.       if (*s == '.')
  399.           return s;
  400.   #ifdef QDOS
  401. !     VOIDCAST strcpy(symbol, s);
  402. ! #else
  403. !     symbol[0] = '_';
  404. !     VOIDCAST strcpy(symbol + 1, s);
  405.   #endif
  406.       return symbol;
  407.   }
  408. ***************
  409. *** 538,548 ****
  410.   dumplits()
  411.   /*
  412.    * dump the string literal pool.
  413.    */
  414.   {
  415.       char           *cp;
  416.       int             len;
  417. !     cseg();
  418.       while (strtab != 0) {
  419.       nl();
  420.       put_label((unsigned int) strtab->label);
  421. --- 538,553 ----
  422.   dumplits()
  423.   /*
  424.    * dump the string literal pool.
  425. +  * if we are producing single copies of strings (which should therefore
  426. +  * be read only we put them in the text segement - else in the data segment.
  427.    */
  428.   {
  429.       char           *cp;
  430.       int             len;
  431. !     if (trad_option)
  432. !     dseg();
  433. !     else
  434. !     cseg();
  435.       while (strtab != 0) {
  436.       nl();
  437.       put_label((unsigned int) strtab->label);
  438. ***************
  439. *** 554,559 ****
  440. --- 559,566 ----
  441.       strtab = strtab->next;
  442.       }
  443.       nl();
  444. +     if (trad_option)
  445. +     cseg();
  446.   }
  447.   
  448.   void
  449. *** src/out68k_ack.c.o    Mon Dec  7 13:14:18 1992
  450. --- src/out68k_ack.c    Mon Dec  7 13:14:21 1992
  451. ***************
  452. *** 547,557 ****
  453.   dumplits()
  454.   /*
  455.    * dump the string literal pool.
  456.    */
  457.   {
  458.       char           *cp;
  459.       int             len;
  460. !     cseg();
  461.       while (strtab != 0) {
  462.       nl();
  463.       put_label((unsigned int) strtab->label);
  464. --- 547,562 ----
  465.   dumplits()
  466.   /*
  467.    * dump the string literal pool.
  468. +  * if we are producing single copies of strings (which should therefore
  469. +  * be read only we put them in the text segement - else in the data segment.
  470.    */
  471.   {
  472.       char           *cp;
  473.       int             len;
  474. !     if (trad_option)
  475. !     dseg();
  476. !     else
  477. !     cseg();
  478.       while (strtab != 0) {
  479.       nl();
  480.       put_label((unsigned int) strtab->label);
  481. ***************
  482. *** 563,568 ****
  483. --- 568,575 ----
  484.       strtab = strtab->next;
  485.       }
  486.       nl();
  487. +     if (trad_option)
  488. +     cseg();
  489.   }
  490.   
  491.   /*ARGSUSED*/
  492. ***************
  493. *** 578,584 ****
  494.       char           *s;
  495.   /* put the definition of a global name in the output file */
  496.   {
  497. !     oprintf(".define %s\n",outlate(s));
  498.   }
  499.   
  500.   void
  501. --- 585,591 ----
  502.       char           *s;
  503.   /* put the definition of a global name in the output file */
  504.   {
  505. !     oprintf(".extern %s\n",outlate(s));
  506.   }
  507.   
  508.   void
  509. ***************
  510. *** 648,657 ****
  511.       if (*string == '.')
  512.           return string;
  513.   #ifdef QDOS
  514. !     (void) strcpy(symname, string);
  515. ! #else
  516. !     symname[0] = '_';
  517. !     (void) strcpy(symname + 1, string);
  518.   #endif
  519.   
  520.       if (((k = strlen(symname)) > 8) && trans_option) {
  521. --- 655,664 ----
  522.       if (*string == '.')
  523.           return string;
  524.   #ifdef QDOS
  525. !     VOIDCAST strcpy(symname, string);
  526. ! #else
  527. !     symname[0] = '_';
  528. !     VOIDCAST strcpy(symname + 1, string);
  529.   #endif
  530.   
  531.       if (((k = strlen(symname)) > 8) && trans_option) {
  532. *** src/out68k_cpm.c.o    Mon Dec  7 13:14:31 1992
  533. --- src/out68k_cpm.c    Mon Dec  7 13:14:34 1992
  534. ***************
  535. *** 496,506 ****
  536.   dumplits()
  537.   /*
  538.    * dump the string literal pool.
  539.    */
  540.   {
  541.       char           *cp;
  542.       int             len;
  543. !     cseg();
  544.       while (strtab != 0) {
  545.       nl();
  546.       put_label((unsigned int) strtab->label);
  547. --- 496,511 ----
  548.   dumplits()
  549.   /*
  550.    * dump the string literal pool.
  551. +  * if we are producing single copies of strings (which should therefore
  552. +  * be read only we put them in the text segement - else in the data segment.
  553.    */
  554.   {
  555.       char           *cp;
  556.       int             len;
  557. !     if (trad_option)
  558. !     dseg();
  559. !     else
  560. !     cseg();
  561.       while (strtab != 0) {
  562.       nl();
  563.       put_label((unsigned int) strtab->label);
  564. ***************
  565. *** 512,517 ****
  566. --- 517,524 ----
  567.       strtab = strtab->next;
  568.       }
  569.       nl();
  570. +     if (trad_option)
  571. +     cseg();
  572.   }
  573.   
  574.   /*ARGSUSED*/
  575. ***************
  576. *** 604,613 ****
  577.       if (*string == '.')
  578.           return string;
  579.   #ifdef QDOS
  580. !     (void) strcpy(symname, string);
  581. ! #else
  582. !     symname[0] = '_';
  583. !     (void) strcpy(symname + 1, string);
  584.   #endif
  585.   
  586.       if (((k = strlen(symname)) > 8) && trans_option) {
  587. --- 611,620 ----
  588.       if (*string == '.')
  589.           return string;
  590.   #ifdef QDOS
  591. !     VOIDCAST strcpy(symname, string);
  592. ! #else
  593. !     symname[0] = '_';
  594. !     VOIDCAST strcpy(symname + 1, string);
  595.   #endif
  596.   
  597.       if (((k = strlen(symname)) > 8) && trans_option) {
  598. *** src/out68k_gas.c.o    Mon Dec  7 13:14:44 1992
  599. --- src/out68k_gas.c    Mon Dec  7 13:14:47 1992
  600. ***************
  601. *** 445,485 ****
  602.   dumplits()
  603.   /*
  604.    * dump the string literal pool.
  605.    */
  606.   {
  607.       char           *cp;
  608.       int             len;
  609. ! /*
  610. !  * The ACK assembler may produce a .text section of an uneven length.
  611. !  * This will eventually bomb the linker when it tries to relocate
  612. !  * something in a following (.data) section, which then is misaligned
  613. !  * as a whole in memory (perhaps this is just a bug in the linker).
  614. !  *
  615. !  * To avoid this (it can only happen if the string pool is the last
  616. !  * thing dumped to the assembler file) we count the total number of
  617. !  * bytes in the string pool and emit a zero filler byte if that
  618. !  * number was uneven.
  619. !  * This is perhaps an ugly hack, but in virtually all of the cases
  620. !  * this filler byte is inserted anyway by the assembler when
  621. !  * doing the alignment necessary for the next function body.
  622. !  */
  623. !     long        count=0;
  624. ! 
  625. !     cseg();
  626.       while (strtab != 0) {
  627.       nl();
  628.       put_label((unsigned int) strtab->label);
  629.       cp = strtab->str;
  630.       len = strtab->len;
  631. -     count += (len+1);
  632.       while (len--)
  633.           genbyte(*cp++);
  634.       genbyte(0);
  635.       strtab = strtab->next;
  636.       }
  637. !     if (count & 1)
  638. !     genbyte(0);
  639. !     nl();
  640.   }
  641.   
  642.   void
  643. --- 445,474 ----
  644.   dumplits()
  645.   /*
  646.    * dump the string literal pool.
  647. +  * if we are producing single copies of strings (which should therefore
  648. +  * be read only we put them in the text segement - else in the data segment.
  649.    */
  650.   {
  651.       char           *cp;
  652.       int             len;
  653. ! 
  654. !     if (trad_option)
  655. !     dseg();
  656. !     else
  657. !     cseg();
  658.       while (strtab != 0) {
  659.       nl();
  660.       put_label((unsigned int) strtab->label);
  661.       cp = strtab->str;
  662.       len = strtab->len;
  663.       while (len--)
  664.           genbyte(*cp++);
  665.       genbyte(0);
  666.       strtab = strtab->next;
  667.       }
  668. !     nl();
  669. !     if (trad_option)
  670. !     cseg();
  671.   }
  672.   
  673.   void
  674. ***************
  675. *** 549,558 ****
  676.       if (*s == '.')
  677.           return s;
  678.   #ifdef QDOS
  679. !     (void) strcpy(symbol, s);
  680. ! #else
  681. !     symbol[0] = '_';
  682. !     (void) strcpy(symbol + 1, s);
  683.   #endif
  684.       return symbol;
  685.   }
  686. --- 538,547 ----
  687.       if (*s == '.')
  688.           return s;
  689.   #ifdef QDOS
  690. !     VOIDCAST strcpy(symbol, s);
  691. ! #else
  692. !     symbol[0] = '_';
  693. !     VOIDCAST strcpy(symbol + 1, s);
  694.   #endif
  695.       return symbol;
  696.   }
  697. *** src/peep386.c.o    Tue Dec 01 23:27:19 1992
  698. --- src/peep386.c    Wed Dec 09 18:27:50 1992
  699. ***************
  700. *** 144,149 ****
  701. --- 144,152 ----
  702.    */
  703.   {
  704.       register struct ocode *ip;
  705. +     struct swtab      *sw;
  706. +     struct enode      *ep;
  707. +     int               i;
  708.   /*
  709.    * perform peephole optimizations
  710.    */
  711. ***************
  712. *** 160,165 ****
  713. --- 163,184 ----
  714.       ip = ip->fwd;
  715.       }
  716.       peep_head = 0;
  717. +     ep = mk_node(en_labcon, NIL_ENODE, NIL_ENODE);
  718. +     for(sw=swtables; sw; sw=sw->next) {
  719. +     nl();
  720. + #ifdef SEPERATE_I_D
  721. +     dseg();
  722. + #else
  723. +     cseg();
  724. + #endif
  725. +     put_align(AL_POINTER);
  726. +     put_label((unsigned) sw->tablab);
  727. +     for(i=0; i<sw->numlabs; i++) {
  728. +         ep->v.i = sw->labels[i];
  729. +         genptr(ep);
  730. +     }
  731. +     }
  732. +     swtables = NULL;
  733.   }
  734.   
  735.   static void
  736. ***************
  737. *** 382,387 ****
  738. --- 401,409 ----
  739.       }
  740.   }
  741.   
  742. + #define branch(ip)    ((ip->opcode >= op_je && ip->opcode <= op_jbe) || \
  743. +              (ip->opcode == op_bra))
  744. + 
  745.   static void
  746.   peep_label(ip)
  747.   /*
  748. ***************
  749. *** 391,435 ****
  750.       struct ocode   *ip;
  751.   {
  752.       struct ocode   *prev, *next, *target;
  753.       long            label;
  754. !     prev = ip->back;
  755. !     if ((next = ip->fwd) == 0 || next->opcode != op_bra)
  756. !     return;
  757. !     /*
  758. !      * To make this fast, assume that the label number is really
  759. !      * next->oper1->offset->v.i
  760. !      */
  761. !     label = next->oper1->offset->v.i;
  762. !     if (label == ip->oper1->offset->v.i)
  763.       return;
  764. !     target = peep_head;
  765. !     /*
  766. !      * look for the label
  767. !      */
  768. !     while (target != 0) {
  769. !     if (target->opcode == op_label
  770. !         && target->oper1->offset->v.i == label)
  771. !         break;
  772. !     target = target->fwd;
  773. !     }
  774. !     /* we should have found it */
  775. !     if (target == 0) {
  776. !        message(MSG_PEEPLABEL);
  777. !        return;
  778. !     }
  779. !     /* move label */
  780. !     peep_delete(ip);
  781. !     ip->fwd = target->fwd;
  782. !     ip->back = target;
  783. !     target->fwd = ip;
  784. !     if (ip->fwd != 0)
  785. !     ip->fwd->back = ip;
  786. !     /* possibly remove branches */
  787. !     /* in fact, prev is always != 0 if peep_delete has succeeded */
  788. !     if (prev != 0) {
  789. !     if (prev->opcode == op_bra || prev->opcode == op_jmp
  790. !         || prev->opcode == op_ret)
  791. !         peep_uctran(prev);
  792.       }
  793.   }
  794.   
  795. --- 413,498 ----
  796.       struct ocode   *ip;
  797.   {
  798.       struct ocode   *prev, *next, *target;
  799. +     struct swtab   *sw;
  800. +     int            i;
  801.       long            label;
  802. ! 
  803. !     if ((next = ip->fwd) == 0)
  804.       return;
  805. ! 
  806. !     switch (next->opcode) {
  807. !       case op_label:
  808. !     /* if a label is followed by a label then common them up */
  809. !     label = next->oper1->offset->v.i;
  810. !     for (target = peep_head; target != 0; target = target->fwd) {
  811. !         if (branch(target) && target->oper1->offset->v.i == label)
  812. !         target->oper1->offset->v.i = ip->oper1->offset->v.i;
  813. !     }
  814. !     for (sw=swtables; sw != 0; sw = sw->next) {
  815. !         for (i=0; i < sw->numlabs; i++) {
  816. !         if (sw->labels[i] == label) {
  817. !             sw->labels[i] = ip->oper1->offset->v.i;
  818. !             changes++;
  819. !         }
  820. !         }
  821. !     }
  822. !     peep_delete(next);
  823. !     break;
  824. ! 
  825. !       case op_bra:
  826. !     prev = ip->back;
  827. !     /*
  828. !      * To make this fast, assume that the label number is really
  829. !      * next->oper1->offset->v.i
  830. !      */
  831. !     label = next->oper1->offset->v.i;
  832. !     if (label == ip->oper1->offset->v.i)
  833. !         return;
  834. !     target = peep_head;
  835. !     /*
  836. !      * look for the label
  837. !      */
  838. !     while (target != 0) {
  839. !         if (target->opcode == op_label
  840. !         && target->oper1->offset->v.i == label)
  841. !         break;
  842. !         target = target->fwd;
  843. !     }
  844. !     /* we should have found it */
  845. !     if (target == 0) {
  846. !        message(MSG_PEEPLABEL);
  847. !        return;
  848. !     }
  849. !     /* move label */
  850. !     peep_delete(ip);
  851. !     ip->fwd = target->fwd;
  852. !     ip->back = target;
  853. !     target->fwd = ip;
  854. !     if (ip->fwd != 0)
  855. !         ip->fwd->back = ip;
  856. !     /* possibly remove branches */
  857. !     /* in fact, prev is always != 0 if peep_delete has succeeded */
  858. !     if (prev != 0) {
  859. !         if (prev->opcode == op_bra || prev->opcode == op_jmp
  860. !         || prev->opcode == op_ret)
  861. !         peep_uctran(prev);
  862. !     }
  863. !     break;
  864. !       default:
  865. !     /* check that there are still references to this label */
  866. !     label = ip->oper1->offset->v.i;
  867. !     for (target = peep_head; target != 0; target = target->fwd) {
  868. !         if (branch(target) && target->oper1->offset->v.i == label)
  869. !         return;
  870. !     }
  871. !     for (sw=swtables; sw != 0; sw = sw->next) {
  872. !         for (i=0; i < sw->numlabs; i++) {
  873. !         if (sw->labels[i] == label)
  874. !             return;
  875. !         }
  876. !     }
  877. !     peep_delete(ip);
  878. !     break;
  879.       }
  880.   }
  881.   
  882. ***************
  883. *** 545,550 ****
  884. --- 608,615 ----
  885.   
  886.       p = ip->back;
  887.       previous_instruction(target);
  888. +     if (p==target)
  889. +     return;
  890.       /* now skip back over identical instruction sequences */
  891.       while (same_instruction(p,target)) {
  892.       p = p->back;
  893. *** src/peep68k.c.o    Mon Dec  7 13:15:21 1992
  894. --- src/peep68k.c    Mon Dec  7 13:15:27 1992
  895. ***************
  896. *** 153,158 ****
  897. --- 153,161 ----
  898.    */
  899.   {
  900.       register struct ocode *ip;
  901. +     struct swtab      *sw;
  902. +     struct enode      *ep;
  903. +     int               i;
  904.       opt3();            /* do the peephole optimizations */
  905.       ip = peep_head;
  906.       while (ip != 0) {
  907. ***************
  908. *** 163,168 ****
  909. --- 166,187 ----
  910.       ip = ip->fwd;
  911.       }
  912.       peep_head = 0;
  913. +     ep = mk_node(en_labcon, NIL_ENODE, NIL_ENODE);
  914. +     for(sw=swtables; sw; sw=sw->next) {
  915. +     nl();
  916. + #ifdef SEPERATE_I_D
  917. +     dseg();
  918. + #else
  919. +     cseg();
  920. + #endif
  921. +     put_align(AL_POINTER);
  922. +     put_label((unsigned) sw->tablab);
  923. +     for(i=0; i<sw->numlabs; i++) {
  924. +         ep->v.i = sw->labels[i];
  925. +         genptr(ep);
  926. +     }
  927. +     }
  928. +     swtables = NULL;
  929.   }
  930.   
  931.   static void
  932. ***************
  933. *** 716,721 ****
  934. --- 735,743 ----
  935.       }
  936.   }
  937.   
  938. + 
  939. + #define branch(ip)    (ip->opcode >= op_bra && ip->opcode <= op_bls)
  940. + 
  941.   static void
  942.   peep_label(ip)
  943.   /*
  944. ***************
  945. *** 725,769 ****
  946.       struct ocode   *ip;
  947.   {
  948.       struct ocode   *prev, *next, *target;
  949. !     long            label;
  950. !     prev = ip->back;
  951. !     if ((next = ip->fwd) == 0 || next->opcode != op_bra)
  952. !     return;
  953. !     /*
  954. !      * To make this fast, assume that the label number is really
  955. !      * next->oper1->offset->v.i
  956. !      */
  957. !     label = next->oper1->offset->v.i;
  958. !     if (label == ip->oper1->offset->v.i)
  959. !     return;
  960. !     target = peep_head;
  961. !     /*
  962. !      * look for the label
  963. !      */
  964. !     while (target != 0) {
  965. !     if (target->opcode == op_label
  966. !         && target->oper1->offset->v.i == label)
  967. !         break;
  968. !     target = target->fwd;
  969. !     }
  970. !     /* we should have found it */
  971. !     if (target == 0) {
  972. !        message(MSG_PEEPLABEL);
  973. !        return;
  974. !     }
  975. !     /* move label */
  976. !     peep_delete(ip);
  977. !     ip->fwd = target->fwd;
  978. !     ip->back = target;
  979. !     target->fwd = ip;
  980. !     if (ip->fwd != 0)
  981. !     ip->fwd->back = ip;
  982. !     /* possibly remove branches */
  983. !     /* in fact, prev is always != 0 if peep_delete has succeeded */
  984. !     if (prev != 0) {
  985. !     if (prev->opcode == op_bra || prev->opcode == op_jmp
  986. !         || prev->opcode == op_rts)
  987. !         peep_uctran(prev);
  988.       }
  989.   }
  990.   
  991. --- 747,836 ----
  992.       struct ocode   *ip;
  993.   {
  994.       struct ocode   *prev, *next, *target;
  995. !     struct swtab   *sw;
  996. !     int            i;
  997. !     long            label;
  998. ! 
  999. !     if ((next = ip->fwd) == 0)
  1000. !     return;
  1001. ! 
  1002. !     switch (next->opcode) {
  1003. !       case op_label:
  1004. !     /* if a label is followed by a label then common them up */
  1005. !     label = next->oper1->offset->v.i;
  1006. !     for (target = peep_head; target != 0; target = target->fwd) {
  1007. !         if (branch(target) && target->oper1->offset->v.i == label)
  1008. !         target->oper1->offset->v.i = ip->oper1->offset->v.i;
  1009. !         if (target->opcode == op_dbra && target->oper2->offset->v.i == label)
  1010. !         target->oper2->offset->v.i = ip->oper1->offset->v.i;
  1011. !     }
  1012. !     for (sw=swtables; sw != 0; sw = sw->next) {
  1013. !         for (i=0; i < sw->numlabs; i++) {
  1014. !         if (sw->labels[i] == label)
  1015. !             sw->labels[i] = ip->oper1->offset->v.i;
  1016. !         }
  1017. !     }
  1018. !     peep_delete(next);
  1019. !     break;
  1020. ! 
  1021. !       case op_bra:
  1022. !     prev = ip->back;
  1023. !     /*
  1024. !      * To make this fast, assume that the label number is really
  1025. !      * next->oper1->offset->v.i
  1026. !      */
  1027. !     label = next->oper1->offset->v.i;
  1028. !     if (label == ip->oper1->offset->v.i)
  1029. !         return;
  1030. !     target = peep_head;
  1031. !     /*
  1032. !      * look for the label
  1033. !      */
  1034. !     while (target != 0) {
  1035. !         if (target->opcode == op_label
  1036. !         && target->oper1->offset->v.i == label)
  1037. !         break;
  1038. !         target = target->fwd;
  1039. !     }
  1040. !     /* we should have found it */
  1041. !     if (target == 0) {
  1042. !        message(MSG_PEEPLABEL);
  1043. !        return;
  1044. !     }
  1045. !     /* move label */
  1046. !     if (target->fwd == ip)
  1047. !         return;
  1048. !     peep_delete(ip);
  1049. !     ip->fwd = target->fwd;
  1050. !     ip->back = target;
  1051. !     target->fwd = ip;
  1052. !     if (ip->fwd != 0)
  1053. !         ip->fwd->back = ip;
  1054. !     /* possibly remove branches */
  1055. !     /* in fact, prev is always != 0 if peep_delete has succeeded */
  1056. !     if (prev != 0) {
  1057. !         if (prev->opcode == op_bra || prev->opcode == op_jmp
  1058. !         || prev->opcode == op_rts)
  1059. !         peep_uctran(prev);
  1060. !     }
  1061. !     break;
  1062. !       default:
  1063. !     /* check that there are still references to this label */
  1064. !     label = ip->oper1->offset->v.i;
  1065. !     for (target = peep_head; target != 0; target = target->fwd) {
  1066. !         if (branch(target) && target->oper1->offset->v.i == label)
  1067. !         return;
  1068. !         if (target->opcode == op_dbra && target->oper2->offset->v.i == label)
  1069. !         return;
  1070. !     }
  1071. !     for (sw=swtables; sw != 0; sw = sw->next) {
  1072. !         for (i=0; i < sw->numlabs; i++) {
  1073. !         if (sw->labels[i] == label)
  1074. !             return;
  1075. !         }
  1076. !     }
  1077. !     peep_delete(ip);
  1078. !     break;
  1079.       }
  1080.   }
  1081.   
  1082. ***************
  1083. *** 891,896 ****
  1084. --- 958,965 ----
  1085.   
  1086.       p = ip->back;
  1087.       previous_instruction(target);
  1088. +     if (p==target)
  1089. +     return;
  1090.       /* now skip back over identical instruction sequences */
  1091.       while (same_instruction(p,target)) {
  1092.       p = p->back;
  1093. *** src/proto.h.o    Mon Dec  7 13:15:40 1992
  1094. --- src/proto.h    Thu Nov 26 22:02:30 1992
  1095. ***************
  1096. *** 16,22 ****
  1097.   /* decl.c */
  1098.   char *strsave P_((char *s));
  1099.   struct typ *mk_type P_((enum e_bt bt, long siz));
  1100. ! void decl P_((struct stab *table));
  1101.   void decl1 P_((void));
  1102.   void compile P_((void));
  1103.   void dodecl P_((enum e_sc defclass));
  1104. --- 16,22 ----
  1105.   /* decl.c */
  1106.   char *strsave P_((char *s));
  1107.   struct typ *mk_type P_((enum e_bt bt, long siz));
  1108. ! void decl P_((void));
  1109.   void decl1 P_((void));
  1110.   void compile P_((void));
  1111.   void dodecl P_((enum e_sc defclass));
  1112. ***************
  1113. *** 28,36 ****
  1114.   struct typ *exprnc P_((struct enode **node));
  1115.   struct typ *expression P_((struct enode **node));
  1116.   struct typ *cast_op P_((struct enode **ep, struct typ *tp1, struct typ *tp2, int flag));
  1117. ! long strip_icon P_((long i, enum e_bt type));
  1118. ! int castbegin P_((enum e_sym st));
  1119. ! struct typ *traceexpr P_((struct enode **node));
  1120.   /* func.c */
  1121.   void funcbody P_((struct sym *sp, char *names[], int nparms));
  1122.   /* gen68k.c */ /* gen68kd.c */ /* gen386.c */
  1123. --- 28,38 ----
  1124.   struct typ *exprnc P_((struct enode **node));
  1125.   struct typ *expression P_((struct enode **node));
  1126.   struct typ *cast_op P_((struct enode **ep, struct typ *tp1, struct typ *tp2, int flag));
  1127. ! #ifdef TRACE
  1128. ! void traceexpr    P_((struct enode  **node));
  1129. ! #endif /* TRACE */
  1130. ! long strip_icon P_((long i, enum e_bt type));
  1131. ! int castbegin P_((enum e_sym st));
  1132.   /* func.c */
  1133.   void funcbody P_((struct sym *sp, char *names[], int nparms));
  1134.   /* gen68k.c */ /* gen68kd.c */ /* gen386.c */
  1135. ***************
  1136. *** 85,90 ****
  1137. --- 87,93 ----
  1138.   #ifndef NOFLOAT
  1139.   double floatexpr P_((void));
  1140.   #endif
  1141. + long arithexpr P_((void));
  1142.   long intexpr P_((void));
  1143.   /* list.c */
  1144.   void list_table P_((struct stab *t, int i));
  1145. *** src/searchkw.c.o    Mon Dec  7 13:16:04 1992
  1146. --- src/searchkw.c    Mon Dec  7 13:16:06 1992
  1147. ***************
  1148. *** 32,115 ****
  1149.       enum e_sym      stype;
  1150.   }               keywords[] = {
  1151.   
  1152. !     {
  1153. !     "int", kw_int
  1154. !     }, {
  1155. !     "char", kw_char
  1156. !     }, {
  1157. !     "long", kw_long
  1158. !     },
  1159. !     {
  1160. !     "float", kw_float
  1161. !     }, {
  1162. !     "double", kw_double
  1163. !     }, {
  1164. !     "return", kw_return
  1165. !     },
  1166. !     {
  1167. !     "struct", kw_struct
  1168. !     }, {
  1169. !     "union", kw_union
  1170. !     }, {
  1171. !     "typedef", kw_typedef
  1172. !     },
  1173. !     {
  1174. !     "enum", kw_enum
  1175. !     }, {
  1176. !     "static", kw_static
  1177. !     }, {
  1178. !     "auto", kw_auto
  1179. !     },
  1180. !     {
  1181. !     "sizeof", kw_sizeof
  1182. !     }, {
  1183. !     "do", kw_do
  1184. !     }, {
  1185. !     "if", kw_if
  1186. !     },
  1187. !     {
  1188. !     "else", kw_else
  1189. !     }, {
  1190. !     "for", kw_for
  1191. !     }, {
  1192. !     "switch", kw_switch
  1193. !     },
  1194. !     {
  1195. !     "while", kw_while
  1196. !     }, {
  1197. !     "short", kw_short
  1198. !     }, {
  1199. !     "extern", kw_extern
  1200. !     },
  1201. !     {
  1202. !     "case", kw_case
  1203. !     }, {
  1204. !     "goto", kw_goto
  1205. !     }, {
  1206. !     "default", kw_default
  1207. !     },
  1208. !     {
  1209. !     "register", kw_register
  1210. !     }, {
  1211. !     "unsigned", kw_unsigned
  1212. !     },
  1213. !     {
  1214. !     "break", kw_break
  1215. !     }, {
  1216. !     "continue", kw_continue
  1217. !     }, {
  1218. !     "void", kw_void
  1219. !     },
  1220. !     {
  1221. !     "signed", kw_signed
  1222. !     }, {
  1223. !     "const", kw_const
  1224. !     }, {
  1225. !     "volatile", kw_volatile
  1226. !     },
  1227. !     {
  1228. !     0, 0
  1229. !     }
  1230.   };
  1231.   
  1232.   /*
  1233. --- 32,72 ----
  1234.       enum e_sym      stype;
  1235.   }               keywords[] = {
  1236.   
  1237. !     { "int", kw_int },
  1238. !     { "char", kw_char },
  1239. !     { "long", kw_long },
  1240. !     { "float", kw_float },
  1241. !     { "double", kw_double },
  1242. !     { "return", kw_return },
  1243. !     { "struct", kw_struct },
  1244. !     { "union", kw_union },
  1245. !     { "typedef", kw_typedef },
  1246. !     { "enum", kw_enum },
  1247. !     { "static", kw_static },
  1248. !     { "auto", kw_auto },
  1249. !     { "sizeof", kw_sizeof },
  1250. !     { "do", kw_do },
  1251. !     { "if", kw_if },
  1252. !     { "else", kw_else },
  1253. !     { "for", kw_for },
  1254. !     { "switch", kw_switch },
  1255. !         { "while", kw_while },
  1256. !     { "short", kw_short },
  1257. !     { "extern", kw_extern },
  1258. !         { "case", kw_case },
  1259. !     { "goto", kw_goto },
  1260. !     { "default", kw_default },
  1261. !         { "register", kw_register },
  1262. !     { "unsigned", kw_unsigned },
  1263. !         { "break", kw_break },
  1264. !     { "continue", kw_continue },
  1265. ! 
  1266. !     { "void", kw_void },
  1267. ! 
  1268. !         { "signed", kw_signed },
  1269. !     { "const", kw_const },
  1270. !     { "volatile", kw_volatile },
  1271. !     { 0, 0 }
  1272.   };
  1273.   
  1274.   /*
  1275. ***************
  1276. *** 136,146 ****
  1277.           switch ( (--kwbp)->stype ) {
  1278.           case kw_volatile:
  1279.               volatile_found = 1;
  1280.           case kw_signed:
  1281.           case kw_const:
  1282.               if (trad_option)
  1283.                   return;
  1284. !             /* else fall through */
  1285.           default:
  1286.               lastst = kwbp->stype;
  1287.               return;
  1288. --- 93,104 ----
  1289.           switch ( (--kwbp)->stype ) {
  1290.           case kw_volatile:
  1291.               volatile_found = 1;
  1292. +             /* FALLTHRU */
  1293.           case kw_signed:
  1294.           case kw_const:
  1295.               if (trad_option)
  1296.                   return;
  1297. !             /* FALLTHRU */
  1298.           default:
  1299.               lastst = kwbp->stype;
  1300.               return;
  1301. *** src/stmt.c.o    Mon Dec  7 13:16:15 1992
  1302. --- src/stmt.c    Mon Dec  7 13:16:18 1992
  1303. ***************
  1304. *** 301,308 ****
  1305.       if (snp->exp != 0) {
  1306.         if (ret_type->type == bt_void)
  1307.       message(ERR_VOIDFUNC);
  1308. !       else
  1309. !     (void) cast_op(&(snp->exp), tp, ret_type, 0);
  1310.       } else if (ret_type->type != bt_void)
  1311.         message(WARN_VALRETURN);
  1312.       return_found = 1;
  1313. --- 301,310 ----
  1314.       if (snp->exp != 0) {
  1315.         if (ret_type->type == bt_void)
  1316.       message(ERR_VOIDFUNC);
  1317. !       else if (tp->type == bt_void)
  1318. !     message(ERR_VOIDRETURN);
  1319. !       else
  1320. !     VOIDCAST cast_op(&(snp->exp), tp, ret_type, 0);
  1321.       } else if (ret_type->type != bt_void)
  1322.         message(WARN_VALRETURN);
  1323.       return_found = 1;
  1324. ***************
  1325. *** 390,396 ****
  1326.       sp->tp->val_flag) {
  1327.       message(ERR_ILLINIT);
  1328.       } else {
  1329. !     (void) cast_op(&ep2, tp, sp->tp, 0);
  1330.   
  1331.       ep1 = mk_node(en_autocon, NIL_ENODE, NIL_ENODE);
  1332.       ep1->v.i = sp->value.i;
  1333. --- 392,398 ----
  1334.       sp->tp->val_flag) {
  1335.       message(ERR_ILLINIT);
  1336.       } else {
  1337. !     VOIDCAST cast_op(&ep2, tp, sp->tp, 0);
  1338.   
  1339.       ep1 = mk_node(en_autocon, NIL_ENODE, NIL_ENODE);
  1340.       ep1->v.i = sp->value.i;
  1341. ***************
  1342. *** 583,596 ****
  1343.       return 0;
  1344.   }
  1345.   
  1346. ! static struct snode   *
  1347. ! statement()
  1348. ! /*
  1349. !  * statement figures out which of the statement processors should be called
  1350. !  * and transfers control to the proper routine.
  1351.    */
  1352.   {
  1353.       struct snode   *snp;
  1354.       switch (lastst) {
  1355.         case semicolon:
  1356.       getsym();
  1357. --- 585,620 ----
  1358.       return 0;
  1359.   }
  1360.   
  1361. ! #ifdef TRACE
  1362. ! static struct snode   *
  1363. ! tracestmt()
  1364. ! /*
  1365. !  * tracestmt adds calls to a run-time tracing/debugging routine.
  1366.    */
  1367.   {
  1368.       struct snode   *snp;
  1369. +     snp = (struct snode *) xalloc((int) sizeof(struct snode));
  1370. +     snp->stype = st_compound;
  1371. +     snp->s1 = (struct snode *) xalloc((int) sizeof(struct snode));
  1372. +     snp->s1->stype = st_expr;
  1373. +     traceexpr(&(snp->s1->exp));
  1374. +     return snp;
  1375. + }
  1376. + #endif /* TRACE */
  1377. + 
  1378. + static struct snode   *
  1379. + statement()
  1380. + /*
  1381. +  * statement figures out which of the statement processors should be called
  1382. +  * and transfers control to the proper routine.
  1383. +  */
  1384. + {
  1385. +     struct snode   *snp;
  1386. + #ifdef TRACE
  1387. +     struct snode   *tsnp;
  1388. +     if (trace_option)
  1389. +     tsnp = tracestmt();
  1390. + #endif
  1391.       switch (lastst) {
  1392.         case semicolon:
  1393.       getsym();
  1394. ***************
  1395. *** 644,648 ****
  1396.       }
  1397.       if (snp != 0)
  1398.       snp->next = 0;
  1399. !     return snp;
  1400. ! }
  1401. --- 668,678 ----
  1402.       }
  1403.       if (snp != 0)
  1404.       snp->next = 0;
  1405. ! #ifdef TRACE
  1406. !     if (trace_option) {
  1407. !     tsnp->s1->next = snp;
  1408. !     return tsnp;
  1409. !     } else
  1410. ! #endif /* TRACE */
  1411. !     return snp;
  1412. ! }
  1413. *** src/version.h.o    Mon Dec  7 13:16:36 1992
  1414. --- src/version.h    Mon Dec  7 13:13:47 1992
  1415. ***************
  1416. *** 1,3 ****
  1417. ! #define VERSION            "4.1"
  1418. ! #define LAST_CHANGE_DATE    "04 Oct 92"
  1419.   
  1420. --- 1,3 ----
  1421. ! #define VERSION            "4.2"
  1422. ! #define LAST_CHANGE_DATE    "05 Dec 92"
  1423.   
  1424.