开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
parse.c.2
资源名称：pascal2c.tar.Z　[点击查看]
上传用户：upcnvip
上传日期：2007-01-06
资源大小：474k
文件大小：48k
源码类别：

编译器/解释器

开发平台：

C/C++

parse.c.2：源码内容
  1.                         if (spnextreturn) {
  2.                             mp->refcount--;
  3.                             sp->next = sp->next->next;
  4.                         }
  5.                         result = 1;
  6.                     }
  7.                 }
  8.                 break;
  10.             case SK_RETURN:
  11.             case SK_GOTO:
  12.                 result = 1;
  13.                 break;
  15.             case SK_IF:
  16.                 result = checkreturns(&sp->stm1, spnearret) &    /* NOT && */
  17.                          checkreturns(&sp->stm2, spnearret);
  18.                 break;
  20.             case SK_TRY:
  21.                 (void) checkreturns(&sp->stm1, 0);
  22.                 (void) checkreturns(&sp->stm2, spnearret);
  23.                 break;
  25.             /* should handle CASE statements as well */
  27.             default:
  28.                 (void) checkreturns(&sp->stm1, 0);
  29.                 (void) checkreturns(&sp->stm2, 0);
  30.                 break;
  31.         }
  32.         spp = &sp->next;
  33.     }
  34.     return result;
  35. }
  43. /* Replace all occurrences of one expression with another expression */
  45. Expr *replaceexprexpr(ex, oldex, newex)
  46. Expr *ex, *oldex, *newex;
  47. {
  48.     int i;
  49.     Type *type;
  51.     for (i = 0; i < ex->nargs; i++)
  52.         ex->args[i] = replaceexprexpr(ex->args[i], oldex, newex);
  53.     if (exprsame(ex, oldex, 2)) {
  54.         if (ex->val.type->kind == TK_POINTER &&
  55.             ex->val.type->basetype == oldex->val.type) {
  56.             freeexpr(ex);
  57.             return makeexpr_addr(copyexpr(newex));
  58.         } else if (oldex->val.type->kind == TK_POINTER &&
  59.                    oldex->val.type->basetype == ex->val.type) {
  60.             freeexpr(ex);
  61.             return makeexpr_hat(copyexpr(newex), 0);
  62.         } else {
  63.     type = ex->val.type;
  64.             freeexpr(ex);
  65.             ex = copyexpr(newex);
  66.     ex->val.type = type;
  67.     return ex;
  68.         }
  69.     }
  70.     return resimplify(ex);
  71. }
  74. void replaceexpr(sp, oldex, newex)
  75. Stmt *sp;
  76. Expr *oldex, *newex;
  77. {
  78.     while (sp) {
  79.         replaceexpr(sp->stm1, oldex, newex);
  80.         replaceexpr(sp->stm2, oldex, newex);
  81.         if (sp->exp1)
  82.             sp->exp1 = replaceexprexpr(sp->exp1, oldex, newex);
  83.         if (sp->exp2)
  84.             sp->exp2 = replaceexprexpr(sp->exp2, oldex, newex);
  85.         if (sp->exp3)
  86.             sp->exp3 = replaceexprexpr(sp->exp3, oldex, newex);
  87.         sp = sp->next;
  88.     }
  89. }
  96. Stmt *mixassignments(sp, mp)
  97. Stmt *sp;
  98. Meaning *mp;
  99. {
  100.     if (!sp)
  101.         return NULL;
  102.     sp->next = mixassignments(sp->next, mp);
  103.     if (sp->next &&
  104.  sp->kind == SK_ASSIGN &&
  105.          sp->exp1->kind == EK_ASSIGN &&
  106.          sp->exp1->args[0]->kind == EK_VAR &&
  107.          (!mp || mp == (Meaning *)sp->exp1->args[0]->val.i) &&
  108.          ord_type(sp->exp1->args[0]->val.type)->kind == TK_INTEGER &&
  109.          nodependencies(sp->exp1->args[1], 0) &&
  110.          sp->next->kind == SK_ASSIGN &&
  111.          sp->next->exp1->kind == EK_ASSIGN &&
  112.          (exprsame(sp->exp1->args[0], sp->next->exp1->args[0], 1) ||
  113.           (mp && mp->istemporary)) &&
  114.          exproccurs(sp->next->exp1->args[1], sp->exp1->args[0]) == 1) {
  115.         sp->next->exp1->args[1] = replaceexprexpr(sp->next->exp1->args[1],
  116.                                                   sp->exp1->args[0],
  117.                                                   sp->exp1->args[1]);
  118.         if (mp && mp->istemporary)
  119.             canceltempvar(mp);
  120.         return sp->next;
  121.     }
  122.     return sp;
  123. }
  132. /* Do various simple (sometimes necessary) massages on the statements */
  135. Static Stmt bogusreturn = { SK_RETURN, NULL, NULL, NULL, NULL, NULL, NULL };
  139. Static int isescape(ex)
  140. Expr *ex;
  141. {
  142.     if (ex->kind == EK_BICALL && (!strcmp(ex->val.s, name_ESCAPE) ||
  143.                                   !strcmp(ex->val.s, name_ESCIO) ||
  144.   !strcmp(ex->val.s, name_OUTMEM) ||
  145.   !strcmp(ex->val.s, name_CASECHECK) ||
  146.   !strcmp(ex->val.s, name_NILCHECK) ||
  147.                                   !strcmp(ex->val.s, "_exit") ||
  148.                                   !strcmp(ex->val.s, "exit")))
  149.         return 1;
  150.     if (ex->kind == EK_CAST)
  151.         return isescape(ex->args[0]);
  152.     return 0;
  153. }
  156. /* check if a block can never exit by falling off the end */
  157. Static int deadendblock(sp)
  158. Stmt *sp;
  159. {
  160.     if (!sp)
  161.         return 0;
  162.     while (sp->next)
  163.         sp = sp->next;
  164.     return (sp->kind == SK_GOTO ||
  165.             sp->kind == SK_BREAK ||
  166.             sp->kind == SK_CONTINUE ||
  167.             sp->kind == SK_RETURN ||
  168.             sp->kind == SK_CASECHECK ||
  169.             (sp->kind == SK_IF && deadendblock(sp->stm1) &&
  170.                                   deadendblock(sp->stm2)) ||
  171.             (sp->kind == SK_ASSIGN && isescape(sp->exp1)));
  172. }
  177. int expr_is_bool(ex, want)
  178. Expr *ex;
  179. int want;
  180. {
  181.     long val;
  183.     if (ex->val.type == tp_boolean && isconstexpr(ex, &val))
  184.         return (val == want);
  185.     return 0;
  186. }
  191. /* Returns 1 if c1 implies c2, 0 otherwise */
  192. /* If not1 is true, then checks if (!c1) implies c2; similarly for not2 */
  194. /* Identities used:
  195.         c1 -> (c2a && c2b)      <=>     (c1 -> c2a) && (c1 -> c2b)
  196.         c1 -> (c2a || c2b)      <=>     (c1 -> c2a) || (c1 -> c2b)
  197.         (c1a && c1b) -> c2      <=>     (c1a -> c2) || (c1b -> c2)
  198.         (c1a || c1b) -> c2      <=>     (c1a -> c2) && (c1b -> c2)
  199.         (!c1) -> (!c2)          <=>     c2 -> c1
  200.         (a == b) -> c2(b)       <=>     c2(a)
  201.         !(c1 && c2)             <=>     (!c1) || (!c2)
  202.         !(c1 || c2)             <=>     (!c1) && (!c2)
  203. */
  204. /* This could be smarter about, e.g., (a>5) -> (a>0) */
  206. int implies(c1, c2, not1, not2)
  207. Expr *c1, *c2;
  208. int not1, not2;
  209. {
  210.     Expr *ex;
  211.     int i;
  213.     if (c1->kind == EK_EQ && c1->args[0]->val.type == tp_boolean) {
  214.         if (checkconst(c1->args[0], 1)) {     /* things like "flag = true" */
  215.             return implies(c1->args[1], c2, not1, not2);
  216.         } else if (checkconst(c1->args[1], 1)) {
  217.             return implies(c1->args[0], c2, not1, not2);
  218.         } else if (checkconst(c1->args[0], 0)) {
  219.             return implies(c1->args[1], c2, !not1, not2);
  220.         } else if (checkconst(c1->args[1], 0)) {
  221.             return implies(c1->args[0], c2, !not1, not2);
  222.         }
  223.     }
  224.     if (c2->kind == EK_EQ && c2->args[0]->val.type == tp_boolean) {
  225.         if (checkconst(c2->args[0], 1)) {
  226.             return implies(c1, c2->args[1], not1, not2);
  227.         } else if (checkconst(c2->args[1], 1)) {
  228.             return implies(c1, c2->args[0], not1, not2);
  229.         } else if (checkconst(c2->args[0], 0)) {
  230.             return implies(c1, c2->args[1], not1, !not2);
  231.         } else if (checkconst(c2->args[1], 0)) {
  232.             return implies(c1, c2->args[0], not1, !not2);
  233.         }
  234.     }
  235.     switch (c2->kind) {
  237.         case EK_AND:
  238.             if (not2)               /* c1 -> (!c2a || !c2b) */
  239.                 return (implies(c1, c2->args[0], not1, 1) ||
  240.                         implies(c1, c2->args[1], not1, 1));
  241.             else                    /* c1 -> (c2a && c2b) */
  242.                 return (implies(c1, c2->args[0], not1, 0) &&
  243.                         implies(c1, c2->args[1], not1, 0));
  245.         case EK_OR:
  246.             if (not2)               /* c1 -> (!c2a && !c2b) */
  247.                 return (implies(c1, c2->args[0], not1, 1) &&
  248.                         implies(c1, c2->args[1], not1, 1));
  249.             else                    /* c1 -> (c2a || c2b) */
  250.                 return (implies(c1, c2->args[0], not1, 0) ||
  251.                         implies(c1, c2->args[1], not1, 0));
  253.         case EK_NOT:                /* c1 -> (!c2) */
  254.             return (implies(c1, c2->args[0], not1, !not2));
  256.         case EK_CONST:
  257.             if ((c2->val.i != 0) != not2)  /* c1 -> true */
  258.                 return 1;
  259.             break;
  261. default:
  262.     break;
  263.     }
  264.     switch (c1->kind) {
  266.         case EK_AND:
  267.             if (not1)               /* (!c1a || !c1b) -> c2 */
  268.                 return (implies(c1->args[0], c2, 1, not2) &&
  269.                         implies(c1->args[1], c2, 1, not2));
  270.             else                    /* (c1a && c1b) -> c2 */
  271.                 return (implies(c1->args[0], c2, 0, not2) ||
  272.                         implies(c1->args[1], c2, 0, not2));
  274.         case EK_OR:
  275.             if (not1)               /* (!c1a && !c1b) -> c2 */
  276.                 return (implies(c1->args[0], c2, 1, not2) ||
  277.                         implies(c1->args[1], c2, 1, not2));
  278.             else                    /* (c1a || c1b) -> c2 */
  279.                 return (implies(c1->args[0], c2, 0, not2) &&
  280.                         implies(c1->args[1], c2, 0, not2));
  282.         case EK_NOT:                /* (!c1) -> c2 */
  283.             return (implies(c1->args[0], c2, !not1, not2));
  285.         case EK_CONST:
  286.             if ((c1->val.i != 0) == not1)  /*  false -> c2 */
  287.                 return 1;
  288.             break;
  290.         case EK_EQ:                 /* (a=b) -> c2 */
  291.         case EK_ASSIGN:             /* (a:=b) -> c2 */
  292.         case EK_NE:                 /* (a<>b) -> c2 */
  293.             if ((c1->kind == EK_NE) == not1) {
  294.                 if (c1->args[0]->kind == EK_VAR) {
  295.                     ex = replaceexprexpr(copyexpr(c2), c1->args[0], c1->args[1]);
  296.                     i = expr_is_bool(ex, !not2);
  297.                     freeexpr(ex);
  298.                     if (i)
  299.                         return 1;
  300.                 }
  301.                 if (c1->args[1]->kind == EK_VAR) {
  302.                     ex = replaceexprexpr(copyexpr(c2), c1->args[1], c1->args[0]);
  303.                     i = expr_is_bool(ex, !not2);
  304.                     freeexpr(ex);
  305.                     if (i)
  306.                         return 1;
  307.                 }
  308.             }
  309.             break;
  311. default:
  312.     break;
  313.     }
  314.     if (not1 == not2 && exprequiv(c1, c2)) {    /* c1 -> c1 */
  315.         return 1;
  316.     }
  317.     return 0;
  318. }
  324. void infiniteloop(sp)
  325. Stmt *sp;
  326. {
  327.     switch (infloopstyle) {
  329.         case 1:      /* write "for (;;) ..." */
  330.             sp->kind = SK_FOR;
  331.             freeexpr(sp->exp1);
  332.             sp->exp1 = NULL;
  333.             break;
  335.         case 2:      /* write "while (1) ..." */
  336.             sp->kind = SK_WHILE;
  337.             freeexpr(sp->exp1);
  338.             sp->exp1 = makeexpr_val(make_ord(tp_boolean, 1));
  339.             break;
  341.         case 3:      /* write "do ... while (1)" */
  342.             sp->kind = SK_REPEAT;
  343.             freeexpr(sp->exp1);
  344.             sp->exp1 = makeexpr_val(make_ord(tp_boolean, 1));
  345.             break;
  347.         default:     /* leave it alone */
  348.             break;
  350.     }
  351. }
  357. Expr *print_func(ex)
  358. Expr *ex;
  359. {
  360.     if (!ex || ex->kind != EK_BICALL)
  361. return NULL;
  362.     if ((!strcmp(ex->val.s, "printf") &&
  363.  ex->args[0]->kind == EK_CONST) ||
  364. !strcmp(ex->val.s, "putchar") ||
  365. !strcmp(ex->val.s, "puts"))
  366. return ex_output;
  367.     if ((!strcmp(ex->val.s, "fprintf") ||
  368.  !strcmp(ex->val.s, "sprintf")) &&
  369. ex->args[1]->kind == EK_CONST)
  370. return ex->args[0];
  371.     if (!strcmp(ex->val.s, "putc") ||
  372. !strcmp(ex->val.s, "fputc") ||
  373. !strcmp(ex->val.s, "fputs"))
  374. return ex->args[1];
  375.     return NULL;
  376. }
  380. int printnl_func(ex)
  381. Expr *ex;
  382. {
  383.     char *cp, ch;
  384.     int i, len;
  386.     if (debug>2) { fprintf(outf,"printnl_func("); dumpexpr(ex); fprintf(outf, ")n"); }
  387.     if (!strcmp(ex->val.s, "printf") ||
  388. !strcmp(ex->val.s, "puts") ||
  389. !strcmp(ex->val.s, "fputs")) {
  390. if (ex->args[0]->kind != EK_CONST)
  391.     return 0;
  392. cp = ex->args[0]->val.s;
  393. len = ex->args[0]->val.i;
  394.     } else if (!strcmp(ex->val.s, "fprintf")) {
  395. if (ex->args[1]->kind != EK_CONST)
  396.     return 0;
  397. cp = ex->args[1]->val.s;
  398. len = ex->args[1]->val.i;
  399.     } else if (!strcmp(ex->val.s, "putchar") ||
  400.        !strcmp(ex->val.s, "putc") ||
  401.        !strcmp(ex->val.s, "fputc")) {
  402. if (ex->args[0]->kind != EK_CONST)
  403.     return 0;
  404. ch = ex->args[0]->val.i;
  405. cp = &ch;
  406. len = 1;
  407.     } else
  408. return 0;
  409.     for (i = 1; i <= len; i++)
  410. if (*cp++ != 'n')
  411.     return 0;
  412.     return len + (!strcmp(ex->val.s, "puts"));
  413. }
  417. Expr *chg_printf(ex)
  418. Expr *ex;
  419. {
  420.     Expr *fex;
  422.     if (debug>2) { fprintf(outf,"chg_printf("); dumpexpr(ex); fprintf(outf, ")n"); }
  423.     if (!strcmp(ex->val.s, "putchar")) {
  424. ex = makeexpr_sprintfify(grabarg(ex, 0));
  425. canceltempvar(istempvar(ex->args[0]));
  426. strchange(&ex->val.s, "printf");
  427. delfreearg(&ex, 0);
  428. ex->val.type = tp_void;
  429.     } else if (!strcmp(ex->val.s, "putc") ||
  430.        !strcmp(ex->val.s, "fputc") ||
  431.        !strcmp(ex->val.s, "fputs")) {
  432. fex = copyexpr(ex->args[1]);
  433. ex = makeexpr_sprintfify(grabarg(ex, 0));
  434. canceltempvar(istempvar(ex->args[0]));
  435. strchange(&ex->val.s, "fprintf");
  436. ex->args[0] = fex;
  437. ex->val.type = tp_void;
  438.     } else if (!strcmp(ex->val.s, "puts")) {
  439. ex = makeexpr_concat(makeexpr_sprintfify(grabarg(ex, 0)),
  440.      makeexpr_string("n"), 1);
  441. strchange(&ex->val.s, "printf");
  442. delfreearg(&ex, 0);
  443. ex->val.type = tp_void;
  444.     }
  445.     if (!strcmp(ex->val.s, "fprintf") && exprsame(ex->args[0], ex_output, 1)) {
  446. delfreearg(&ex, 0);
  447. strchange(&ex->val.s, "printf");
  448.     }
  449.     return ex;
  450. }
  453. Expr *mix_printf(ex, ex2)
  454. Expr *ex, *ex2;
  455. {
  456.     int i;
  458.     ex = chg_printf(ex);
  459.     if (debug>2) { fprintf(outf,"chg_printf returns "); dumpexpr(ex); fprintf(outf, "n"); }
  460.     ex2 = chg_printf(copyexpr(ex2));
  461.     if (debug>2) { fprintf(outf,"chg_printf returns "); dumpexpr(ex2);fprintf(outf, "n"); }
  462.     i = (!strcmp(ex->val.s, "printf")) ? 0 : 1;
  463.     ex->args[i] = makeexpr_concat(ex->args[i], ex2->args[i], 0);
  464.     for (i++; i < ex2->nargs; i++) {
  465. insertarg(&ex, ex->nargs, ex2->args[i]);
  466.     }
  467.     return ex;
  468. }
  475. void eatstmt(spp)
  476. Stmt **spp;
  477. {
  478.     Stmt *sp = *spp;
  480.     if (debug>2) { fprintf(outf, "eatstmt on:n"); dumpstmt(sp, 5); }
  481.     *spp = sp->next;
  482.     sp->next = NULL;
  483.     free_stmt(sp);
  484. }
  488. int haslabels(sp)
  489. Stmt *sp;
  490. {
  491.     if (!sp)
  492.         return 0;
  493.     if (haslabels(sp->stm1) || haslabels(sp->stm2))
  494.         return 1;
  495.     return (sp->kind == SK_LABEL);
  496. }
  500. void fixblock(spp, thereturn)
  501. Stmt **spp, *thereturn;
  502. {
  503.     Stmt *sp, *sp1, *sp2, *sp3, **spp2, *thisreturn;
  504.     Expr *ex;
  505.     Meaning *tvar, *mp;
  506.     int save_tryblock;
  507.     short save_tryflag;
  508.     int i, j, de1, de2;
  509.     long saveserial = curserial;
  511.     while ((sp = *spp)) {
  512.         sp2 = sp->next;
  513.         sp->next = NULL;
  514.         sp = fix_statement(*spp);
  515.         if (!sp) {
  516.             *spp = sp2;
  517.             continue;
  518.         }
  519.         *spp = sp;
  520.         for (sp3 = sp; sp3->next; sp3 = sp3->next) ;
  521.         sp3->next = sp2;
  522.         if (!sp->next)
  523.             thisreturn = thereturn;
  524.         else if (sp->next->kind == SK_RETURN ||
  525.                  (sp->next->kind == SK_ASSIGN &&
  526.                   isescape(sp->next->exp1)))
  527.             thisreturn = sp->next;
  528.         else
  529.             thisreturn = NULL;
  530. if (sp->serial >= 0)
  531.     curserial = sp->serial;
  532.         switch (sp->kind) {
  534.             case SK_ASSIGN:
  535.         if (sp->exp1)
  536.     sp->exp1 = fixexpr(sp->exp1, ENV_STMT);
  537. if (!sp->exp1)
  538.     intwarning("fixblock", "sp->exp1 == NULL in SK_ASSIGN");
  539.                 if (!sp->exp1 || nosideeffects(sp->exp1, 1)) {
  540.     eatstmt(spp);
  541.     continue;
  542.                 } else {
  543.                     switch (sp->exp1->kind) {
  545.                         case EK_COND:
  546.                             *spp = makestmt_if(sp->exp1->args[0],
  547.                                                makestmt_call(sp->exp1->args[1]),
  548.                                                makestmt_call(sp->exp1->args[2]));
  549.                             (*spp)->next = sp->next;
  550.                             continue;    /* ... to fix this new if statement */
  552.                         case EK_ASSIGN:
  553.                             if (sp->exp1->args[1]->kind == EK_COND && usecommas != 1) {
  554.                                 *spp = makestmt_if(sp->exp1->args[1]->args[0],
  555.                                                    makestmt_assign(copyexpr(sp->exp1->args[0]),
  556.                                                                    sp->exp1->args[1]->args[1]),
  557.                                                    makestmt_assign(sp->exp1->args[0],
  558.                                                                    sp->exp1->args[1]->args[2]));
  559.                                 (*spp)->next = sp->next;
  560.                                 continue;
  561.                             }
  562.     if (isescape(sp->exp1->args[1])) {
  563.                                 sp->exp1 = grabarg(sp->exp1, 1);
  564. continue;
  565.                             }
  566.     if (exprsame(sp->exp1->args[0], sp->exp1->args[1], 1)) {
  567.                               /*  *spp = sp->next;  */
  568.                                 sp->exp1 = grabarg(sp->exp1, 0);
  569.                                 continue;
  570.                             }
  571.     if (sp->exp1->args[1]->kind == EK_BICALL) {
  572. if (!strcmp(sp->exp1->args[1]->val.s,
  573.     getfbufname) &&
  574.     buildreads == 1 &&
  575.     sp->next &&
  576.     sp->next->kind == SK_ASSIGN &&
  577.     sp->next->exp1->kind == EK_BICALL &&
  578.     !strcmp(sp->next->exp1->val.s,
  579.     getname) &&
  580.     expr_has_address(sp->exp1->args[0]) &&
  581.     similartypes(sp->exp1->args[0]->val.type,
  582.  sp->exp1->args[1]->args[0]->val.type->basetype->basetype) &&
  583.     exprsame(sp->exp1->args[1]->args[0],
  584.      sp->next->exp1->args[0], 1)) {
  585.     eatstmt(&sp->next);
  586.     ex = makeexpr_bicall_4("fread", tp_integer,
  587.    makeexpr_addr(sp->exp1->args[0]),
  588.    makeexpr_sizeof(sp->exp1->args[1]->args[1], 0),
  589.    makeexpr_long(1),
  590.    sp->exp1->args[1]->args[0]);
  591.     FREE(sp->exp1);
  592.     sp->exp1 = ex;
  593.     continue;
  594. }
  595. if (!strcmp(sp->exp1->args[1]->val.s,
  596.     chargetfbufname) &&
  597.     buildreads != 0 &&
  598.     sp->next &&
  599.     sp->next->kind == SK_ASSIGN &&
  600.     sp->next->exp1->kind == EK_BICALL &&
  601.     !strcmp(sp->next->exp1->val.s,
  602.     chargetname) &&
  603.     expr_has_address(sp->exp1->args[0]) &&
  604.     exprsame(sp->exp1->args[1]->args[0],
  605.      sp->next->exp1->args[0], 1)) {
  606.     eatstmt(&sp->next);
  607.     strchange(&sp->exp1->args[1]->val.s,
  608.       "getc");
  609.     continue;
  610. }
  611.     }
  612.                             break;
  614.                         case EK_BICALL:
  615.                             if (!strcmp(sp->exp1->val.s, name_ESCAPE)) {
  616.                                 if (fixexpr_tryblock) {
  617.                                     *spp = makestmt_assign(makeexpr_var(mp_escapecode),
  618.                                                            grabarg(sp->exp1, 0));
  619.                                     (*spp)->next = makestmt(SK_GOTO);
  620.                                     (*spp)->next->exp1 = makeexpr_name(format_s(name_LABEL,
  621.                                                                                 format_d("try%d",
  622.                                                                                          fixexpr_tryblock)),
  623.                                                                        tp_integer);
  624.                                     (*spp)->next->next = sp->next;
  625.                                     fixexpr_tryflag = 1;
  626.                                     continue;
  627.                                 }
  628.                             } else if (!strcmp(sp->exp1->val.s, name_ESCIO)) {
  629.                                 if (fixexpr_tryblock) {
  630.                                     *spp = makestmt_assign(makeexpr_var(mp_escapecode),
  631.                                                            makeexpr_long(-10));
  632.                                     (*spp)->next = makestmt_assign(makeexpr_var(mp_ioresult),
  633.                                                                    grabarg(sp->exp1, 0));
  634.                                     (*spp)->next->next = makestmt(SK_GOTO);
  635.                                     (*spp)->next->next->exp1 = makeexpr_name(format_s(name_LABEL,
  636.                                                                                       format_d("try%d",
  637.                                                                                                fixexpr_tryblock)),
  638.                                                                              tp_integer);
  639.                                     (*spp)->next->next->next = sp->next;
  640.                                     fixexpr_tryflag = 1;
  641.                                     continue;
  642.                                 }
  643.                             }
  644.     if (!strcmp(sp->exp1->val.s, putfbufname) &&
  645. buildwrites == 1 &&
  646. sp->next &&
  647. sp->next->kind == SK_ASSIGN &&
  648. sp->next->exp1->kind == EK_BICALL &&
  649. !strcmp(sp->next->exp1->val.s,
  650. putname) &&
  651. exprsame(sp->exp1->args[0],
  652.  sp->next->exp1->args[0], 1)) {
  653. eatstmt(&sp->next);
  654. if (!expr_has_address(sp->exp1->args[2]) ||
  655.     sp->exp1->args[2]->val.type !=
  656.         sp->exp1->args[1]->val.type) {
  657.     tvar = maketempvar(sp->exp1->args[1]->val.type,
  658.    name_TEMP);
  659.     sp2 = makestmt_assign(makeexpr_var(tvar),
  660.   sp->exp1->args[2]);
  661.     sp2->next = sp;
  662.     *spp = sp2;
  663.     sp->exp1->args[2] = makeexpr_var(tvar);
  664.     freetempvar(tvar);
  665. }
  666. ex = makeexpr_bicall_4("fwrite", tp_integer,
  667.        makeexpr_addr(sp->exp1->args[2]),
  668.        makeexpr_sizeof(sp->exp1->args[1], 0),
  669.        makeexpr_long(1),
  670.        sp->exp1->args[0]);
  671. FREE(sp->exp1);
  672. sp->exp1 = ex;
  673. continue;
  674.     }
  675.     if (!strcmp(sp->exp1->val.s, charputfbufname) &&
  676. buildwrites != 0 &&
  677. sp->next &&
  678. sp->next->kind == SK_ASSIGN &&
  679. sp->next->exp1->kind == EK_BICALL &&
  680. !strcmp(sp->next->exp1->val.s,
  681. charputname) &&
  682. exprsame(sp->exp1->args[0],
  683.  sp->next->exp1->args[0], 1)) {
  684. eatstmt(&sp->next);
  685. swapexprs(sp->exp1->args[0],
  686.   sp->exp1->args[1]);
  687. strchange(&sp->exp1->val.s, "putc");
  688. continue;
  689.     }
  690.     if ((!strcmp(sp->exp1->val.s, resetbufname) ||
  691.  !strcmp(sp->exp1->val.s, setupbufname)) &&
  692. (mp = isfilevar(sp->exp1->args[0])) != NULL &&
  693. !mp->bufferedfile) {
  694. eatstmt(spp);
  695. continue;
  696.     }
  697.     ex = print_func(sp->exp1);
  698.     if (ex && sp->next && mixwritelns &&
  699. sp->next->kind == SK_ASSIGN &&
  700. exprsame(ex, print_func(sp->next->exp1), 1) &&
  701. (printnl_func(sp->exp1) ||
  702.  printnl_func(sp->next->exp1))) {
  703. sp->exp1 = mix_printf(sp->exp1,
  704.       sp->next->exp1);
  705. eatstmt(&sp->next);
  706. continue;
  707.     }
  708.                             break;
  710.                         case EK_FUNCTION:
  711.                         case EK_SPCALL:
  712.                         case EK_POSTINC:
  713.                         case EK_POSTDEC:
  714.                         case EK_AND:
  715.                         case EK_OR:
  716.                             break;
  718.                         default:
  719.                             spp2 = spp;
  720.                             for (i = 0; i < sp->exp1->nargs; i++) {
  721.                                 *spp2 = makestmt_call(sp->exp1->args[i]);
  722.                                 spp2 = &(*spp2)->next;
  723.                             }
  724.                             *spp2 = sp->next;
  725.                             continue;    /* ... to fix these new statements */
  727.                     }
  728.                 }
  729.                 break;
  731.             case SK_IF:
  732.                 fixblock(&sp->stm1, thisreturn);
  733.                 fixblock(&sp->stm2, thisreturn);
  734.                 if (!sp->stm1) {
  735.                     if (!sp->stm2) {
  736.                         sp->kind = SK_ASSIGN;
  737.                         continue;
  738.                     } else {
  739. if (sp->stm2->kind == SK_IF && sp->stm2->exp2) {
  740.     freeexpr(sp->stm2->exp2);
  741.     sp->stm2->exp2 = NULL;
  742. }
  743.                         sp->exp1 = makeexpr_not(sp->exp1);   /* if (x) else foo  =>  if (!x) foo */
  744.                         swapstmts(sp->stm1, sp->stm2);
  745. /* Ought to exchange comments for then/else parts */
  746.                     }
  747.                 }
  748. /* At this point we know sp1 != NULL */
  749.                 if (thisreturn) {
  750.                     if (thisreturn->kind == SK_WHILE) {
  751.                         if (usebreaks) {
  752.                             sp1 = sp->stm1;
  753.                             while (sp1->next)
  754.                                 sp1 = sp1->next;
  755.                             if (sp->stm2) {
  756. sp2 = sp->stm2;
  757. while (sp2->next)
  758.     sp2 = sp2->next;
  759.                                 i = stmtcount(sp->stm1);
  760.                                 j = stmtcount(sp->stm2);
  761.                                 if (j >= breaklimit && i <= 2 && j > i*2 &&
  762.                                     ((implies(sp->exp1, thisreturn->exp1, 0, 1) &&
  763.       !checkexprchanged(sp->stm1, sp->exp1)) ||
  764.      (sp1->kind == SK_ASSIGN &&
  765.       implies(sp1->exp1, thisreturn->exp1, 0, 1)))) {
  766.                                     sp1->next = makestmt(SK_BREAK);
  767.                                 } else if (i >= breaklimit && j <= 2 && i > j*2 &&
  768.                                            ((implies(sp->exp1, thisreturn->exp1, 1, 1) &&
  769.      !checkexprchanged(sp->stm2, sp->exp1)) ||
  770.     (sp2->kind == SK_ASSIGN &&
  771.      implies(sp2->exp1, thisreturn->exp1, 0, 1)))) {
  772.                                     sp2->next = makestmt(SK_BREAK);
  773. } else if (!checkconst(sp->exp2, 1)) {
  774.     /* not part of an else-if */
  775.     if (j >= continuelimit) {
  776. sp1->next = makestmt(SK_CONTINUE);
  777.     } else if (i >= continuelimit) {
  778. sp2->next = makestmt(SK_CONTINUE);
  779.     }
  780. }
  781.     } else {
  782.                                 i = stmtcount(sp->stm1);
  783.                                 if (i >= breaklimit &&
  784.                                     implies(sp->exp1, thisreturn->exp1, 1, 1)) {
  785.                                     sp->exp1 = makeexpr_not(sp->exp1);
  786.                                     sp1->next = sp->next;
  787.                                     sp->next = sp->stm1;
  788.                                     sp->stm1 = makestmt(SK_BREAK);
  789.                                 } else if (i >= continuelimit) {
  790.                                     sp->exp1 = makeexpr_not(sp->exp1);
  791.                                     sp1->next = sp->next;
  792.                                     sp->next = sp->stm1;
  793.                                     sp->stm1 = makestmt(SK_CONTINUE);
  794.                                 }
  795.                             }
  796.                         }
  797.                     } else {
  798.                         if (usereturns) {
  799.                             sp2 = sp->stm1;
  800.                             while (sp2->next)
  801.                                 sp2 = sp2->next;
  802.                             if (sp->stm2) {
  803.                                 /* if (x) foo; else bar; (return;)  =>  if (x) {foo; return;} bar; */
  804.                                 if (stmtcount(sp->stm2) >= returnlimit) {
  805.     if (!deadendblock(sp->stm1))
  806. sp2->next = copystmt(thisreturn);
  807.                                 } else if (stmtcount(sp->stm1) >= returnlimit) {
  808.                                     sp2 = sp->stm2;
  809.                                     while (sp2->next)
  810.                                         sp2 = sp2->next;
  811.     if (!deadendblock(sp->stm2))
  812. sp2->next = copystmt(thisreturn);
  813.                                 }
  814.                             } else {      /* if (x) foo; (return;)  =>  if (!x) return; foo; */
  815.                                 if (stmtcount(sp->stm1) >= returnlimit) {
  816.                                     sp->exp1 = makeexpr_not(sp->exp1);
  817.                                     sp2->next = sp->next;
  818.                                     sp->next = sp->stm1;
  819.                                     sp->stm1 = copystmt(thisreturn);
  820.                                 }
  821.                             }
  822.                         }
  823.                     }
  824.                 }
  825.                 if (!checkconst(sp->exp2, 1)) {    /* not part of an else-if */
  826.                     de1 = deadendblock(sp->stm1);
  827.                     de2 = deadendblock(sp->stm2);
  828.                     if (de2 && !de1) {
  829.                         sp->exp1 = makeexpr_not(sp->exp1);
  830.                         swapstmts(sp->stm1, sp->stm2);
  831.                         de1 = 1, de2 = 0;
  832.                     }
  833.                     if (de1 && !de2 && sp->stm2) {
  834. if (sp->stm2->kind == SK_IF && sp->stm2->exp2) {
  835.     freeexpr(sp->stm2->exp2);
  836.     sp->stm2->exp2 = NULL;
  837. }
  838.                         for (sp2 = sp->stm2; sp2->next; sp2 = sp2->next) ;
  839.                         sp2->next = sp->next;
  840.                         sp->next = sp->stm2;      /* if (x) ESCAPE else foo  =>  if (x) ESCAPE; foo */
  841.                         sp->stm2 = NULL;
  842.                     }
  843.                 }
  844.                 sp->exp1 = fixexpr(sp->exp1, ENV_BOOL);
  845.                 break;
  847.             case SK_WHILE:
  848.                 if (whilefgets &&    /* handle "while eof(f) do readln(f,...)" */
  849.     sp->stm1->kind == SK_ASSIGN &&
  850.     sp->stm1->exp1->kind == EK_BICALL &&
  851.     !strcmp(sp->stm1->exp1->val.s, "fgets") &&
  852.     nosideeffects(sp->stm1->exp1->args[0], 1) &&
  853.     nosideeffects(sp->stm1->exp1->args[1], 1) &&
  854.     nosideeffects(sp->stm1->exp1->args[2], 1)) {
  855.     if ((sp->exp1->kind == EK_NOT &&
  856.  sp->exp1->args[0]->kind == EK_BICALL && *eofname &&
  857.  !strcmp(sp->exp1->args[0]->val.s, eofname) &&
  858.  exprsame(sp->exp1->args[0]->args[0],
  859.   sp->stm1->exp1->args[2], 1)) ||
  860. (sp->exp1->kind == EK_EQ &&
  861.  sp->exp1->args[0]->kind == EK_BICALL &&
  862.  !strcmp(sp->exp1->args[0]->val.s, "feof") &&
  863.  checkconst(sp->exp1->args[1], 0) &&
  864.  exprsame(sp->exp1->args[0]->args[0],
  865.   sp->stm1->exp1->args[2], 1))) {
  866. sp->stm1->exp1->val.type = tp_strptr;
  867. sp->exp1 = makeexpr_rel(EK_NE,
  868. sp->stm1->exp1,
  869. makeexpr_nil());
  870. sp->stm1 = sp->stm1->next;
  871.     }
  872.                 }
  873.                 fixblock(&sp->stm1, sp);
  874.                 sp->exp1 = fixexpr(sp->exp1, ENV_BOOL);
  875.                 if (checkconst(sp->exp1, 1))
  876.                     infiniteloop(sp);
  877.                 break;
  879.             case SK_REPEAT:
  880.                 fixblock(&sp->stm1, NULL);
  881.                 sp->exp1 = fixexpr(sp->exp1, ENV_BOOL);
  882.                 if (checkconst(sp->exp1, 1))
  883.                     infiniteloop(sp);
  884.                 break;
  886.             case SK_TRY:
  887.                 save_tryblock = fixexpr_tryblock;
  888.                 save_tryflag = fixexpr_tryflag;
  889.                 fixexpr_tryblock = sp->exp1->val.i;
  890.                 fixexpr_tryflag = 0;
  891.                 fixblock(&sp->stm1, NULL);
  892.                 if (fixexpr_tryflag)
  893.                     sp->exp2 = makeexpr_long(1);
  894.                 fixexpr_tryblock = save_tryblock;
  895.                 fixexpr_tryflag = save_tryflag;
  896.                 fixblock(&sp->stm2, NULL);
  897.                 break;
  899.             case SK_BODY:
  900.                 fixblock(&sp->stm1, thisreturn);
  901.                 break;
  903.             case SK_CASE:
  904.                 fixblock(&sp->stm1, NULL);
  905.                 sp->exp1 = fixexpr(sp->exp1, ENV_EXPR);
  906.                 if (!sp->stm1) {    /* empty case */
  907.                     sp->kind = SK_ASSIGN;
  908.                     continue;
  909.                 } else if (sp->stm1->kind != SK_CASELABEL) {   /* default only */
  910.                     for (sp2 = sp->stm1; sp2->next; sp2 = sp2->next) ;
  911.                     sp2->next = sp->next;
  912.                     sp->next = sp->stm1;
  913.                     sp->kind = SK_ASSIGN;
  914.                     sp->stm1 = NULL;
  915.                     continue;
  916.                 }
  917.                 break;
  919.             default:
  920.                 fixblock(&sp->stm1, NULL);
  921.                 fixblock(&sp->stm2, NULL);
  922.                 sp->exp1 = fixexpr(sp->exp1, ENV_EXPR);
  923.                 sp->exp2 = fixexpr(sp->exp2, ENV_EXPR);
  924.                 sp->exp3 = fixexpr(sp->exp3, ENV_EXPR);
  925.                 if (sp->next &&
  926.                     (sp->kind == SK_GOTO ||
  927.                      sp->kind == SK_BREAK ||
  928.                      sp->kind == SK_CONTINUE ||
  929.                      sp->kind == SK_RETURN) &&
  930.                     !haslabels(sp->next)) {
  931.                     if (elimdeadcode) {
  932.                         note("Deleting unreachable code [255]");
  933.                         while (sp->next && !haslabels(sp->next))
  934.                             eatstmt(&sp->next);
  935.                     } else {
  936.                         note("Code is unreachable [256]");
  937.                     }
  938.                 } else if (sp->kind == SK_RETURN &&
  939.                            thisreturn &&
  940.                            thisreturn->kind == SK_RETURN &&
  941.                            exprsame(sp->exp1, thisreturn->exp1, 1)) {
  942.                     eatstmt(spp);
  943.     continue;
  944.                 }
  945.                 break;
  946.         }
  947.         spp = &sp->next;
  948.     }
  949.     saveserial = curserial;
  950. }
  955. /* Convert comma expressions into multiple statements */
  957. Static int checkcomma_expr(spp, exp)
  958. Stmt **spp;
  959. Expr **exp;
  960. {
  961.     Stmt *sp;
  962.     Expr *ex = *exp;
  963.     int i, res;
  965.     switch (ex->kind) {
  967.         case EK_COMMA:
  968.             if (spp) {
  969.                 res = checkcomma_expr(spp, &ex->args[ex->nargs-1]);
  970.                 for (i = ex->nargs-1; --i >= 0; ) {
  971.                     sp = makestmt(SK_ASSIGN);
  972.                     sp->exp1 = ex->args[i];
  973.                     sp->next = *spp;
  974.                     *spp = sp;
  975.                     res = checkcomma_expr(spp, &ex->args[i]);
  976.                 }
  977.                 *exp = ex->args[ex->nargs-1];
  978.             }
  979.             return 1;
  981.         case EK_COND:
  982.             if (isescape(ex->args[1]) && spp &&
  983.                 !isescape(ex->args[2])) {
  984.                 swapexprs(ex->args[1], ex->args[2]);
  985.                 ex->args[0] = makeexpr_not(ex->args[0]);
  986.             }
  987.             if (isescape(ex->args[2])) {
  988.                 if (spp) {
  989.                     res = checkcomma_expr(spp, &ex->args[1]);
  990.                     if (ex->args[0]->kind == EK_ASSIGN) {
  991.                         sp = makestmt(SK_ASSIGN);
  992.                         sp->exp1 = copyexpr(ex->args[0]);
  993.                         sp->next = makestmt(SK_IF);
  994.                         sp->next->next = *spp;
  995.                         *spp = sp;
  996.                         res = checkcomma_expr(spp, &sp->exp1);
  997.                         ex->args[0] = grabarg(ex->args[0], 0);
  998.                         sp = sp->next;
  999.                     } else {
  1000.                         sp = makestmt(SK_IF);
  1001.                         sp->next = *spp;
  1002.                         *spp = sp;
  1003.                     }
  1004.                     sp->exp1 = makeexpr_not(ex->args[0]);
  1005.                     sp->stm1 = makestmt(SK_ASSIGN);
  1006.                     sp->stm1->exp1 = eatcasts(ex->args[2]);
  1007.                     res = checkcomma_expr(&sp->stm1, &ex->args[2]);
  1008.                     res = checkcomma_expr(spp, &sp->exp1);
  1009.                     *exp = ex->args[1];
  1010.                 }
  1011.                 return 1;
  1012.             }
  1013.             return checkcomma_expr(spp, &ex->args[0]);
  1015.         case EK_AND:
  1016.         case EK_OR:
  1017.             return checkcomma_expr(spp, &ex->args[0]);
  1019. default:
  1020.     res = 0;
  1021.     for (i = ex->nargs; --i >= 0; ) {
  1022. res += checkcomma_expr(spp, &ex->args[i]);
  1023.     }
  1024.     return res;
  1026.     }
  1027. }
  1031. Static void checkcommas(spp)
  1032. Stmt **spp;
  1033. {
  1034.     Stmt *sp;
  1035.     int res;
  1037.     while ((sp = *spp)) {
  1038.         checkcommas(&sp->stm1);
  1039.         checkcommas(&sp->stm2);
  1040.         switch (sp->kind) {
  1042.             case SK_ASSIGN:
  1043.             case SK_IF:
  1044.             case SK_CASE:
  1045.             case SK_RETURN:
  1046.                 if (sp->exp1)
  1047.                     res = checkcomma_expr(spp, &sp->exp1);
  1048.                 break;
  1050.             case SK_WHILE:
  1051.                 /* handle the argument */
  1052.                 break;
  1054.             case SK_REPEAT:
  1055.                 /* handle the argument */
  1056.                 break;
  1058.             case SK_FOR:
  1059. if (sp->exp1)
  1060.     res = checkcomma_expr(spp, &sp->exp1);
  1061.                 /* handle the other arguments */
  1062.                 break;
  1064.     default:
  1065. break;
  1066.         }
  1067.         spp = &sp->next;
  1068.     }
  1069. }
  1074. Static int checkvarchangeable(ex, mp)
  1075. Expr *ex;
  1076. Meaning *mp;
  1077. {
  1078.     switch (ex->kind) {
  1080.         case EK_VAR:
  1081.             return (mp == (Meaning *)ex->val.i);
  1083.         case EK_DOT:
  1084.         case EK_INDEX:
  1085.             return checkvarchangeable(ex->args[0], mp);
  1087. default:
  1088.     return 0;
  1089.     }
  1090. }
  1094. int checkvarchangedexpr(ex, mp, addrokay)
  1095. Expr *ex;
  1096. Meaning *mp;
  1097. int addrokay;
  1098. {
  1099.     int i;
  1100.     Meaning *mp3;
  1101.     unsigned int safemask = 0;
  1103.     switch (ex->kind) {
  1105.         case EK_FUNCTION:
  1106.         case EK_SPCALL:
  1107.             if (ex->kind == EK_FUNCTION) {
  1108.                 i = 0;
  1109.                 mp3 = ((Meaning *)ex->val.i)->type->fbase;
  1110.             } else {
  1111.                 i = 1;
  1112.                 if (ex->args[0]->val.type->kind != TK_PROCPTR)
  1113.                     return 1;
  1114.                 mp3 = ex->args[0]->val.type->basetype->fbase;
  1115.             }
  1116.             for ( ; i < ex->nargs && i < 16; i++) {
  1117.                 if (!mp3) {
  1118.                     intwarning("checkvarchangedexpr", "Too many arguments for EK_FUNCTION [266]");
  1119.                     break;
  1120.                 }
  1121.                 if (mp3->kind == MK_PARAM &&
  1122.                     (mp3->type->kind == TK_ARRAY ||
  1123.                      mp3->type->kind == TK_STRING ||
  1124.                      mp3->type->kind == TK_SET))
  1125.                     safemask |= 1<<i;
  1126.                 if (mp3->kind == MK_VARPARAM &&
  1127.                     mp3->type == tp_strptr && mp3->anyvarflag)
  1128.                     i++;
  1129.                 mp3 = mp3->xnext;
  1130.             }
  1131.             if (mp3)
  1132.                 intwarning("checkvarchangedexpr", "Too few arguments for EK_FUNCTION [267]");
  1133.             break;
  1135.         case EK_VAR:
  1136.             if (mp == (Meaning *)ex->val.i) {
  1137.                 if ((mp->type->kind == TK_ARRAY ||
  1138.                      mp->type->kind == TK_STRING ||
  1139.                      mp->type->kind == TK_SET) &&
  1140.                     ex->val.type->kind == TK_POINTER && !addrokay)
  1141.                     return 1;   /* must be an implicit & */
  1142.             }
  1143.             break;
  1145.         case EK_ADDR:
  1146.         case EK_ASSIGN:
  1147.         case EK_POSTINC:
  1148.         case EK_POSTDEC:
  1149.             if (checkvarchangeable(ex->args[0], mp))
  1150.                 return 1;
  1151.             break;
  1153.         case EK_BICALL:
  1154.             if (structuredfunc(ex) && checkvarchangeable(ex->args[0], mp))
  1155.                 return 1;
  1156.             safemask = safemask_bicall(ex->val.s);
  1157.             break;
  1158.             /* In case calls to these functions were lazy and passed
  1159.                the array rather than its (implicit) address.  Other
  1160.                BICALLs had better be careful about their arguments. */
  1162.         case EK_PLUS:
  1163.             if (addrokay)         /* to keep from being scared by pointer */
  1164.                 safemask = ~0;    /*  arithmetic on string being passed */
  1165.             break;                /*  to functions. */
  1167. default:
  1168.     break;
  1169.     }
  1170.     for (i = 0; i < ex->nargs; i++) {
  1171.         if (checkvarchangedexpr(ex->args[i], mp, safemask&1))
  1172.             return 1;
  1173.         safemask >>= 1;
  1174.     }
  1175.     return 0;
  1176. }
  1180. int checkvarchanged(sp, mp)
  1181. Stmt *sp;
  1182. Meaning *mp;
  1183. {
  1184.     if (mp->constqual)
  1185. return 0;
  1186.     if (mp->varstructflag || !mp->ctx || mp->ctx->kind != MK_FUNCTION ||
  1187.         mp->volatilequal || alwayscopyvalues)
  1188.         return 1;
  1189.     while (sp) {
  1190.         if (/* sp->kind == SK_GOTO || */
  1191.     sp->kind == SK_LABEL ||
  1192.             checkvarchanged(sp->stm1, mp) ||
  1193.             checkvarchanged(sp->stm2, mp) ||
  1194.             (sp->exp1 && checkvarchangedexpr(sp->exp1, mp, 1)) ||
  1195.             (sp->exp2 && checkvarchangedexpr(sp->exp2, mp, 1)) ||
  1196.             (sp->exp3 && checkvarchangedexpr(sp->exp3, mp, 1)))
  1197.             return 1;
  1198.         sp = sp->next;
  1199.     }
  1200.     return 0;
  1201. }
  1205. int checkexprchanged(sp, ex)
  1206. Stmt *sp;
  1207. Expr *ex;
  1208. {
  1209.     Meaning *mp;
  1210.     int i;
  1212.     for (i = 0; i < ex->nargs; i++) {
  1213.         if (checkexprchanged(sp, ex->args[i]))
  1214.             return 1;
  1215.     }
  1216.     switch (ex->kind) {
  1218.         case EK_VAR:
  1219.             mp = (Meaning *)ex->val.i;
  1220.             if (mp->kind == MK_CONST)
  1221.                 return 0;
  1222.             else
  1223.                 return checkvarchanged(sp, mp);
  1225.         case EK_HAT:
  1226.         case EK_INDEX:
  1227.         case EK_SPCALL:
  1228.             return 1;
  1230.         case EK_FUNCTION:
  1231.         case EK_BICALL:
  1232.             return !nosideeffects_func(ex);
  1234. default:
  1235.     return 0;
  1236.     }
  1237. }
  1243. /* Check if a variable always occurs with a certain offset added, e.g. "i+1" */
  1245. Static int theoffset, numoffsets, numzerooffsets;
  1246. #define BadOffset  (-999)
  1248. void checkvaroffsetexpr(ex, mp, myoffset)
  1249. Expr *ex;
  1250. Meaning *mp;
  1251. int myoffset;
  1252. {
  1253.     int i, nextoffset = 0;
  1254.     Expr *ex2;
  1256.     if (!ex)
  1257. return;
  1258.     switch (ex->kind) {
  1260.       case EK_VAR:
  1261. if (ex->val.i == (long)mp) {
  1262.     if (myoffset == 0)
  1263. numzerooffsets++;
  1264.     else if (numoffsets == 0 || myoffset == theoffset) {
  1265. theoffset = myoffset;
  1266. numoffsets++;
  1267.     } else
  1268. theoffset = BadOffset;
  1269. }
  1270. break;
  1272.       case EK_PLUS:
  1273. ex2 = ex->args[ex->nargs-1];
  1274. if (ex2->kind == EK_CONST &&
  1275.     ex2->val.type->kind == TK_INTEGER) {
  1276.     nextoffset = ex2->val.i;
  1277. }
  1278. break;
  1280.       case EK_HAT:
  1281.       case EK_POSTINC:
  1282.       case EK_POSTDEC:
  1283. nextoffset = BadOffset;
  1284. break;
  1286.       case EK_ASSIGN:
  1287. checkvaroffsetexpr(ex->args[0], mp, BadOffset);
  1288. checkvaroffsetexpr(ex->args[1], mp, 0);
  1289. return;
  1291.       default:
  1292. break;
  1293.     }
  1294.     i = ex->nargs;
  1295.     while (--i >= 0)
  1296. checkvaroffsetexpr(ex->args[i], mp, nextoffset);
  1297. }
  1300. void checkvaroffsetstmt(sp, mp)
  1301. Stmt *sp;
  1302. Meaning *mp;
  1303. {
  1304.     while (sp) {
  1305. checkvaroffsetstmt(sp->stm1, mp);
  1306. checkvaroffsetstmt(sp->stm1, mp);
  1307. checkvaroffsetexpr(sp->exp1, mp, 0);
  1308. checkvaroffsetexpr(sp->exp2, mp, 0);
  1309. checkvaroffsetexpr(sp->exp3, mp, 0);
  1310. sp = sp->next;
  1311.     }
  1312. }
  1315. int checkvaroffset(sp, mp)
  1316. Stmt *sp;
  1317. Meaning *mp;
  1318. {
  1319.     if (mp->varstructflag || !mp->ctx || mp->ctx->kind != MK_FUNCTION)
  1320. return 0;
  1321.     numoffsets = 0;
  1322.     numzerooffsets = 0;
  1323.     checkvaroffsetstmt(sp, mp);
  1324.     if (numoffsets == 0 || theoffset == BadOffset ||
  1325. numoffsets <= numzerooffsets * 3)
  1326. return 0;
  1327.     else
  1328. return theoffset;
  1329. }
  1334. void initfilevars(mp, sppp, exbase)
  1335. Meaning *mp;
  1336. Stmt ***sppp;
  1337. Expr *exbase;
  1338. {
  1339.     Stmt *sp;
  1340.     Type *tp;
  1341.     Expr *ex;
  1343.     while (mp) {
  1344. if ((mp->kind == MK_VAR && mp->refcount > 0 && !mp->istemporary) ||
  1345.     mp->kind == MK_FIELD) {
  1346.     tp = mp->type;
  1347.     if (isfiletype(tp)) {
  1348. mp->refcount++;
  1349. sp = makestmt(SK_ASSIGN);
  1350. sp->next = **sppp;
  1351. **sppp = sp;
  1352. if (exbase)
  1353.     ex = makeexpr_dot(copyexpr(exbase), mp);
  1354. else
  1355.     ex = makeexpr_var(mp);
  1356. sp->exp1 = makeexpr_assign(copyexpr(ex), makeexpr_nil());
  1357.     } else if (tp->kind == TK_RECORD) {
  1358. if (exbase)
  1359.     ex = makeexpr_dot(copyexpr(exbase), mp);
  1360. else
  1361.     ex = makeexpr_var(mp);
  1362. initfilevars(tp->fbase, sppp, ex);
  1363. freeexpr(ex);
  1364.     } else if (tp->kind == TK_ARRAY) {
  1365. while (tp->kind == TK_ARRAY)
  1366.     tp = tp->basetype;
  1367. if (isfiletype(tp))
  1368.     note(format_s("Array of files %s should be initialized [257]",
  1369.   mp->name));
  1370.     }
  1371. }
  1372. mp = mp->cnext;
  1373.     }
  1374. }
  1380. Static Stmt *p_body()
  1381. {
  1382.     Stmt *sp, **spp, *spbody, **sppbody, *spbase, *thereturn;
  1383.     Meaning *mp;
  1384.     Expr *ex;
  1385.     int haspostamble;
  1386.     long saveserial;
  1388.     if (verbose)
  1389. fprintf(logf, "%s, %d/%d: Translating %s (in %s)n",
  1390. infname, inf_lnum, outf_lnum,
  1391. curctx->name, curctx->ctx->name);
  1392.     notephase = 1;
  1393.     spp = &spbase;
  1394.     addstmt(SK_HEADER);
  1395.     sp->exp1 = makeexpr_var(curctx);
  1396.     checkkeyword(TOK_INLINE);
  1397.     if (curtok != TOK_END && curtok != TOK_BEGIN && curtok != TOK_INLINE) {
  1398. if (curctx->kind == MK_FUNCTION || curctx->anyvarflag)
  1399.     wexpecttok(TOK_BEGIN);
  1400. else
  1401.     wexpecttok(TOK_END);
  1402. skiptotoken2(TOK_BEGIN, TOK_END);
  1403.     }
  1404.     if (curtok == TOK_END) {
  1405. gettok();
  1406. spbody = NULL;
  1407.     } else {
  1408. spbody = p_stmt(NULL, SF_FUNC);  /* parse the procedure/program body */
  1409.     }
  1410.     if (curtok == TOK_IDENT && curtokmeaning == curctx) {
  1411. gettok();    /* Modula-2 */
  1412.     }
  1413.     notephase = 2;
  1414.     saveserial = curserial;
  1415.     curserial = 10000;
  1416.     if (curctx->kind == MK_FUNCTION) {     /* handle copy parameters */
  1417.         for (mp = curctx->type->fbase; mp; mp = mp->xnext) {
  1418.             if (!mp->othername && mp->varstructflag) {
  1419.                 mp->othername = stralloc(format_s(name_COPYPAR, mp->name));
  1420.                 mp->rectype = mp->type;
  1421.                 addstmt(SK_ASSIGN);
  1422.                 sp->exp1 = makeexpr_assign(makeexpr_var(mp), 
  1423.                                            makeexpr_name(mp->othername, mp->rectype));
  1424.                 mp->refcount++;
  1425.             } else if (mp->othername) {
  1426.                 if (checkvarchanged(spbody, mp)) {
  1427.                     addstmt(SK_ASSIGN);
  1428.                     sp->exp1 = makeexpr_assign(makeexpr_var(mp),
  1429.                                                makeexpr_hat(makeexpr_name(mp->othername,
  1430.                                                                           mp->rectype), 0));
  1431.                     mp->refcount++;
  1432.                 } else {           /* don't need to copy it after all */
  1433.                     strchange(&mp->othername, mp->name);
  1434.                     ex = makeexpr_var(mp);
  1435.                     ex->val.type = mp->rectype;
  1436.                     replaceexpr(spbody, makeexpr_var(mp), makeexpr_hat(ex, 0));
  1437.                 }
  1438.             }
  1439.         }
  1440.     }
  1441.     for (mp = curctx->cbase; mp; mp = mp->cnext) {
  1442. if (mp->kind == MK_LABEL && mp->val.i) {
  1443.     addstmt(SK_IF);
  1444.     sp->exp1 = makeexpr_bicall_1("setjmp", tp_int,
  1445.  makeexpr_var(mp->xnext));
  1446.     sp->stm1 = makestmt(SK_GOTO);
  1447.     sp->stm1->exp1 = makeexpr_name(format_s(name_LABEL, mp->name),
  1448.    tp_integer);
  1449. }
  1450.     }
  1451.     *spp = spbody;
  1452.     sppbody = spp;
  1453.     while (*spp)
  1454.         spp = &((*spp)->next);
  1455.     haspostamble = 0;
  1456.     initfilevars(curctx->cbase, &sppbody, NULL);
  1457.     for (mp = curctx->cbase; mp; mp = mp->cnext) {
  1458.         if (mp->kind == MK_VAR && mp->refcount > 0 && isfiletype(mp->type) &&
  1459.              !mp->istemporary) {
  1460.             if (curctx->kind != MK_MODULE || curctx->anyvarflag) {
  1461.                 addstmt(SK_IF);                    /* close file variables */
  1462.                 sp->exp1 = makeexpr_rel(EK_NE, makeexpr_var(mp), makeexpr_nil());
  1463.                 sp->stm1 = makestmt(SK_ASSIGN);
  1464.                 sp->stm1->exp1 = makeexpr_bicall_1("fclose", tp_void, makeexpr_var(mp));
  1465.             }
  1466.             haspostamble = 1;
  1467.         }
  1468.     }
  1469.     thereturn = &bogusreturn;
  1470.     if (curctx->kind == MK_FUNCTION && curctx->type->basetype != tp_void) {
  1471.         if ((haspostamble || !checkreturns(&spbase, 1)) &&
  1472.             curctx->cbase->refcount > 0) {      /* add function return code */
  1473.             addstmt(SK_RETURN);
  1474.             sp->exp1 = makeexpr_var(curctx->cbase);
  1475.         }
  1476.         thereturn = NULL;
  1477.     } else if (curctx->kind == MK_MODULE && curctx->anyvarflag) {
  1478.         addstmt(SK_ASSIGN);
  1479.         sp->exp1 = makeexpr_bicall_1("exit", tp_void, makeexpr_long(0));
  1480.         thereturn = NULL;
  1481.     }
  1482.     if (debug>2) { fprintf(outf, "calling fixblock/usecommas on:n"); dumpstmt(spbase, 5); }
  1483.     curserial = saveserial;
  1484.     sp = makestmt(SK_BODY);
  1485.     sp->stm1 = spbase;
  1486.     fixblock(&sp, thereturn);           /* finishing touches to statements and expressions */
  1487.     spbase = sp->stm1;
  1488.     FREE(sp);
  1489.     if (usecommas != 1)
  1490.         checkcommas(&spbase);    /* unroll ugly EK_COMMA and EK_COND expressions */
  1491.     if (debug>1) { fprintf(outf, "p_body returns:n"); dumpstmt(spbase, 5); }
  1492.     notephase = 0;
  1493.     return spbase;
  1494. }
  1499. #define checkWord()  if (anywords) output(" "); anywords = 1
  1501. Static void out_function(func)
  1502. Meaning *func;
  1503. {
  1504.     Meaning *mp;
  1505.     Symbol *sym;
  1506.     int opts, anywords, spacing, saveindent;
  1508.     if (func->varstructflag) {
  1509.         makevarstruct(func);
  1510.     }
  1511.     if (collectnest) {
  1512. for (mp = func->cbase; mp; mp = mp->cnext) {
  1513.     if (mp->kind == MK_FUNCTION && mp->isforward) {
  1514. forward_decl(mp, 0);
  1515.     }
  1516. }
  1517. for (mp = func->cbase; mp; mp = mp->cnext) {
  1518.     if (mp->kind == MK_FUNCTION && mp->type) {
  1519. pushctx(mp);
  1520. out_function(mp);    /* generate the sub-procedures first */
  1521. popctx();
  1522.     }
  1523. }
  1524.     }
  1525.     spacing = functionspace;
  1526.     for (mp = func; mp->ctx->kind == MK_FUNCTION; mp = mp->ctx) {
  1527.         if (spacing > minfuncspace)
  1528.             spacing--;
  1529.     }
  1530.     outsection(spacing);
  1531.     flushcomments(&func->comments, -1, 0);
  1532.     if (usePPMacros == 1) {
  1533.         forward_decl(func, 0);
  1534.         outsection(minorspace);
  1535.     }
  1536.     opts = ODECL_HEADER;
  1537.     anywords = 0;
  1538.     if (func->namedfile) {
  1539. checkWord();
  1540. if (useAnyptrMacros || ansiC < 2)
  1541.     output("Inline");
  1542. else
  1543.     output("inline");
  1544.     }
  1545.     if (!func->exported) {
  1546. if (func->ctx->kind == MK_FUNCTION) {
  1547.     if (useAnyptrMacros) {
  1548. checkWord();
  1549. output("Local");
  1550.     } else if (use_static) {
  1551. checkWord();
  1552. output("static");
  1553.     }
  1554. } else if ((findsymbol(func->name)->flags & NEEDSTATIC) ||
  1555.    (use_static != 0 && !useAnyptrMacros)) {
  1556.     checkWord();
  1557.     output("static");
  1558. } else if (useAnyptrMacros) {
  1559.     checkWord();
  1560.     output("Static");
  1561. }
  1562.     }
  1563.     if (func->type->basetype != tp_void || ansiC != 0) {
  1564. checkWord();
  1565.         outbasetype(func->type, 0);
  1566.     }
  1567.     if (anywords) {
  1568.         if (newlinefunctions)
  1569.             opts |= ODECL_FUNCTION;
  1570.         else
  1571.             output(" ");
  1572.     }
  1573.     outdeclarator(func->type, func->name, opts);
  1574.     if (fullprototyping == 0) {
  1575. saveindent = outindent;
  1576. moreindent(argindent);
  1577.         out_argdecls(func->type);
  1578. outindent = saveindent;
  1579.     }
  1580.     for (mp = func->type->fbase; mp; mp = mp->xnext) {
  1581.         if (mp->othername && strcmp(mp->name, mp->othername))
  1582.             mp->wasdeclared = 0;    /* make sure we also declare the copy */
  1583.     }
  1584.     func->wasdeclared = 1;
  1585.     outcontext = func;
  1586.     out_block((Stmt *)func->val.i, BR_FUNCTION, 10000);
  1587.     if (useundef) {
  1588. anywords = 0;
  1589. for (mp = func->cbase; mp; mp = mp->cnext) {
  1590.     if (mp->kind == MK_CONST &&