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

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

编译器/解释器

开发平台：

C/C++

parse.c.1：源码内容
  1. /* "p2c", a Pascal to C translator.
  2.    Copyright (C) 1989 David Gillespie.
  3.    Author's address: daveg@csvax.caltech.edu; 256-80 Caltech/Pasadena CA 91125.
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation (any version).
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program; see the file COPYING.  If not, write to
  16. the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  20. #define PROTO_PARSE_C
  21. #include "trans.h"
  25. Static short candeclare;
  26. Static int trycount;
  27. Static Strlist *includedfiles;
  28. Static char echo_first;
  29. Static int echo_pos;
  33. void setup_parse()
  34. {
  35.     candeclare = 0;
  36.     trycount = 0;
  37.     includedfiles = NULL;
  38.     echo_first = 1;
  39.     echo_pos = 0;
  40.     fixexpr_tryblock = 0;
  41. }
  45. void echobreak()
  46. {
  47.     if (echo_pos > 0) {
  48. printf("n");
  49. echo_pos = 0;
  50. echo_first = 0;
  51.     }
  52. }
  55. void echoword(name, comma)
  56. char *name;
  57. int comma;
  58. {
  59.     FILE *f = (outf == stdout) ? stderr : stdout;
  61.     if (quietmode || showprogress)
  62.         return;
  63.     if (!echo_first) {
  64. if (comma) {
  65.     fprintf(f, ",");
  66.     echo_pos++;
  67. }
  68.         if (echo_pos + strlen(name) > 77) {
  69.             fprintf(f, "n");
  70.             echo_pos = 0;
  71.         } else {
  72.             fprintf(f, " ");
  73.             echo_pos++;
  74.         }
  75.     }
  76.     echo_first = 0;
  77.     fprintf(f, "%s", name);
  78.     echo_pos += strlen(name);
  79.     fflush(f);
  80. }
  84. void echoprocname(mp)
  85. Meaning *mp;
  86. {
  87.     echoword(mp->name, 1);
  88. }
  94. Static void forward_decl(func, isextern)
  95. Meaning *func;
  96. int isextern;
  97. {
  98.     if (func->wasdeclared)
  99.         return;
  100.     if (isextern && func->constdefn && !checkvarmac(func))
  101. return;
  102.     if (isextern) {
  103.         output("extern ");
  104.     } else if (func->ctx->kind == MK_FUNCTION) {
  105. if (useAnyptrMacros)
  106.     output("Local ");
  107. else
  108.     output("static ");
  109.     } else if ((use_static != 0 && !useAnyptrMacros) ||
  110.        (findsymbol(func->name)->flags & NEEDSTATIC)) {
  111. output("static ");
  112.     } else if (useAnyptrMacros) {
  113. output("Static ");
  114.     }
  115.     if (func->type->basetype != tp_void || ansiC != 0) {
  116.         outbasetype(func->type, ODECL_FORWARD);
  117.         output(" ");
  118.     }
  119.     outdeclarator(func->type, func->name, ODECL_FORWARD);
  120.     output(";n");
  121.     func->wasdeclared = 1;
  122. }
  127. /* Check if calling a parent procedure, whose body must */
  128. /*   be declared forward */
  130. void need_forward_decl(func)
  131. Meaning *func;
  132. {
  133.     Meaning *mp;
  135.     if (func->wasdeclared)
  136.         return;
  137.     for (mp = curctx->ctx; mp; mp = mp->ctx) {
  138.         if (mp == func) {
  139.     if (func->ctx->kind == MK_FUNCTION)
  140. func->isforward = 1;
  141.     else
  142. forward_decl(func, 0);
  143.             return;
  144.         }
  145.     }
  146. }
  151. void free_stmt(sp)
  152. register Stmt *sp;
  153. {
  154.     if (sp) {
  155.         free_stmt(sp->stm1);
  156.         free_stmt(sp->stm2);
  157.         free_stmt(sp->next);
  158.         freeexpr(sp->exp1);
  159.         freeexpr(sp->exp2);
  160.         freeexpr(sp->exp3);
  161.         FREE(sp);
  162.     }
  163. }
  168. Stmt *makestmt(kind)
  169. enum stmtkind kind;
  170. {
  171.     Stmt *sp;
  173.     sp = ALLOC(1, Stmt, stmts);
  174.     sp->kind = kind;
  175.     sp->next = NULL;
  176.     sp->stm1 = NULL;
  177.     sp->stm2 = NULL;
  178.     sp->exp1 = NULL;
  179.     sp->exp2 = NULL;
  180.     sp->exp3 = NULL;
  181.     sp->serial = curserial = ++serialcount;
  182.     return sp;
  183. }
  187. Stmt *makestmt_call(call)
  188. Expr *call;
  189. {
  190.     Stmt *sp = makestmt(SK_ASSIGN);
  191.     sp->exp1 = call;
  192.     return sp;
  193. }
  197. Stmt *makestmt_assign(lhs, rhs)
  198. Expr *lhs, *rhs;
  199. {
  200.     Stmt *sp = makestmt(SK_ASSIGN);
  201.     sp->exp1 = makeexpr_assign(lhs, rhs);
  202.     return sp;
  203. }
  207. Stmt *makestmt_if(cond, thn, els)
  208. Expr *cond;
  209. Stmt *thn, *els;
  210. {
  211.     Stmt *sp = makestmt(SK_IF);
  212.     sp->exp1 = cond;
  213.     sp->stm1 = thn;
  214.     sp->stm2 = els;
  215.     return sp;
  216. }
  220. Stmt *makestmt_seq(s1, s2)
  221. Stmt *s1, *s2;
  222. {
  223.     Stmt *s1a;
  225.     if (!s1)
  226.         return s2;
  227.     if (!s2)
  228.         return s1;
  229.     for (s1a = s1; s1a->next; s1a = s1a->next) ;
  230.     s1a->next = s2;
  231.     return s1;
  232. }
  236. Stmt *copystmt(sp)
  237. Stmt *sp;
  238. {
  239.     Stmt *sp2;
  241.     if (sp) {
  242.         sp2 = makestmt(sp->kind);
  243.         sp2->stm1 = copystmt(sp->stm1);
  244.         sp2->stm2 = copystmt(sp->stm2);
  245.         sp2->exp1 = copyexpr(sp->exp1);
  246.         sp2->exp2 = copyexpr(sp->exp2);
  247.         sp2->exp3 = copyexpr(sp->exp3);
  248.         return sp2;
  249.     } else
  250.         return NULL;
  251. }
  255. void nukestmt(sp)
  256. Stmt *sp;
  257. {
  258.     if (sp) {
  259.         sp->kind = SK_ASSIGN;
  260.         sp->exp1 = makeexpr_long(0);
  261.     }
  262. }
  266. void splicestmt(sp, spnew)
  267. Stmt *sp, *spnew;
  268. {
  269.     Stmt *snext;
  271.     snext = sp->next;
  272.     *sp = *spnew;
  273.     while (sp->next)
  274.         sp = sp->next;
  275.     sp->next = snext;
  276. }
  280. int stmtcount(sp)
  281. Stmt *sp;
  282. {
  283.     int i = 0;
  285.     while (sp) {
  286.         i += 1 + stmtcount(sp->stm1) + stmtcount(sp->stm2);
  287.         sp = sp->next;
  288.     }
  289.     return i;
  290. }
  296. Stmt *close_files_to_ctx(ctx)
  297. Meaning *ctx;
  298. {
  299.     Meaning *ctx2, *mp;
  300.     Stmt *splist = NULL, *sp;
  302.     ctx2 = curctx;
  303.     while (ctx2 && ctx2 != ctx && ctx2->kind == MK_FUNCTION) {
  304. for (mp = ctx2->cbase; mp; mp = mp->cnext) {
  305.     if (mp->kind == MK_VAR &&
  306. isfiletype(mp->type) && !mp->istemporary) {
  307. var_reference(mp);
  308. sp = makestmt_if(makeexpr_rel(EK_NE, makeexpr_var(mp),
  309.       makeexpr_nil()),
  310.  makestmt_call(
  311.      makeexpr_bicall_1("fclose", tp_void,
  312.        makeexpr_var(mp))),
  313.  NULL);
  314. splist = makestmt_seq(splist, sp);
  315.     }
  316. }
  317. ctx2 = ctx2->ctx;
  318.     }
  319.     return splist;
  320. }
  325. int simplewith(ex)
  326. Expr *ex;
  327. {
  328.     switch (ex->kind) {
  329.         case EK_VAR:
  330.         case EK_CONST:
  331.             return 1;
  332.         case EK_DOT:
  333.             return simplewith(ex->args[0]);
  334.         default:
  335.             return 0;
  336.     }
  337. }
  340. int simplefor(sp, ex)
  341. Stmt *sp;
  342. Expr *ex;
  343. {
  344.     return (exprspeed(sp->exp2) <= 3 &&
  345.             !checkexprchanged(sp->stm1, sp->exp2) &&
  346.     !exproccurs(sp->exp2, ex));
  347. }
  351. int tryfuncmacro(exp, mp)
  352. Expr **exp;
  353. Meaning *mp;
  354. {
  355.     char *name;
  356.     Strlist *lp;
  357.     Expr *ex = *exp, *ex2;
  359.     ex2 = (mp) ? mp->constdefn : NULL;
  360.     if (!ex2) {
  361. if (ex->kind == EK_BICALL || ex->kind == EK_NAME)
  362.     name = ex->val.s;
  363. else if (ex->kind == EK_FUNCTION)
  364.     name = ((Meaning *)ex->val.i)->name;
  365. else
  366.     return 0;
  367. lp = strlist_cifind(funcmacros, name);
  368. ex2 = (lp) ? (Expr *)lp->value : NULL;
  369.     }
  370.     if (ex2) {
  371.         *exp = replacemacargs(copyexpr(ex2), ex);
  372. freeexpr(ex);
  373.         return 1;
  374.     }
  375.     return 0;
  376. }
  382. #define addstmt(kind)   
  383.     *spp = sp = makestmt(kind),   
  384.     spp = &(sp->next)
  386. #define newstmt(kind)   
  387.     addstmt(kind),   
  388.     steal_comments(firstserial, sp->serial, sflags & SF_FIRST),   
  389.     sflags &= ~SF_FIRST
  393. #define SF_FUNC    0x1
  394. #define SF_SAVESER 0x2
  395. #define SF_FIRST   0x4
  396. #define SF_IF    0x8
  398. Static Stmt *p_stmt(slist, sflags)
  399. Stmt *slist;
  400. int sflags;
  401. {
  402.     Stmt *sbase = NULL, **spp = &sbase, **spp2, **spp3, **savespp;
  403.     Stmt *defsp, **defsphook;
  404.     register Stmt *sp;
  405.     Stmt *sp2;
  406.     long li1, li2, firstserial = 0, saveserial = 0, saveserial2;
  407.     int i, forfixed, offset, line1, line2, toobig, isunsafe;
  408.     Token savetok;
  409.     char *name;
  410.     Expr *ep, *ep2, *ep3, *forstep, *range, *swexpr, *trueswexpr;
  411.     Type *tp;
  412.     Meaning *mp, *tvar, *tempmark;
  413.     Symbol *sym;
  414.     enum exprkind ekind;
  415.     Stmt *(*prochandler)();
  416.     Strlist *cmt;
  418.     tempmark = markstmttemps();
  419. again:
  420.     while (findlabelsym()) {
  421.         newstmt(SK_LABEL);
  422.         sp->exp1 = makeexpr_name(format_s(name_LABEL, curtokmeaning->name), tp_integer);
  423.         gettok();
  424.         wneedtok(TOK_COLON);
  425.     }
  426.     firstserial = curserial;
  427.     checkkeyword(TOK_TRY);
  428.     checkkeyword(TOK_INLINE);
  429.     checkkeyword(TOK_LOOP);
  430.     checkkeyword(TOK_RETURN);
  431.     if (modula2) {
  432. if (sflags & SF_SAVESER)
  433.     goto stmtSeq;
  434.     }
  435.     switch (curtok) {
  437.         case TOK_BEGIN:
  438.         stmtSeq:
  439.     if (sflags & (SF_FUNC|SF_SAVESER)) {
  440. saveserial = curserial;
  441. cmt = grabcomment(CMT_ONBEGIN);
  442. if (sflags & SF_FUNC)
  443.     cmt = fixbeginendcomment(cmt);
  444. strlist_mix(&curcomments, cmt);
  445.     }
  446.     i = sflags & SF_FIRST;
  447.             do {
  448. if (modula2) {
  449.     if (curtok == TOK_BEGIN || curtok == TOK_SEMI)
  450. gettok();
  451.     checkkeyword(TOK_ELSIF);
  452.     if (curtok == TOK_ELSE || curtok == TOK_ELSIF)
  453. break;
  454. } else
  455.     gettok();
  456.                 *spp = p_stmt(sbase, i);
  457. i = 0;
  458.                 while (*spp)
  459.                     spp = &((*spp)->next);
  460.             } while (curtok == TOK_SEMI);
  461.     if (sflags & (SF_FUNC|SF_SAVESER)) {
  462. cmt = grabcomment(CMT_ONEND);
  463. changecomments(cmt, -1, -1, -1, saveserial);
  464. if (sflags & SF_FUNC)
  465.     cmt = fixbeginendcomment(cmt);
  466. strlist_mix(&curcomments, cmt);
  467. if (sflags & SF_FUNC)
  468.     changecomments(curcomments, -1, saveserial, -1, 10000);
  469. curserial = saveserial;
  470.     }
  471.     checkkeyword(TOK_ELSIF);
  472.     if (modula2 && (sflags & SF_IF)) {
  473. break;
  474.     }
  475.     if (curtok == TOK_VBAR)
  476. break;
  477.             if (!wneedtok(TOK_END))
  478. skippasttoken(TOK_END);
  479.             break;
  481.         case TOK_CASE:
  482.             gettok();
  483.             swexpr = trueswexpr = p_ord_expr();
  484.             if (nosideeffects(swexpr, 1)) {
  485.                 tvar = NULL;
  486.             } else {
  487.                 tvar = makestmttempvar(swexpr->val.type, name_TEMP);
  488.                 swexpr = makeexpr_var(tvar);
  489.             }
  490.             savespp = spp;
  491.             newstmt(SK_CASE);
  492.     saveserial2 = curserial;
  493.             sp->exp1 = trueswexpr;
  494.             spp2 = &sp->stm1;
  495.             tp = swexpr->val.type;
  496.             defsp = NULL;
  497.             defsphook = &defsp;
  498.             if (!wneedtok(TOK_OF)) {
  499. skippasttoken(TOK_END);
  500. break;
  501.     }
  502.     i = 1;
  503.     while (curtok == TOK_VBAR)
  504. gettok();
  505.     checkkeyword(TOK_OTHERWISE);
  506.             while (curtok != TOK_END && curtok != TOK_OTHERWISE && curtok != TOK_ELSE) {
  507.                 spp3 = spp2;
  508. saveserial = curserial;
  509.                 *spp2 = sp = makestmt(SK_CASELABEL);
  510. steal_comments(saveserial, sp->serial, i);
  511.                 spp2 = &sp->next;
  512.                 range = NULL;
  513.                 toobig = 0;
  514.                 for (;;) {
  515.                     ep = gentle_cast(p_expr(tp), tp);
  516.                     if (curtok == TOK_DOTS) {
  517.                         li1 = ord_value(eval_expr(ep));
  518.                         gettok();
  519.                         ep2 = gentle_cast(p_expr(tp), tp);
  520.                         li2 = ord_value(eval_expr(ep2));
  521.                         range = makeexpr_or(range,
  522.                                             makeexpr_range(copyexpr(swexpr),
  523.                                                            ep, ep2, 1));
  524.                         if (li2 - li1 >= caselimit)
  525.                             toobig = 1;
  526.                         if (!toobig) {
  527.                             for (;;) {
  528.                                 sp->exp1 = makeexpr_val(make_ord(tp, li1));
  529.                                 if (li1 >= li2) break;
  530.                                 li1++;
  531. serialcount--;   /* make it reuse the count */
  532.                                 sp->stm1 = makestmt(SK_CASELABEL);
  533.                                 sp = sp->stm1;
  534.                             }
  535.                         }
  536.                     } else {
  537.                         sp->exp1 = copyexpr(ep);
  538.                         range = makeexpr_or(range,
  539.                                             makeexpr_rel(EK_EQ, 
  540.                                                          copyexpr(swexpr),
  541.                                                          ep));
  542.                     }
  543.                     if (curtok == TOK_COMMA) {
  544.                         gettok();
  545. serialcount--;   /* make it reuse the count */
  546.                         sp->stm1 = makestmt(SK_CASELABEL);
  547.                         sp = sp->stm1;
  548.                     } else
  549.                         break;
  550.                 }
  551.                 wneedtok(TOK_COLON);
  552.                 if (toobig) {
  553.                     free_stmt(*spp3);
  554.                     spp2 = spp3;
  555.                     *defsphook = makestmt_if(range, p_stmt(NULL, SF_SAVESER),
  556.      NULL);
  557.                     if (defsphook != &defsp && elseif != 0)
  558.                         (*defsphook)->exp2 = makeexpr_long(1);
  559.                     defsphook = &((*defsphook)->stm2);
  560.                 } else {
  561.                     freeexpr(range);
  562.                     sp->stm1 = p_stmt(NULL, SF_SAVESER);
  563.                 }
  564. i = 0;
  565. checkkeyword(TOK_OTHERWISE);
  566.                 if (curtok != TOK_END && curtok != TOK_OTHERWISE && curtok != TOK_ELSE) {
  567.     if (curtok == TOK_VBAR) {
  568. while (curtok == TOK_VBAR)
  569.     gettok();
  570.     } else
  571. wneedtok(TOK_SEMI);
  572.     checkkeyword(TOK_OTHERWISE);
  573. }
  574.             }
  575.             if (defsp) {
  576.                 *spp2 = defsp;
  577.                 spp2 = defsphook;
  578.                 if (tvar) {
  579.                     sp = makestmt_assign(makeexpr_var(tvar), trueswexpr);
  580.                     sp->next = *savespp;
  581.                     *savespp = sp;
  582.                     sp->next->exp1 = swexpr;
  583.                 }
  584.             } else {
  585.                 if (tvar) {
  586.                     canceltempvar(tvar);
  587.                     freeexpr(swexpr);
  588.                 }
  589.             }
  590.             if (curtok == TOK_OTHERWISE || curtok == TOK_ELSE) {
  591.                 gettok();
  592.                 while (curtok == TOK_SEMI)
  593.                     gettok();
  594. /* changecomments(curcomments, CMT_TRAIL, curserial,
  595.                     CMT_POST, -1);   */
  596. i = SF_FIRST;
  597. while (curtok != TOK_END) {
  598.                     *spp2 = p_stmt(NULL, i);
  599.                     while (*spp2)
  600.                         spp2 = &((*spp2)->next);
  601.     i = 0;
  602.                     if (curtok != TOK_SEMI)
  603.                         break;
  604.                     gettok();
  605.                 }
  606.                 if (!wexpecttok(TOK_END))
  607.     skiptotoken(TOK_END);
  608.             } else if (casecheck == 1 || (casecheck == 2 && range_flag)) {
  609.                 *spp2 = makestmt(SK_CASECHECK);
  610.             }
  611.     curserial = saveserial2;
  612.     strlist_mix(&curcomments, grabcomment(CMT_ONEND));
  613.             gettok();
  614.             break;
  616.         case TOK_FOR:
  617.             forfixed = fixedflag;
  618.             gettok();
  619.             newstmt(SK_FOR);
  620.             ep = p_expr(tp_integer);
  621.             if (!wneedtok(TOK_ASSIGN)) {
  622. skippasttoken(TOK_DO);
  623. break;
  624.     }
  625.             ep2 = makeexpr_charcast(p_expr(ep->val.type));
  626.             if (curtok != TOK_DOWNTO) {
  627. if (!wexpecttok(TOK_TO)) {
  628.     skippasttoken(TOK_DO);
  629.     break;
  630. }
  631.     }
  632.             savetok = curtok;
  633.             gettok();
  634.             sp->exp2 = makeexpr_charcast(p_expr(ep->val.type));
  635.     checkkeyword(TOK_BY);
  636.     if (curtok == TOK_BY) {
  637. gettok();
  638. forstep = p_expr(tp_integer);
  639. i = possiblesigns(forstep);
  640. if ((i & 5) == 5) {
  641.     if (expr_is_neg(forstep)) {
  642. ekind = EK_GE;
  643. note("Assuming FOR loop step is negative [252]");
  644.     } else {
  645. ekind = EK_LE;
  646. note("Assuming FOR loop step is positive [252]");
  647.     }
  648. } else {
  649.     if (!(i & 1))
  650. ekind = EK_LE;
  651.     else
  652. ekind = EK_GE;
  653. }
  654.     } else {
  655. if (savetok == TOK_DOWNTO) {
  656.     ekind = EK_GE;
  657.     forstep = makeexpr_long(-1);
  658. } else {
  659.     ekind = EK_LE;
  660.     forstep = makeexpr_long(1);
  661. }
  662.     }
  663.             tvar = NULL;
  664.     swexpr = NULL;
  665.             if (ep->kind == EK_VAR) {
  666.                 tp = findbasetype(ep->val.type, 0);
  667.                 if ((tp == tp_char || tp == tp_schar || tp == tp_uchar ||
  668.                      tp == tp_abyte || tp == tp_sbyte || tp == tp_ubyte ||
  669.      tp == tp_boolean) &&
  670.                     ((checkconst(sp->exp2, 0) &&
  671.       tp != tp_sbyte && tp != tp_schar) ||
  672.                      checkconst(sp->exp2, -128) ||
  673.                      (checkconst(sp->exp2, 127) &&
  674.       tp != tp_ubyte && tp != tp_uchar) ||
  675.                      checkconst(sp->exp2, 255) ||
  676.                      (tp == tp_char &&
  677.                       (useAnyptrMacros == 1 || unsignedchar != 1) &&
  678.                       isliteralconst(sp->exp2, NULL) == 2 &&
  679.                       sp->exp2->val.i >= 128))) {
  680.                     swexpr = ep;
  681.                     tvar = makestmttempvar(tp_sshort, name_TEMP);
  682.                     ep = makeexpr_var(tvar);
  683.                 } else if (((tp == tp_sshort &&
  684.                              (checkconst(sp->exp2, -32768) ||
  685.                               checkconst(sp->exp2, 32767))) ||
  686.                             (tp == tp_ushort &&
  687.                              (checkconst(sp->exp2, 0) ||
  688.                               checkconst(sp->exp2, 65535))))) {
  689.                     swexpr = ep;
  690.                     tvar = makestmttempvar(tp_integer, name_TEMP);
  691.                     ep = makeexpr_var(tvar);
  692.                 } else if (tp == tp_integer &&
  693.    (checkconst(sp->exp2, LONG_MAX) ||
  694.     (sp->exp2->kind == EK_VAR &&
  695.      sp->exp2->val.i == (long)mp_maxint))) {
  696.                     swexpr = ep;
  697.                     tvar = makestmttempvar(tp_unsigned, name_TEMP);
  698.                     ep = makeexpr_var(tvar);
  699.                 }
  700.             }
  701.     sp->exp3 = makeexpr_assign(copyexpr(ep),
  702.        makeexpr_inc(copyexpr(ep),
  703.     copyexpr(forstep)));
  704.             wneedtok(TOK_DO);
  705.             forfixed = (fixedflag != forfixed);
  706.             mp = makestmttempvar(ep->val.type, name_FOR);
  707.             sp->stm1 = p_stmt(NULL, SF_SAVESER);
  708.             if (tvar) {
  709.                 if (checkexprchanged(sp->stm1, swexpr))
  710.                     note(format_s("Rewritten FOR loop won't work if it meddles with %s [253]",
  711.                                   ((Meaning *)swexpr->val.i)->name));
  712.                 sp->stm1 = makestmt_seq(makestmt_assign(swexpr, makeexpr_var(tvar)),
  713.                                         sp->stm1);
  714.             } else if (offsetforloops && ep->kind == EK_VAR) {
  715. offset = checkvaroffset(sp->stm1, (Meaning *)ep->val.i);
  716. if (offset != 0) {
  717.     ep3 = makeexpr_inc(copyexpr(ep), makeexpr_long(-offset));
  718.     replaceexpr(sp->stm1, ep, ep3);
  719.     freeexpr(ep3);
  720.     ep2 = makeexpr_plus(ep2, makeexpr_long(offset));
  721.     sp->exp2 = makeexpr_inc(sp->exp2, makeexpr_long(offset));
  722. }
  723.     }
  724.             if (!exprsame(ep, ep2, 1))
  725.                 sp->exp1 = makeexpr_assign(copyexpr(ep), copyexpr(ep2));
  726.     isunsafe = ((!nodependencies(ep2, 2) &&
  727.  !nosideeffects(sp->exp2, 1)) ||
  728. (!nodependencies(sp->exp2, 2) &&
  729.  !nosideeffects(ep2, 1)));
  730.             if (forfixed || (simplefor(sp, ep) && !isunsafe)) {
  731.                 canceltempvar(mp);
  732.                 sp->exp2 = makeexpr_rel(ekind, ep, sp->exp2);
  733.             } else {
  734. ep3 = makeexpr_neg(copyexpr(forstep));
  735. if ((checkconst(forstep, 1) || checkconst(forstep, -1)) &&
  736.     sp->exp2->kind == EK_PLUS &&
  737.     exprsame(sp->exp2->args[sp->exp2->nargs-1], ep3, 2)) {
  738.     sp->exp2 = makeexpr_inc(sp->exp2, forstep);
  739. } else {
  740.     freeexpr(forstep);
  741.     freeexpr(ep3);
  742.     ep3 = makeexpr_long(0);
  743. }
  744. if (forevalorder && isunsafe) {
  745.     if (exprdepends(sp->exp2, ep)) {
  746. tvar = makestmttempvar(mp->type, name_TEMP);
  747. sp->exp1 = makeexpr_comma(
  748.      makeexpr_comma(
  749.        makeexpr_assign(makeexpr_var(tvar),
  750.        copyexpr(ep2)),
  751.        makeexpr_assign(makeexpr_var(mp),
  752.        sp->exp2)),
  753.      makeexpr_assign(copyexpr(ep),
  754.      makeexpr_var(tvar)));
  755.     } else
  756. sp->exp1 = makeexpr_comma(
  757.      sp->exp1,
  758.      makeexpr_assign(makeexpr_var(mp),
  759.      sp->exp2));
  760. } else {
  761.     if (isunsafe)
  762. note("Evaluating FOR loop limit before initial value [315]");
  763.     sp->exp1 = makeexpr_comma(
  764.          makeexpr_assign(makeexpr_var(mp),
  765.  sp->exp2),
  766.          sp->exp1);
  767. }
  768. sp->exp2 = makeexpr_inc(makeexpr_var(mp), ep3);
  769.                 sp->exp2 = makeexpr_rel(ekind, ep, sp->exp2);
  770.             }
  771.     freeexpr(ep2);
  772.             break;
  774.         case TOK_GOTO:
  775.             gettok();
  776.             if (findlabelsym()) {
  777.                 if (curtokmeaning->ctx != curctx) {
  778.     curtokmeaning->val.i = 1;
  779.     *spp = close_files_to_ctx(curtokmeaning->ctx);
  780.     while (*spp)
  781. spp = &((*spp)->next);
  782.     newstmt(SK_ASSIGN);
  783.     var_reference(curtokmeaning->xnext);
  784.     if (curtokmeaning->ctx->kind == MK_MODULE &&
  785. !curtokmeaning->xnext->wasdeclared) {
  786. outsection(minorspace);
  787. declarevar(curtokmeaning->xnext, 0x7);
  788. curtokmeaning->xnext->wasdeclared = 1;
  789. outsection(minorspace);
  790.     }
  791.     sp->exp1 = makeexpr_bicall_2("longjmp", tp_void,
  792.  makeexpr_var(curtokmeaning->xnext),
  793.  makeexpr_long(1));
  794. } else {
  795.     newstmt(SK_GOTO);
  796.     sp->exp1 = makeexpr_name(format_s(name_LABEL,
  797.       curtokmeaning->name),
  798.      tp_integer);
  799. }
  800.             } else {
  801.                 warning("Expected a label [263]");
  802.     }
  803.     gettok();
  804.             break;
  806.         case TOK_IF:
  807.             gettok();
  808.             newstmt(SK_IF);
  809.     saveserial = curserial;
  810.     curserial = ++serialcount;
  811.             sp->exp1 = p_expr(tp_boolean);
  812.             wneedtok(TOK_THEN);
  813.             sp->stm1 = p_stmt(NULL, SF_SAVESER|SF_IF);
  814.     changecomments(curcomments, -1, saveserial+1, -1, saveserial);
  815.     checkkeyword(TOK_ELSIF);
  816.     while (curtok == TOK_ELSIF) {
  817. gettok();
  818. sp->stm2 = makestmt(SK_IF);
  819. sp = sp->stm2;
  820. sp->exp1 = p_expr(tp_boolean);
  821. wneedtok(TOK_THEN);
  822. sp->stm1 = p_stmt(NULL, SF_SAVESER|SF_IF);
  823. sp->exp2 = makeexpr_long(1);
  824.     }
  825.     if (curtok == TOK_ELSE) {
  826.                 line1 = inf_lnum;
  827. strlist_mix(&curcomments, grabcomment(CMT_ONELSE));
  828.                 gettok();
  829.                 line2 = (curtok == TOK_IF) ? inf_lnum : -1;
  830. saveserial2 = curserial;
  831.                 sp->stm2 = p_stmt(NULL, SF_SAVESER|SF_IF);
  832. changecomments(curcomments, -1, saveserial2, -1, saveserial+1);
  833.                 if (sp->stm2 && sp->stm2->kind == SK_IF &&
  834.     !sp->stm2->next && !modula2) {
  835.                     sp->stm2->exp2 = makeexpr_long(elseif > 0 ||
  836.                                                    (elseif < 0 && line1 == line2));
  837.                 }
  838.             }
  839.     if (modula2)
  840. wneedtok(TOK_END);
  841.     curserial = saveserial;
  842.             break;
  844.         case TOK_INLINE:
  845.             gettok();
  846.             note("Inline assembly language encountered [254]");
  847.             if (curtok != TOK_LPAR) {   /* Macintosh style */
  848. newstmt(SK_ASSIGN);
  849. sp->exp1 = makeexpr_bicall_1("inline", tp_void,
  850.      p_expr(tp_integer));
  851. break;
  852.     }
  853.             do {
  854.                 name = getinlinepart();
  855.                 if (!*name)
  856.                     break;
  857.                 newstmt(SK_ASSIGN);
  858.                 sp->exp1 = makeexpr_bicall_1("asm", tp_void,
  859.                             makeexpr_string(format_s(" inline %s", name)));
  860.                 gettok();
  861.             } while (curtok == TOK_SLASH);
  862.             skipcloseparen();
  863.             break;
  865. case TOK_LOOP:
  866.     gettok();
  867.     newstmt(SK_WHILE);
  868.     sp->exp1 = makeexpr_long(1);
  869.             sp->stm1 = p_stmt(NULL, SF_SAVESER);
  870.     break;
  872.         case TOK_REPEAT:
  873.             newstmt(SK_REPEAT);
  874.     saveserial = curserial;
  875.             spp2 = &(sp->stm1);
  876.     i = SF_FIRST;
  877.             do {
  878.                 gettok();
  879.                 *spp2 = p_stmt(sp->stm1, i);
  880. i = 0;
  881.                 while (*spp2)
  882.                     spp2 = &((*spp2)->next);
  883.             } while (curtok == TOK_SEMI);
  884.             if (!wneedtok(TOK_UNTIL))
  885. skippasttoken(TOK_UNTIL);
  886.             sp->exp1 = makeexpr_not(p_expr(tp_boolean));
  887.     curserial = saveserial;
  888.     strlist_mix(&curcomments, grabcomment(CMT_ONEND));
  889.             break;
  891. case TOK_RETURN:
  892.     gettok();
  893.     newstmt(SK_RETURN);
  894.     if (curctx->isfunction) {
  895. sp->exp1 = gentle_cast(p_expr(curctx->cbase->type),
  896.        curctx->cbase->type);
  897.     }
  898.     break;
  900.         case TOK_TRY:
  901.     findsymbol("RECOVER")->flags &= ~KWPOSS;
  902.             newstmt(SK_TRY);
  903.             sp->exp1 = makeexpr_long(++trycount);
  904.             spp2 = &(sp->stm1);
  905.     i = SF_FIRST;
  906.             do {
  907.                 gettok();
  908.                 *spp2 = p_stmt(sp->stm1, i);
  909. i = 0;
  910.                 while (*spp2)
  911.                     spp2 = &((*spp2)->next);
  912.             } while (curtok == TOK_SEMI);
  913.             if (!wneedtok(TOK_RECOVER))
  914. skippasttoken(TOK_RECOVER);
  915.             sp->stm2 = p_stmt(NULL, SF_SAVESER);
  916.             break;
  918.         case TOK_WHILE:
  919.             gettok();
  920.             newstmt(SK_WHILE);
  921.             sp->exp1 = p_expr(tp_boolean);
  922.             wneedtok(TOK_DO);
  923.             sp->stm1 = p_stmt(NULL, SF_SAVESER);
  924.             break;
  926.         case TOK_WITH:
  927.             gettok();
  928.             if (withlevel >= MAXWITHS-1)
  929.                 error("Too many nested WITHs");
  930.             ep = p_expr(NULL);
  931.             if (ep->val.type->kind != TK_RECORD)
  932.                 warning("Argument of WITH is not a RECORD [264]");
  933.             withlist[withlevel] = ep->val.type;
  934.             if (simplewith(ep)) {
  935.                 withexprs[withlevel] = ep;
  936.                 mp = NULL;
  937.             } else {           /* need to save a temporary pointer */
  938.                 tp = makepointertype(ep->val.type);
  939.                 mp = makestmttempvar(tp, name_WITH);
  940.                 withexprs[withlevel] = makeexpr_hat(makeexpr_var(mp), 0);
  941.             }
  942.             withlevel++;
  943.             if (curtok == TOK_COMMA) {
  944.                 curtok = TOK_WITH;
  945.                 sp2 = p_stmt(NULL, sflags & SF_FIRST);
  946.             } else {
  947.                 wneedtok(TOK_DO);
  948.                 sp2 = p_stmt(NULL, sflags & SF_FIRST);
  949.             }
  950.             withlevel--;
  951.             if (mp) {    /* if "with p^" for constant p, don't need temp ptr */
  952.                 if (ep->kind == EK_HAT && ep->args[0]->kind == EK_VAR &&
  953.                     !checkvarchanged(sp2, (Meaning *)ep->args[0]->val.i)) {
  954.                     replaceexpr(sp2, withexprs[withlevel]->args[0],
  955.                                      ep->args[0]);
  956.                     freeexpr(ep);
  957.                     canceltempvar(mp);
  958.                 } else {
  959.                     newstmt(SK_ASSIGN);
  960.                     sp->exp1 = makeexpr_assign(makeexpr_var(mp),
  961.                                                makeexpr_addr(ep));
  962.                 }
  963.             }
  964.             freeexpr(withexprs[withlevel]);
  965.             *spp = sp2;
  966.             while (*spp)
  967.                 spp = &((*spp)->next);
  968.             break;
  970.         case TOK_INCLUDE:
  971.             badinclude();
  972.             goto again;
  974. case TOK_ADDR:   /* flakey Turbo "@procptr := anyptr" assignment */
  975.     newstmt(SK_ASSIGN);
  976.     ep = p_expr(tp_void);
  977.     if (wneedtok(TOK_ASSIGN))
  978. sp->exp1 = makeexpr_assign(ep, p_expr(ep->val.type));
  979.     else
  980. sp->exp1 = ep;
  981.     break;
  983.         case TOK_IDENT:
  984.             mp = curtokmeaning;
  985.     if (mp == mp_str_hp)
  986. mp = curtokmeaning = mp_str_turbo;
  987.     if (mp == mp_val_modula)
  988. mp = curtokmeaning = mp_val_turbo;
  989.     if (mp == mp_blockread_ucsd)
  990. mp = curtokmeaning = mp_blockread_turbo;
  991.     if (mp == mp_blockwrite_ucsd)
  992. mp = curtokmeaning = mp_blockwrite_turbo;
  993.     if (mp == mp_dec_dec)
  994. mp = curtokmeaning = mp_dec_turbo;
  995.             if (!mp) {
  996.                 sym = curtoksym;     /* make a guess at what the undefined name is... */
  997.                 name = stralloc(curtokcase);
  998.                 gettok();
  999.                 newstmt(SK_ASSIGN);
  1000.                 if (curtok == TOK_ASSIGN) {
  1001.                     gettok();
  1002.                     ep = p_expr(NULL);
  1003.                     mp = addmeaning(sym, MK_VAR);
  1004.                     mp->name = name;
  1005.                     mp->type = ep->val.type;
  1006.                     sp->exp1 = makeexpr_assign(makeexpr_var(mp), ep);
  1007.                 } else if (curtok == TOK_HAT || curtok == TOK_ADDR ||
  1008.                            curtok == TOK_LBR || curtok == TOK_DOT) {
  1009.                     ep = makeexpr_name(name, tp_integer);
  1010.                     ep = fake_dots_n_hats(ep);
  1011.                     if (wneedtok(TOK_ASSIGN))
  1012. sp->exp1 = makeexpr_assign(ep, p_expr(NULL));
  1013.     else
  1014. sp->exp1 = ep;
  1015.                 } else if (curtok == TOK_LPAR) {
  1016.                     ep = makeexpr_bicall_0(name, tp_void);
  1017.                     do {
  1018.                         gettok();
  1019.                         insertarg(&ep, ep->nargs, p_expr(NULL));
  1020.                     } while (curtok == TOK_COMMA);
  1021.                     skipcloseparen();
  1022.                     sp->exp1 = ep;
  1023.                 } else {
  1024.                     sp->exp1 = makeexpr_bicall_0(name, tp_void);
  1025.                 }
  1026. if (!tryfuncmacro(&sp->exp1, NULL))
  1027.     undefsym(sym);
  1028.             } else if (mp->kind == MK_FUNCTION && !mp->isfunction) {
  1029.                 mp->refcount++;
  1030.                 gettok();
  1031.                 ep = p_funccall(mp);
  1032.                 if (!mp->constdefn)
  1033.                     need_forward_decl(mp);
  1034.                 if (mp->handler && !(mp->sym->flags & LEAVEALONE) &&
  1035.                                    !mp->constdefn) {
  1036.                     prochandler = (Stmt *(*)())mp->handler;
  1037.                     *spp = (*prochandler)(ep, slist);
  1038.                     while (*spp)
  1039.                         spp = &((*spp)->next);
  1040.                 } else {
  1041.                     newstmt(SK_ASSIGN);
  1042.                     sp->exp1 = ep;
  1043.                 }
  1044.             } else if (mp->kind == MK_SPECIAL) {
  1045.                 gettok();
  1046.                 if (mp->handler && !mp->isfunction) {
  1047.                     if ((mp->sym->flags & LEAVEALONE) || mp->constdefn) {
  1048.                         ep = makeexpr_bicall_0(mp->name, tp_void);
  1049.                         if (curtok == TOK_LPAR) {
  1050.                             do {
  1051.                                 gettok();
  1052.                                 insertarg(&ep, ep->nargs, p_expr(NULL));
  1053.                             } while (curtok == TOK_COMMA);
  1054.                             skipcloseparen();
  1055.                         }
  1056.                         newstmt(SK_ASSIGN);
  1057. tryfuncmacro(&ep, mp);
  1058. sp->exp1 = ep;
  1059.                     } else {
  1060.                         prochandler = (Stmt *(*)())mp->handler;
  1061.                         *spp = (*prochandler)(mp, slist);
  1062.                         while (*spp)
  1063.                             spp = &((*spp)->next);
  1064.                     }
  1065.                 } else
  1066.                     symclass(curtoksym);
  1067.             } else {
  1068.                 newstmt(SK_ASSIGN);
  1069.                 if (curtokmeaning->kind == MK_FUNCTION &&
  1070.     peeknextchar() != '(') {
  1071.                     mp = curctx;
  1072.                     while (mp && mp != curtokmeaning)
  1073.                         mp = mp->ctx;
  1074.                     if (mp)
  1075.                         curtokmeaning = curtokmeaning->cbase;
  1076.                 }
  1077.                 ep = p_expr(tp_void);
  1078. #if 0
  1079. if (!(ep->kind == EK_SPCALL ||
  1080.       (ep->kind == EK_COND &&
  1081.        ep->args[1]->kind == EK_SPCALL)))
  1082.     wexpecttok(TOK_ASSIGN);
  1083. #endif
  1084. if (curtok == TOK_ASSIGN) {
  1085.     gettok();
  1086.     if (curtok == TOK_IDENT && !strcicmp(curtokbuf, "ZERO") &&
  1087. !curtokmeaning) {   /* VAX Pascal foolishness */
  1088. gettok();
  1089. ep2 = makeexpr_sizeof(copyexpr(ep), 0);
  1090. sp->exp1 = makeexpr_bicall_3("memset", tp_void,
  1091.      makeexpr_addr(ep),
  1092.      makeexpr_long(0), ep2);
  1093.     } else
  1094. sp->exp1 = makeexpr_assign(ep, p_expr(ep->val.type));
  1095. } else
  1096.     sp->exp1 = ep;
  1097.             }
  1098.             break;
  1100. default:
  1101.     break;    /* null statement */
  1102.     }
  1103.     freestmttemps(tempmark);
  1104.     if (sflags & SF_SAVESER)
  1105. curserial = firstserial;
  1106.     return sbase;
  1107. }
  1115. #define BR_NEVER        0x1     /* never use braces */
  1116. #define BR_FUNCTION     0x2     /* function body */
  1117. #define BR_THENPART     0x4     /* before an "else" */
  1118. #define BR_ALWAYS       0x8     /* always use braces */
  1119. #define BR_REPEAT       0x10    /* "do-while" loop */
  1120. #define BR_TRY          0x20    /* in a recover block */
  1121. #define BR_ELSEPART     0x40    /* after an "else" */
  1122. #define BR_CASE         0x80    /* case of a switch stmt */
  1124. Static int usebraces(sp, opts)
  1125. Stmt *sp;
  1126. int opts;
  1127. {
  1128.     if (opts & (BR_FUNCTION|BR_ALWAYS))
  1129.         return 1;
  1130.     if (opts & BR_NEVER)
  1131.         return 0;
  1132.     switch (bracesalways) {
  1133.         case 0:
  1134.             if (sp) {
  1135.                 if (sp->next ||
  1136.                     sp->kind == SK_TRY ||
  1137.                     (sp->kind == SK_IF && !sp->stm2) ||
  1138.                     (opts & BR_REPEAT))
  1139.                     return 1;
  1140.             }
  1141.             break;
  1143.         case 1:
  1144.             return 1;
  1145.             break;
  1147.         default:
  1148.             if (sp) {
  1149.                 if (sp->next ||
  1150.                     sp->kind == SK_IF ||
  1151.                     sp->kind == SK_WHILE ||
  1152.                     sp->kind == SK_REPEAT ||
  1153.                     sp->kind == SK_TRY ||
  1154.     sp->kind == SK_CASE ||
  1155.                     sp->kind == SK_FOR)
  1156.                     return 1;
  1157.             }
  1158.             break;
  1159.     }
  1160.     if (sp != NULL &&
  1161. findcomment(curcomments, CMT_NOT | CMT_TRAIL, sp->serial) != NULL)
  1162. return 1;
  1163.     return 0;
  1164. }
  1168. #define outspnl(spflag) output((spflag) ? " " : "n")
  1170. #define openbrace()                 
  1171.     wbraces = (!candeclare);        
  1172.     if (wbraces) {                  
  1173.         output("{");                
  1174.         outspnl(braceline <= 0);    
  1175.         candeclare = 1;             
  1176.     }
  1178. #define closebrace()                
  1179.     if (wbraces) {                  
  1180.         if (sp->next || braces)     
  1181.             output("}n");          
  1182.         else                        
  1183.             braces = 1;             
  1184.     }
  1188. Meaning *outcontext;
  1190. Static void outnl(serial)
  1191. int serial;
  1192. {
  1193.     outtrailcomment(curcomments, serial, commentindent);
  1194. }
  1197. Static void out_block(spbase, opts, serial)
  1198. Stmt *spbase;
  1199. int opts, serial;
  1200. {
  1201.     int i, j, braces, always, trynum, istrail, hascmt;
  1202.     int gotcomments = 0;
  1203.     int saveindent, saveindent2, delta;
  1204.     Stmt *sp = spbase;
  1205.     Stmt *sp2, *sp3;
  1206.     Meaning *ctx, *mp;
  1207.     Strlist *curcmt, *cmt, *savecurcmt = curcomments;
  1208.     Strlist *trailcmt, *begincmt, *endcmt;
  1210.     if (debug>1) { fprintf(outf, "out_block of:n"); dumpstmt(spbase,5); }
  1211.     if (opts & BR_FUNCTION) {
  1212. if (outcontext && outcontext->comments) {
  1213.     gotcomments = 1;
  1214.     curcomments = outcontext->comments;
  1215. }
  1216. attach_comments(spbase);
  1217.     }
  1218.     braces = usebraces(sp, opts);
  1219.     trailcmt = findcomment(curcomments, CMT_TRAIL, serial);
  1220.     begincmt = findcomment(curcomments, CMT_ONBEGIN, serial);
  1221.     istrail = 1;
  1222.     if (!trailcmt) {
  1223. trailcmt = begincmt;
  1224. begincmt = NULL;
  1225. istrail = 0;
  1226.     }
  1227.     endcmt = findcomment(curcomments, CMT_ONEND, serial);
  1228.     if ((begincmt || endcmt) && !(opts & BR_NEVER))
  1229. braces = 1;
  1230.     if (opts & BR_ELSEPART) {
  1231. cmt = findcomment(curcomments, CMT_ONELSE, serial);
  1232. if (cmt) {
  1233.     if (trailcmt) {
  1234. out_spaces(bracecommentindent, commentoverindent,
  1235.    commentlen(cmt), 0);
  1236. output("01");
  1237. outcomment(cmt);
  1238.     } else
  1239. trailcmt = cmt;
  1240. }
  1241.     }
  1242.     if (braces) {
  1243. j = (opts & BR_FUNCTION) ? funcopenindent : openbraceindent;
  1244.         if (!line_start()) {
  1245.     if (trailcmt &&
  1246. cur_column() + commentlen(trailcmt) + 2 > linewidth &&
  1247. outindent + commentlen(trailcmt) + 2 < linewidth)  /*close enough*/
  1248. i = 0;
  1249.     else if (opts & BR_ELSEPART)
  1250. i = ((braceelseline & 2) == 0);
  1251.     else if (braceline >= 0)
  1252. i = (braceline == 0);
  1253.     else
  1254.                 i = ((opts & BR_FUNCTION) == 0);
  1255.     if (trailcmt && begincmt) {
  1256. out_spaces(commentindent, commentoverindent,
  1257.    commentlen(trailcmt), j);
  1258. outcomment(trailcmt);
  1259. trailcmt = begincmt;
  1260. begincmt = NULL;
  1261. istrail = 0;
  1262.     } else
  1263. outspnl(i);
  1264.         }
  1265. if (line_start())
  1266.     singleindent(j);
  1267.         output("{");
  1268.         candeclare = 1;
  1269.     } else if (!sp) {
  1270.         if (!line_start())
  1271.             outspnl(!nullstmtline && !(opts & BR_TRY));
  1272. if (line_start())
  1273.     singleindent(tabsize);
  1274.         output(";");
  1275.     }
  1276.     if (opts & BR_CASE)
  1277. delta = 0;
  1278.     else {
  1279. delta = tabsize;
  1280. if (opts & BR_FUNCTION)
  1281.     delta = adddeltas(delta, bodyindent);
  1282. else if (braces)
  1283.     delta = adddeltas(delta, blockindent);
  1284.     }
  1285.     futureindent(delta);
  1286.     if (bracecombine && braces)
  1287. i = applydelta(outindent, delta) - cur_column();
  1288.     else
  1289. i = -1;
  1290.     if (commentvisible(trailcmt)) {
  1291. if (line_start()) {
  1292.     singleindent(delta);
  1293.     out_spaces(commentoverindent, 1000, commentlen(trailcmt), 0);
  1294.     outcomment(trailcmt);
  1295. } else /*if (commentlen(trailcmt) + cur_column() + 1 <= linewidth)*/ {
  1296.     out_spaces(istrail ? commentindent : bracecommentindent,
  1297.        commentoverindent, commentlen(trailcmt), delta);
  1298.     outcomment(trailcmt);
  1299. } /*else {
  1300.     output("n");
  1301.     singleindent(delta);
  1302.     out_spaces(commentoverindent, 1000, commentlen(trailcmt), 0);
  1303.     outcomment(trailcmt);
  1304. }*/
  1305. i = -9999;
  1306.     }
  1307.     if (i > 0)
  1308. out_spaces(i, 0, 0, 0);
  1309.     else if (i != -9999)
  1310. output("n");
  1311.     saveindent = outindent;
  1312.     moreindent(delta);
  1313.     outcomment(begincmt);
  1314.     while (sp) {
  1315. flushcomments(NULL, CMT_PRE, sp->serial);
  1316. if (cmtdebug)
  1317.     output(format_d("[%d] ", sp->serial));
  1318.         switch (sp->kind) {
  1320.             case SK_HEADER:
  1321.                 ctx = (Meaning *)sp->exp1->val.i;
  1322. eatblanklines();
  1323.                 if (declarevars(ctx, 0))
  1324.                     outsection(minorspace);
  1325. flushcomments(NULL, CMT_NOT | CMT_ONEND, serial);
  1326.                 if (ctx->kind == MK_MODULE) {
  1327.                     if (ctx->anyvarflag) {
  1328.                         output(format_s(name_MAIN, ""));
  1329.                         output("(argc, argv);n");
  1330.                     } else {
  1331.                         output("static int _was_initialized = 0;n");
  1332.                         output("if (_was_initialized++)n");
  1333. singleindent(tabsize);
  1334.                         output("return;n");
  1335.                     }
  1336.     while (initialcalls) {
  1337. output(initialcalls->s);
  1338. output(";n");
  1339. strlist_remove(&initialcalls, initialcalls->s);
  1340.     }
  1341.                 } else {
  1342.                     if (ctx->varstructflag && ctx->ctx->kind == MK_FUNCTION &&
  1343.                                               ctx->ctx->varstructflag) {
  1344.                         output(format_s(name_VARS, ctx->name));
  1345.                         output(".");
  1346.                         output(format_s(name_LINK, ctx->ctx->name));
  1347.                         output(" = ");
  1348.                         output(format_s(name_LINK, ctx->ctx->name));
  1349.                         output(";n");
  1350.                     }
  1351.                     for (mp = ctx->cbase; mp; mp = mp->cnext) {
  1352.                         if ((mp->kind == MK_VAR ||    /* these are variables with */
  1353.      mp->kind == MK_VARREF) &&
  1354.     mp->varstructflag &&      /* initializers which were moved */
  1355.     mp->cnext &&              /* into a varstruct, so they */
  1356.     mp->cnext->snext == mp && /* must be initialized now */
  1357.     mp->cnext->constdefn) {
  1358.                             if (mp->type->kind == TK_ARRAY) {
  1359.                                 output("memcpy(");
  1360.                                 out_var(mp, 2);
  1361.                                 output(", ");
  1362.                                 out_var(mp->cnext, 2);
  1363.                                 output(", sizeof(");
  1364.                                 out_type(mp->type, 1);
  1365.                                 output("))");
  1366.                             } else {
  1367.                                 out_var(mp, 2);
  1368.                                 output(" = ");
  1369.                                 out_var(mp->cnext, 2);
  1370.                             }
  1371.                             output(";n");
  1372.                         }
  1373.                     }
  1374.                 }
  1375.                 break;
  1377.             case SK_RETURN:
  1378.                 output("return");
  1379. if (sp->exp1) {
  1380.     switch (returnparens) {
  1382.       case 0:
  1383. output(" ");
  1384. out_expr(sp->exp1);
  1385. break;
  1387.       case 1:
  1388. if (spaceexprs != 0)
  1389.     output(" ");
  1390. out_expr_parens(sp->exp1);
  1391. break;
  1393.       default:
  1394. if (sp->exp1->kind == EK_VAR ||
  1395.     sp->exp1->kind == EK_CONST ||
  1396.     sp->exp1->kind == EK_LONGCONST ||
  1397.     sp->exp1->kind == EK_BICALL) {
  1398.     output(" ");
  1399.     out_expr(sp->exp1);
  1400. } else {
  1401.     if (spaceexprs != 0)
  1402. output(" ");
  1403.     out_expr_parens(sp->exp1);
  1404. }
  1405. break;
  1406.     }
  1407. }
  1408. output(";");
  1409. outnl(sp->serial);
  1410.                 break;
  1412.             case SK_ASSIGN:
  1413.                 out_expr_stmt(sp->exp1);
  1414.                 output(";");
  1415. outnl(sp->serial);
  1416.                 break;
  1418.             case SK_CASE:
  1419.                 output("switch (");
  1420.                 out_expr(sp->exp1);
  1421.                 output(")");
  1422.                 outspnl(braceline <= 0);
  1423.                 output("{");
  1424. outnl(sp->serial);
  1425. saveindent2 = outindent;
  1426. moreindent(tabsize);
  1427. moreindent(switchindent);
  1428.                 sp2 = sp->stm1;
  1429.                 while (sp2 && sp2->kind == SK_CASELABEL) {
  1430.                     outsection(casespacing);
  1431.                     sp3 = sp2;
  1432.     i = 0;
  1433.     hascmt = (findcomment(curcomments, -1, sp2->serial) != NULL);
  1434.     singleindent(caseindent);
  1435.     flushcomments(NULL, CMT_PRE, sp2->serial);
  1436.                     for (;;) {
  1437. if (i)
  1438.     singleindent(caseindent);
  1439. i = 0;
  1440.                         output("case ");
  1441.                         out_expr(sp3->exp1);
  1442.                         output(":01");
  1443.                         sp3 = sp3->stm1;
  1444.                         if (!sp3 || sp3->kind != SK_CASELABEL)
  1445.                             break;
  1446.                         if (casetabs != 1000)
  1447.                             out_spaces(casetabs, 0, 0, 0);
  1448.                         else {
  1449.                             output("n");
  1450.     i = 1;
  1451. }
  1452.                     }
  1453.                     if (sp3)
  1454.                         out_block(sp3, BR_NEVER|BR_CASE, sp2->serial);
  1455.                     else {
  1456. outnl(sp2->serial);
  1457. if (!hascmt)
  1458.     output("/* blank case */n");
  1459.     }
  1460.                     output("break;n");
  1461.     flushcomments(NULL, -1, sp2->serial);
  1462.                     sp2 = sp2->next;
  1463.                 }
  1464.                 if (sp2) {
  1465.                     outsection(casespacing);
  1466.     singleindent(caseindent);
  1467.     flushcomments(NULL, CMT_PRE, sp2->serial);
  1468.                     output("default:");
  1469.                     out_block(sp2, BR_NEVER|BR_CASE, sp2->serial);
  1470.                     output("break;n");
  1471.     flushcomments(NULL, -1, sp2->serial);
  1472.                 }
  1473.                 outindent = saveindent2;
  1474.                 output("}");
  1475. curcmt = findcomment(curcomments, CMT_ONEND, sp->serial);
  1476. if (curcmt)
  1477.     outcomment(curcmt);
  1478. else
  1479.     output("n");
  1480.                 break;
  1482.             case SK_CASECHECK:
  1483. output(name_CASECHECK);
  1484.                 output("();   /* CASE value range error */n");
  1485.                 break;
  1487.             case SK_FOR:
  1488.                 output("for (");
  1489. if (for_allornone)
  1490.     output("07");
  1491.                 if (sp->exp1 || sp->exp2 || sp->exp3 || spaceexprs > 0) {
  1492.                     if (sp->exp1)
  1493.                         out_expr_top(sp->exp1);
  1494.                     else if (spaceexprs > 0)
  1495.                         output(" ");
  1496.                     output(";02 ");
  1497.                     if (sp->exp2)
  1498.                         out_expr(sp->exp2);
  1499.                     output(";02 ");
  1500.                     if (sp->exp3)
  1501.                         out_expr_top(sp->exp3);
  1502.                 } else {
  1503.                     output(";;");
  1504.                 }
  1505.                 output(")");
  1506.                 out_block(sp->stm1, 0, sp->serial);
  1507.                 break;
  1509.             case SK_LABEL:
  1510.                 if (!line_start())
  1511.                     output("n");
  1512. singleindent(labelindent);
  1513.                 out_expr(sp->exp1);
  1514.                 output(":");
  1515.                 if (!sp->next)
  1516.                     output(" ;");
  1517.                 outnl(sp->serial);
  1518.                 break;
  1520.             case SK_GOTO:
  1521.                 /* what about non-local goto's? */
  1522.                 output("goto ");
  1523.                 out_expr(sp->exp1);
  1524.                 output(";");
  1525. outnl(sp->serial);
  1526.                 break;
  1528.             case SK_IF:
  1529.                 sp2 = sp;
  1530.                 for (;;) {
  1531.                     output("if (");
  1532.                     out_expr_bool(sp2->exp1);
  1533.                     output(")");
  1534.                     if (sp2->stm2) {
  1535. cmt = findcomment(curcomments, CMT_ONELSE, sp->serial+1);
  1536.                         i = (!cmt && sp2->stm2->kind == SK_IF &&
  1537.      !sp2->stm2->next &&
  1538.      ((sp2->stm2->exp2)
  1539.       ? checkconst(sp2->stm2->exp2, 1)
  1540.       : (elseif > 0)));
  1541. if (braceelse &&
  1542.                             (usebraces(sp2->stm1, 0) ||
  1543.                              usebraces(sp2->stm2, 0) || i))
  1544.                             always = BR_ALWAYS;
  1545.                         else
  1546.                             always = 0;
  1547.                         out_block(sp2->stm1, BR_THENPART|always, sp->serial);
  1548.                         output("else");
  1549.                         sp2 = sp2->stm2;
  1550.                         if (i) {
  1551.                             output(" ");
  1552.                         } else {
  1553.                             out_block(sp2, BR_ELSEPART|always, sp->serial+1);
  1554.                             break;
  1555.                         }
  1556.                     } else {
  1557.                         out_block(sp2->stm1, 0, sp->serial);
  1558.                         break;
  1559.                     }
  1560.                 }
  1561.                 break;
  1563.             case SK_REPEAT:
  1564.                 output("do");
  1565.                 out_block(sp->stm1, BR_ALWAYS|BR_REPEAT, sp->serial);
  1566.                 output("while (");
  1567.                 out_expr_bool(sp->exp1);
  1568.                 output(");");
  1569. cmt = findcomment(curcomments, CMT_ONEND, sp->serial);
  1570. if (commentvisible(cmt)) {
  1571.     out_spaces(commentindent, commentoverindent,
  1572.        commentlen(cmt), 0);
  1573.     output("01");
  1574.     outcomment(cmt);
  1575. } else
  1576.     output("n");
  1577.                 break;
  1579.             case SK_TRY:
  1580.                 trynum = sp->exp1->val.i;
  1581.                 output(format_d("TRY(try%d);", trynum));
  1582.                 out_block(sp->stm1, BR_NEVER|BR_TRY, sp->serial);
  1583.                 if (sp->exp2)
  1584.                     output(format_ds("RECOVER2(try%d,%s);", trynum,
  1585.                                      format_s(name_LABEL, format_d("try%d", trynum))));
  1586.                 else
  1587.                     output(format_d("RECOVER(try%d);", trynum));
  1588.                 out_block(sp->stm2, BR_NEVER|BR_TRY, sp->serial);
  1589.                 output(format_d("ENDTRY(try%d);n", trynum));
  1590.                 break;
  1592.             case SK_WHILE:
  1593.                 output("while (");
  1594.                 out_expr_bool(sp->exp1);
  1595.                 output(")");
  1596.                 out_block(sp->stm1, 0, sp->serial);
  1597.                 break;
  1599.             case SK_BREAK:
  1600.                 output("break;");
  1601. outnl(sp->serial);
  1602.                 break;
  1604.             case SK_CONTINUE:
  1605.                 output("continue;");
  1606. outnl(sp->serial);
  1607.                 break;
  1609.     default:
  1610.         intwarning("out_block",
  1611.    format_s("Misplaced statement kind %s [265]",
  1612.     stmtkindname(sp->kind)));
  1613. break;
  1614.         }
  1615. flushcomments(NULL, -1, sp->serial);
  1616.         candeclare = 0;
  1617.         if (debug>1) { fprintf(outf, "in out_block:n"); dumpstmt(spbase,5); }
  1618.         sp = sp->next;
  1619.     }
  1620.     if (opts & BR_FUNCTION) {
  1621. cmt = extractcomment(&curcomments, CMT_ONEND, serial);
  1622. if (findcomment(curcomments, -1, -1) != NULL)  /* check for non-DONE */
  1623.     output("n");
  1624. flushcomments(NULL, -1, -1);
  1625. curcomments = cmt;
  1626.     }
  1627.     outindent = saveindent;
  1628.     if (braces) {
  1629. if (line_start()) {
  1630.     if (opts & BR_FUNCTION)
  1631. singleindent(funccloseindent);
  1632.     else
  1633. singleindent(closebraceindent);
  1634. }
  1635.         output("}");
  1636. i = 1;
  1637. cmt = findcomment(curcomments, CMT_ONEND, serial);
  1638. if (!(opts & BR_REPEAT) && commentvisible(cmt)) {
  1639.     out_spaces(bracecommentindent, commentoverindent,
  1640.        commentlen(cmt), 0);
  1641.     output("01");
  1642.     outcomment(cmt);
  1643.     i = 0;
  1644. }
  1645. if (i) {
  1646.     outspnl((opts & BR_REPEAT) ||
  1647.     ((opts & BR_THENPART) && (braceelseline & 1) == 0));
  1648. }
  1649.         candeclare = 0;
  1650.     }
  1651.     if (gotcomments) {
  1652. outcontext->comments = curcomments;
  1653. curcomments = savecurcmt;
  1654.     }
  1655. }
  1661. /* Should have a way to convert GOTO's to the end of the function to RETURN's */
  1664. /* Convert "_RETV = foo;" at end of function to "return foo" */
  1666. Static int checkreturns(spp, nearret)
  1667. Stmt **spp;
  1668. int nearret;
  1669. {
  1670.     Stmt *sp;
  1671.     Expr *rvar, *ex;
  1672.     Meaning *mp;
  1673.     int spnearret, spnextreturn;
  1674.     int result = 0;
  1676.     if (debug>2) { fprintf(outf, "checkreturns on:n"); dumpstmt(*spp, 5); }
  1677.     while ((sp = *spp)) {
  1678.         spnextreturn = (sp->next &&
  1679.                         sp->next->kind == SK_RETURN && sp->next->exp1 &&
  1680.                         isretvar(sp->next->exp1) == curctx->cbase);
  1681.         spnearret = (nearret && !sp->next) || spnextreturn;
  1682.         result = 0;
  1683.         switch (sp->kind) {
  1685.             case SK_ASSIGN:
  1686.                 ex = sp->exp1;
  1687.                 if (ex->kind == EK_ASSIGN || structuredfunc(ex)) {
  1688.                     rvar = ex->args[0];
  1689.                     mp = isretvar(rvar);
  1690.                     if (mp == curctx->cbase && spnearret) {
  1691.                         if (ex->kind == EK_ASSIGN) {
  1692.                             if (mp->kind == MK_VARPARAM) {
  1693.                                 ex = makeexpr_comma(ex, makeexpr_var(mp));
  1694.                             } else {
  1695.                                 ex = grabarg(ex, 1);
  1696.                                 mp->refcount--;
  1697.                             }
  1698.                         }
  1699.                         sp->exp1 = ex;
  1700.                         sp->kind = SK_RETURN;