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

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

编译器/解释器

开发平台：

C/C++

pexpr.c.2：源码内容
  1.                     ex = makeexpr_var(tvar);
  2.                 } else
  3.                     ex3 = NULL;
  4.                 ex4 = copyexpr(ex);
  5.                 if (ex->kind == EK_CONST && smallsetconst)
  6.                     ex = makesmallsetconst(1<<ex->val.i, ex2->val.type);
  7.                 else
  8.                     ex = makeexpr_bin(EK_LSH, ex2->val.type,
  9.                                       makeexpr_longcast(makeexpr_long(1), 1),
  10.                                       enum_to_int(ex));
  11.                 ex = makeexpr_rel(EK_NE, makeexpr_bin(EK_BAND, tp_integer, ex, ex2),
  12.                                          makeexpr_long(0));
  13.                 if (*name_SETBITS ||
  14.                     ((ex4->kind == EK_CONST) ? ((unsigned long)ex4->val.i >= setbits)
  15.                                              : !(0 <= smin && smax < setbits))) {
  16.                     ex = makeexpr_and(makeexpr_range(enum_to_int(ex4),
  17.                                                      makeexpr_long(0),
  18.                                                      makeexpr_setbits(), 0),
  19.                                       ex);
  20.                 } else
  21.                     freeexpr(ex4);
  22.                 ex = makeexpr_comma(ex3, ex);
  23.                 return ex;
  24.             } else {
  25.                 ex3 = ex2;
  26.                 while (ex3->kind == EK_BICALL &&
  27.                        (!strcmp(ex3->val.s, setaddname) ||
  28.                         !strcmp(ex3->val.s, setaddrangename)))
  29.                     ex3 = ex3->args[0];
  30.                 if (ex3->kind == EK_BICALL && !strcmp(ex3->val.s, setexpandname) &&
  31.                     (tvar = istempvar(ex3->args[0])) != NULL && 
  32.                     isconstexpr(ex3->args[1], &mask)) {
  33.                     canceltempvar(tvar);
  34.                     if (!nosideeffects(ex, 0)) {
  35.                         tvar = makestmttempvar(ex->val.type, name_TEMP);
  36.                         ex3 = makeexpr_assign(makeexpr_var(tvar), ex);
  37.                         ex = makeexpr_var(tvar);
  38.                     } else
  39.                         ex3 = NULL;
  40.                     type = ord_type(ex2->val.type->indextype);
  41.                     ex4 = NULL;
  42.                     i = 0;
  43.                     while (i < setbits) {
  44.                         if (mask & (1<<i++)) {
  45.                             if (i+1 < setbits && (mask & (2<<i))) {
  46.                                 for (j = i; j < setbits && (mask & (1<<j)); j++) ;
  47.                                 ex4 = makeexpr_or(ex4,
  48.                                         makeexpr_range(copyexpr(ex),
  49.                                                        makeexpr_val(make_ord(type, i-1)),
  50.                                                        makeexpr_val(make_ord(type, j-1)), 1));
  51.                                 i = j;
  52.                             } else {
  53.                                 ex4 = makeexpr_or(ex4,
  54.                                         makeexpr_rel(EK_EQ, copyexpr(ex),
  55.                                                             makeexpr_val(make_ord(type, i-1))));
  56.                             }
  57.                         }
  58.                     }
  59.                     mask = 0;
  60.                     for (;;) {
  61.                         if (!strcmp(ex2->val.s, setaddrangename)) {
  62.                             if (checkconst(ex2->args[1], 'a') &&
  63.                                 checkconst(ex2->args[2], 'z')) {
  64.                                 mask |= 0x1;
  65.                             } else if (checkconst(ex2->args[1], 'A') &&
  66.                                        checkconst(ex2->args[2], 'Z')) {
  67.                                 mask |= 0x2;
  68.                             } else if (checkconst(ex2->args[1], '0') &&
  69.                                        checkconst(ex2->args[2], '9')) {
  70.                                 mask |= 0x4;
  71.                             } else {
  72.                                 ex4 = makeexpr_or(ex4,
  73.                                         makeexpr_range(copyexpr(ex), ex2->args[1], ex2->args[2], 1));
  74.                             }
  75.                         } else if (!strcmp(ex2->val.s, setaddname)) {
  76.                             ex4 = makeexpr_or(ex4,
  77.                                     makeexpr_rel(EK_EQ, copyexpr(ex), ex2->args[1]));
  78.                         } else
  79.                             break;
  80.                         ex2 = ex2->args[0];
  81.                     }
  82.                     /* do these now so that EK_OR optimizations will work: */
  83.                     if (mask & 0x1)
  84.                         ex4 = makeexpr_or(ex4, makeexpr_range(copyexpr(ex),
  85.                                                               makeexpr_char('a'),
  86.                                                               makeexpr_char('z'), 1));
  87.                     if (mask & 0x2)
  88.                         ex4 = makeexpr_or(ex4, makeexpr_range(copyexpr(ex),
  89.                                                               makeexpr_char('A'),
  90.                                                               makeexpr_char('Z'), 1));
  91.                     if (mask & 0x4)
  92.                         ex4 = makeexpr_or(ex4, makeexpr_range(copyexpr(ex),
  93.                                                               makeexpr_char('0'),
  94.                                                               makeexpr_char('9'), 1));
  95.                     freeexpr(ex);
  96.                     return makeexpr_comma(ex3, ex4);
  97.                 }
  98.                 return makeexpr_bicall_2(setinname, tp_boolean,
  99.                                          makeexpr_arglong(ex, 0), ex2);
  100.             }
  102. default:
  103.     return ex;
  104.     }
  105. }
  113. /* Parse a C expression; used by VarMacro, etc. */
  115. Type *nametotype(name)
  116. char *name;
  117. {
  118.     if (!strcicmp(name, "malloc") ||
  119. !strcicmp(name, mallocname)) {
  120. return tp_anyptr;
  121.     }
  122.     return tp_integer;
  123. }
  126. int istypespec()
  127. {
  128.     switch (curtok) {
  130.         case TOK_CONST:
  131.             return 1;
  133.         case TOK_IDENT:
  134.             return !strcmp(curtokcase, "volatile") ||
  135.                    !strcmp(curtokcase, "void") ||
  136.                    !strcmp(curtokcase, "char") ||
  137.                    !strcmp(curtokcase, "short") ||
  138.                    !strcmp(curtokcase, "int") ||
  139.                    !strcmp(curtokcase, "long") ||
  140.                    !strcmp(curtokcase, "float") ||
  141.                    !strcmp(curtokcase, "double") ||
  142.                    !strcmp(curtokcase, "signed") ||
  143.                    !strcmp(curtokcase, "unsigned") ||
  144.                    !strcmp(curtokcase, "struct") ||
  145.                    !strcmp(curtokcase, "union") ||
  146.                    !strcmp(curtokcase, "class") ||
  147.                    !strcmp(curtokcase, "enum") ||
  148.                    !strcmp(curtokcase, "typedef") ||
  149.                    (curtokmeaning &&
  150.                     curtokmeaning->kind == MK_TYPE);
  152.         default:
  153.             return 0;
  154.     }
  155. }
  159. Expr *pc_parentype(cp)
  160. char *cp;
  161. {
  162.     Expr *ex;
  164.     if (curtok == TOK_IDENT &&
  165.          curtokmeaning &&
  166.          curtokmeaning->kind == MK_TYPE) {
  167.         ex = makeexpr_type(curtokmeaning->type);
  168.         gettok();
  169.         skipcloseparen();
  170.     } else if (curtok == TOK_IDENT && !strcmp(curtokcase, "typedef")) {
  171.         ex = makeexpr_name(getparenstr(inbufptr), tp_integer);
  172.         gettok();
  173.     } else {
  174.         ex = makeexpr_name(getparenstr(cp), tp_integer);
  175.         gettok();
  176.     }
  177.     return ex;
  178. }
  183. Expr *pc_expr2();
  185. Expr *pc_factor()
  186. {
  187.     Expr *ex;
  188.     char *cp;
  189.     Strlist *sl;
  190.     int i;
  192.     switch (curtok) {
  194.         case TOK_BANG:
  195.             gettok();
  196.             return makeexpr_not(pc_expr2(14));
  198.         case TOK_TWIDDLE:
  199.             gettok();
  200.             return makeexpr_un(EK_BNOT, tp_integer, pc_expr2(14));
  202.         case TOK_PLPL:
  203.             gettok();
  204.             ex = pc_expr2(14);
  205.             return makeexpr_assign(ex, makeexpr_plus(copyexpr(ex), makeexpr_long(1)));
  207.         case TOK_MIMI:
  208.             gettok();
  209.             ex = pc_expr2(14);
  210.             return makeexpr_assign(ex, makeexpr_minus(copyexpr(ex), makeexpr_long(1)));
  212.         case TOK_STAR:
  213.             gettok();
  214.             ex = pc_expr2(14);
  215.             if (ex->val.type->kind != TK_POINTER)
  216.                 ex->val.type = makepointertype(ex->val.type);
  217.             return makeexpr_hat(ex, 0);
  219.         case TOK_AMP:
  220.             gettok();
  221.             return makeexpr_addr(pc_expr2(14));
  223.         case TOK_PLUS:
  224.             gettok();
  225.             return pc_expr2(14);
  227.         case TOK_MINUS:
  228.             gettok();
  229.             return makeexpr_neg(pc_expr2(14));
  231.         case TOK_LPAR:
  232.             cp = inbufptr;
  233.             gettok();
  234.             if (istypespec()) {
  235.                 ex = pc_parentype(cp);
  236.                 return makeexpr_bin(EK_LITCAST, tp_integer, ex, pc_expr2(14));
  237.             }
  238.             ex = pc_expr();
  239.             skipcloseparen();
  240.             return ex;
  242.         case TOK_IDENT:
  243.             if (!strcmp(curtokcase, "sizeof")) {
  244.                 gettok();
  245.                 if (curtok != TOK_LPAR)
  246.                     return makeexpr_sizeof(pc_expr2(14), 1);
  247.                 cp = inbufptr;
  248.                 gettok();
  249.                 if (istypespec()) {
  250.                     ex = makeexpr_sizeof(pc_parentype(cp), 1);
  251.                 } else {
  252.                     ex = makeexpr_sizeof(pc_expr(), 1);
  253.                     skipcloseparen();
  254.                 }
  255.                 return ex;
  256.             }
  257.             if (curtoksym->flags & FMACREC) {
  258.                 ex = makeexpr(EK_MACARG, 0);
  259.                 ex->val.type = tp_integer;
  260.                 ex->val.i = 0;
  261.                 for (sl = funcmacroargs, i = 1; sl; sl = sl->next, i++) {
  262.                     if (sl->value == (long)curtoksym) {
  263.                         ex->val.i = i;
  264.                         break;
  265.                     }
  266.                 }
  267.             } else
  268.                 ex = makeexpr_name(curtokcase, nametotype(curtokcase));
  269.             gettok();
  270.             return ex;
  272.         case TOK_INTLIT:
  273.             ex = makeexpr_long(curtokint);
  274.             if (curtokbuf[strlen(curtokbuf)-1] == 'L')
  275.                 ex = makeexpr_longcast(ex, 1);
  276.             gettok();
  277.             return ex;
  279.         case TOK_HEXLIT:
  280.             ex = makeexpr_long(curtokint);
  281.             insertarg(&ex, 0, makeexpr_name("%#lx", tp_integer));
  282.             if (curtokbuf[strlen(curtokbuf)-1] == 'L')
  283.                 ex = makeexpr_longcast(ex, 1);
  284.             gettok();
  285.             return ex;
  287.         case TOK_OCTLIT:
  288.             ex = makeexpr_long(curtokint);
  289.             insertarg(&ex, 0, makeexpr_name("%#lo", tp_integer));
  290.             if (curtokbuf[strlen(curtokbuf)-1] == 'L')
  291.                 ex = makeexpr_longcast(ex, 1);
  292.             gettok();
  293.             return ex;
  295.         case TOK_REALLIT:
  296.             ex = makeexpr_real(curtokbuf);
  297.             gettok();
  298.             return ex;
  300.         case TOK_STRLIT:
  301.             ex = makeexpr_lstring(curtokbuf, curtokint);
  302.             gettok();
  303.             return ex;
  305.         case TOK_CHARLIT:
  306.             ex = makeexpr_char(curtokint);
  307.             gettok();
  308.             return ex;
  310.         default:
  311.     wexpected("a C expression");
  312.     return makeexpr_long(0);
  313.     }
  314. }
  319. #define pc_prec(pr)  if (prec > (pr)) return ex; gettok();
  321. Expr *pc_expr2(prec)
  322. int prec;
  323. {
  324.     Expr *ex, *ex2;
  325.     int i;
  327.     ex = pc_factor();
  328.     for (;;) {
  329.         switch (curtok) {
  331.             case TOK_COMMA:
  332.                 pc_prec(1);
  333.                 ex = makeexpr_comma(ex, pc_expr2(2));
  334.                 break;
  336.             case TOK_EQ:
  337.                 pc_prec(2);
  338.                 ex = makeexpr_assign(ex, pc_expr2(2));
  339.                 break;
  341.             case TOK_QM:
  342.                 pc_prec(3);
  343.                 ex2 = pc_expr();
  344.                 if (wneedtok(TOK_COLON))
  345.     ex = makeexpr_cond(ex, ex2, pc_expr2(3));
  346. else
  347.     ex = makeexpr_cond(ex, ex2, makeexpr_long(0));
  348.                 break;
  350.             case TOK_OROR:
  351.                 pc_prec(4);
  352.                 ex = makeexpr_or(ex, pc_expr2(5));
  353.                 break;
  355.             case TOK_ANDAND:
  356.                 pc_prec(5);
  357.                 ex = makeexpr_and(ex, pc_expr2(6));
  358.                 break;
  360.             case TOK_VBAR:
  361.                 pc_prec(6);
  362.                 ex = makeexpr_bin(EK_BOR, tp_integer, ex, pc_expr2(7));
  363.                 break;
  365.             case TOK_HAT:
  366.                 pc_prec(7);
  367.                 ex = makeexpr_bin(EK_BXOR, tp_integer, ex, pc_expr2(8));
  368.                 break;
  370.             case TOK_AMP:
  371.                 pc_prec(8);
  372.                 ex = makeexpr_bin(EK_BAND, tp_integer, ex, pc_expr2(9));
  373.                 break;
  375.             case TOK_EQEQ:
  376.                 pc_prec(9);
  377.                 ex = makeexpr_rel(EK_EQ, ex, pc_expr2(10));
  378.                 break;
  380.             case TOK_BANGEQ:
  381.                 pc_prec(9);
  382.                 ex = makeexpr_rel(EK_NE, ex, pc_expr2(10));
  383.                 break;
  385.             case TOK_LT:
  386.                 pc_prec(10);
  387.                 ex = makeexpr_rel(EK_LT, ex, pc_expr2(11));
  388.                 break;
  390.             case TOK_LE:
  391.                 pc_prec(10);
  392.                 ex = makeexpr_rel(EK_LE, ex, pc_expr2(11));
  393.                 break;
  395.             case TOK_GT:
  396.                 pc_prec(10);
  397.                 ex = makeexpr_rel(EK_GT, ex, pc_expr2(11));
  398.                 break;
  400.             case TOK_GE:
  401.                 pc_prec(10);
  402.                 ex = makeexpr_rel(EK_GE, ex, pc_expr2(11));
  403.                 break;
  405.             case TOK_LTLT:
  406.                 pc_prec(11);
  407.                 ex = makeexpr_bin(EK_LSH, tp_integer, ex, pc_expr2(12));
  408.                 break;
  410.             case TOK_GTGT:
  411.                 pc_prec(11);
  412.                 ex = makeexpr_bin(EK_RSH, tp_integer, ex, pc_expr2(12));
  413.                 break;
  415.             case TOK_PLUS:
  416.                 pc_prec(12);
  417.                 ex = makeexpr_plus(ex, pc_expr2(13));
  418.                 break;
  420.             case TOK_MINUS:
  421.                 pc_prec(12);
  422.                 ex = makeexpr_minus(ex, pc_expr2(13));
  423.                 break;
  425.             case TOK_STAR:
  426.                 pc_prec(13);
  427.                 ex = makeexpr_times(ex, pc_expr2(14));
  428.                 break;
  430.             case TOK_SLASH:
  431.                 pc_prec(13);
  432.                 ex = makeexpr_div(ex, pc_expr2(14));
  433.                 break;
  435.             case TOK_PERC:
  436.                 pc_prec(13);
  437.                 ex = makeexpr_mod(ex, pc_expr2(14));
  438.                 break;
  440.             case TOK_PLPL:
  441.                 pc_prec(15);
  442.                 ex = makeexpr_un(EK_POSTINC, tp_integer, ex);
  443.                 break;
  445.             case TOK_MIMI:
  446.                 pc_prec(15);
  447.                 ex = makeexpr_un(EK_POSTDEC, tp_integer, ex);
  448.                 break;
  450.             case TOK_LPAR:
  451.                 pc_prec(16);
  452.                 if (ex->kind == EK_NAME) {
  453.                     ex->kind = EK_BICALL;
  454.                 } else {
  455.                     ex = makeexpr_un(EK_SPCALL, tp_integer, ex);
  456.                 }
  457.                 while (curtok != TOK_RPAR) {
  458.                     insertarg(&ex, ex->nargs, pc_expr2(2));
  459.                     if (curtok != TOK_RPAR)
  460.                         if (!wneedtok(TOK_COMMA))
  461.     skiptotoken2(TOK_RPAR, TOK_SEMI);
  462.                 }
  463.                 gettok();
  464.                 break;
  466.             case TOK_LBR:
  467.                 pc_prec(16);
  468.                 ex = makeexpr_index(ex, pc_expr(), NULL);
  469.                 if (!wneedtok(TOK_RBR))
  470.     skippasttoken(TOK_RBR);
  471.                 break;
  473.             case TOK_ARROW:
  474.                 pc_prec(16);
  475.                 if (!wexpecttok(TOK_IDENT))
  476.     break;
  477.                 if (ex->val.type->kind != TK_POINTER)
  478.                     ex->val.type = makepointertype(ex->val.type);
  479.                 ex = makeexpr_dotq(makeexpr_hat(ex, 0),
  480.                                    curtokcase, tp_integer);
  481.                 gettok();
  482.                 break;
  484.             case TOK_DOT:
  485.                 pc_prec(16);
  486.                 if (!wexpecttok(TOK_IDENT))
  487.     break;
  488.                 ex = makeexpr_dotq(ex, curtokcase, tp_integer);
  489.                 gettok();
  490.                 break;
  492.     case TOK_COLONCOLON:
  493. if (prec > 16)
  494.     return ex;
  495. i = C_lex;
  496. C_lex = 0;
  497. gettok();
  498. if (curtok == TOK_IDENT &&
  499.     curtokmeaning && curtokmeaning->kind == MK_TYPE) {
  500.     ex->val.type = curtokmeaning->type;
  501. } else if (curtok == TOK_LPAR) {
  502.     gettok();
  503.     ex->val.type = p_type(NULL);
  504.     if (!wexpecttok(TOK_RPAR))
  505. skiptotoken(TOK_RPAR);
  506. } else
  507.     wexpected("a type name");
  508. C_lex = i;
  509. gettok();
  510. break;
  512.             default:
  513.                 return ex;
  514.         }
  515.     }
  516. }
  521. Expr *pc_expr()
  522. {
  523.     return pc_expr2(0);
  524. }
  528. Expr *pc_expr_str(buf)
  529. char *buf;
  530. {
  531.     Strlist *defsl, *sl;
  532.     Expr *ex;
  534.     defsl = NULL;
  535.     sl = strlist_append(&defsl, buf);
  536.     C_lex++;
  537.     push_input_strlist(defsl, buf);
  538.     ex = pc_expr();
  539.     if (curtok != TOK_EOF)
  540.         warning(format_s("Junk (%s) at end of C expression [306]",
  541.  tok_name(curtok)));
  542.     pop_input();
  543.     C_lex--;
  544.     strlist_empty(&defsl);
  545.     return ex;
  546. }
  553. /* Simplify an expression */
  555. Expr *fixexpr(ex, env)
  556. Expr *ex;
  557. int env;
  558. {
  559.     Expr *ex2, *ex3, **ep;
  560.     Type *type, *type2;
  561.     Meaning *mp;
  562.     char *cp;
  563.     char sbuf[5];
  564.     int i;
  565.     Value val;
  567.     if (!ex)
  568.         return NULL;
  569.     switch (ex->kind) {
  571.         case EK_BICALL:
  572.             ex2 = fix_bicall(ex, env);
  573.             if (ex2) {
  574.                 ex = ex2;
  575.                 break;
  576.             }
  577.             cp = ex->val.s;
  578.             if (!strcmp(cp, "strlen")) {
  579.                 if (ex->args[0]->kind == EK_BICALL &&
  580.                     !strcmp(ex->args[0]->val.s, "sprintf") &&
  581.                     sprintf_value == 0) {     /* does sprintf return char count? */
  582.                     ex = grabarg(ex, 0);
  583.                     strchange(&ex->val.s, "*sprintf");
  584.                     ex = fixexpr(ex, env);
  585.                 } else {
  586.                     ex->args[0] = fixexpr(ex->args[0], ENV_EXPR);
  587.                 }
  588.             } else if (!strcmp(cp, name_SETIO)) {
  589.                 ex->args[0] = fixexpr(ex->args[0], ENV_BOOL);
  590.             } else if (!strcmp(cp, "~~SETIO")) {
  591.                 ex->args[0] = fixexpr(ex->args[0], ENV_BOOL);
  592.                 ex = makeexpr_cond(ex->args[0],
  593.                                    makeexpr_long(0),
  594.                                    makeexpr_bicall_1(name_ESCIO, tp_int, ex->args[1]));
  595.             } else if (!strcmp(cp, name_CHKIO)) {
  596.                 ex->args[0] = fixexpr(ex->args[0], ENV_BOOL);
  597.                 ex->args[2] = fixexpr(ex->args[2], env);
  598.                 ex->args[3] = fixexpr(ex->args[3], env);
  599.             } else if (!strcmp(cp, "~~CHKIO")) {
  600.                 ex->args[0] = fixexpr(ex->args[0], ENV_BOOL);
  601.                 ex->args[2] = fixexpr(ex->args[2], env);
  602.                 ex->args[3] = fixexpr(ex->args[3], env);
  603.                 ex2 = makeexpr_bicall_1(name_ESCIO, tp_int, ex->args[1]);
  604.                 if (ord_type(ex->args[3]->val.type)->kind != TK_INTEGER)
  605.                     ex2 = makeexpr_cast(ex2, ex->args[3]->val.type);
  606.                 ex = makeexpr_cond(ex->args[0], ex->args[2], ex2);
  607.             } else if (!strcmp(cp, "assert")) {
  608.                 ex->args[0] = fixexpr(ex->args[0], ENV_BOOL);
  609.             } else {
  610.                 for (i = 0; i < ex->nargs; i++)
  611.                     ex->args[i] = fixexpr(ex->args[i], ENV_EXPR);
  612. ex = cleansprintf(ex);
  613.                 if (!strcmp(cp, "sprintf")) {
  614.                     if (checkstring(ex->args[1], "%s")) {
  615.                         delfreearg(&ex, 1);
  616.                         strchange(&ex->val.s, "strcpy");
  617.                         ex = fixexpr(ex, env);
  618.                     } else if (sprintf_value != 1 && env != ENV_STMT) {
  619.                         if (*sprintfname) {
  620.                             strchange(&ex->val.s, format_s("*%s", sprintfname));
  621.                         } else {
  622.                             strchange(&ex->val.s, "*sprintf");
  623.                             ex = makeexpr_comma(ex, copyexpr(ex->args[0]));
  624.                         }
  625.                     }
  626.                 } else if (!strcmp(cp, "strcpy")) {
  627.                     if (env == ENV_STMT &&
  628.                          ex->args[1]->kind == EK_BICALL &&
  629.                          !strcmp(ex->args[1]->val.s, "strcpy") &&
  630.                          nosideeffects(ex->args[1]->args[0], 1)) {
  631.                         ex2 = ex->args[1];
  632.                         ex->args[1] = copyexpr(ex2->args[0]);
  633.                         ex = makeexpr_comma(ex2, ex);
  634.                     }
  635.                 } else if (!strcmp(cp, "memcpy")) {
  636.                     strchange(&ex->val.s, format_s("*%s", memcpyname));
  637.                     if (!strcmp(memcpyname, "*bcopy")) {
  638.                         swapexprs(ex->args[0], ex->args[1]);
  639.                         if (env != ENV_STMT)
  640.                             ex = makeexpr_comma(ex, copyexpr(ex->args[1]));
  641.                     }
  642. } else if (!strcmp(cp, setunionname) &&
  643.    (ex3 = singlevar(ex->args[0])) != NULL &&
  644.    ((i=1, exprsame(ex->args[0], ex->args[i], 0)) ||
  645.     (i=2, exprsame(ex->args[0], ex->args[i], 0))) &&
  646.    !exproccurs(ex3, ex->args[3-i])) {
  647.     ep = &ex->args[3-i];
  648.     while ((ex2 = *ep)->kind == EK_BICALL &&
  649.    (!strcmp(ex2->val.s, setaddname) ||
  650.     !strcmp(ex2->val.s, setaddrangename)))
  651. ep = &ex2->args[0];
  652.     if (ex2->kind == EK_BICALL &&
  653. !strcmp(ex2->val.s, setexpandname) &&
  654. checkconst(ex2->args[1], 0) &&
  655. (mp = istempvar(ex2->args[0])) != NULL) {
  656. if (ex2 == ex->args[3-i]) {
  657.     ex = grabarg(ex, i);
  658. } else {
  659.     freeexpr(ex2);
  660.     *ep = ex->args[i];
  661.     ex = ex->args[3-i];
  662. }
  663.     }
  664. } else if (!strcmp(cp, setdiffname) && *setremname &&
  665.    (ex3 = singlevar(ex->args[0])) != NULL &&
  666.    exprsame(ex->args[0], ex->args[1], 0) &&
  667.    !exproccurs(ex3, ex->args[2])) {
  668.     ep = &ex->args[2];
  669.     while ((ex2 = *ep)->kind == EK_BICALL &&
  670.    !strcmp(ex2->val.s, setaddname))
  671. ep = &ex2->args[0];
  672.     if (ex2->kind == EK_BICALL &&
  673. !strcmp(ex2->val.s, setexpandname) &&
  674. checkconst(ex2->args[1], 0) &&
  675. (mp = istempvar(ex2->args[0])) != NULL) {
  676. if (ex2 == ex->args[2]) {
  677.     ex = grabarg(ex, 1);
  678. } else {
  679.     ex2 = ex->args[2];
  680.     while (ex2->kind == EK_BICALL &&
  681.    !strcmp(ex2->val.s, setaddname)) {
  682. strchange(&ex2->val.s, setremname);
  683. ex2 = ex2->args[0];
  684.     }
  685.     freeexpr(ex2);
  686.     *ep = ex->args[1];
  687.     ex = ex->args[2];
  688. }
  689.     }
  690.                 } else if (!strcmp(cp, setexpandname) && env == ENV_STMT &&
  691.                            checkconst(ex->args[1], 0)) {
  692.                     ex = makeexpr_assign(makeexpr_hat(ex->args[0], 0),
  693.                                          ex->args[1]);
  694.                 } else if (!strcmp(cp, getbitsname)) {
  695.     type = ex->args[0]->val.type;
  696.     if (type->kind == TK_POINTER)
  697. type = type->basetype;
  698.                     sbuf[0] = (type->issigned) ? 'S' : 'U';
  699.                     sbuf[1] = (type->kind == TK_ARRAY) ? 'B' : 'S';
  700.                     sbuf[2] = 0;
  701.                     if (sbuf[1] == 'S' &&
  702.                         type->smax->val.type == tp_boolean) {
  703.                         ex = makeexpr_rel(EK_NE,
  704.                                           makeexpr_bin(EK_BAND, tp_integer,
  705.                                                        ex->args[0],
  706.                                                        makeexpr_bin(EK_LSH, tp_integer,
  707.                                                                     makeexpr_longcast(makeexpr_long(1),
  708.                                                                                       type->basetype
  709.                                                                                             == tp_unsigned),
  710.                                                                     ex->args[1])),
  711.                                           makeexpr_long(0));
  712.                         ex = fixexpr(ex, env);
  713.                     } else
  714.                         strchange(&ex->val.s, format_s(cp, sbuf));
  715.                 } else if (!strcmp(cp, putbitsname)) {
  716.     type = ex->args[0]->val.type;
  717.     if (type->kind == TK_POINTER)
  718. type = type->basetype;
  719.                     sbuf[0] = (type->issigned) ? 'S' : 'U';
  720.                     sbuf[1] = (type->kind == TK_ARRAY) ? 'B' : 'S';
  721.                     sbuf[2] = 0;
  722.                     if (sbuf[1] == 'S' &&
  723.                         type->smax->val.type == tp_boolean) {
  724.                         ex = makeexpr_assign(ex->args[0],
  725.                                              makeexpr_bin(EK_BOR, tp_integer,
  726.                                                           copyexpr(ex->args[0]),
  727.                                                           makeexpr_bin(EK_LSH, tp_integer,
  728.                                                                        makeexpr_longcast(ex->args[2],
  729.                                                                                          type->basetype
  730.                                                                                                == tp_unsigned),
  731.                                                                        ex->args[1])));
  732.                     } else
  733.                         strchange(&ex->val.s, format_s(cp, sbuf));
  734.                 } else if (!strcmp(cp, storebitsname)) {
  735.     type = ex->args[0]->val.type;
  736.     if (type->kind == TK_POINTER)
  737. type = type->basetype;
  738.                     sbuf[0] = (type->issigned) ? 'S' : 'U';
  739.                     sbuf[1] = (type->kind == TK_ARRAY) ? 'B' : 'S';
  740.                     sbuf[2] = 0;
  741.                     strchange(&ex->val.s, format_s(cp, sbuf));
  742.                 } else if (!strcmp(cp, clrbitsname)) {
  743.     type = ex->args[0]->val.type;
  744.     if (type->kind == TK_POINTER)
  745. type = type->basetype;
  746.                     sbuf[0] = (type->kind == TK_ARRAY) ? 'B' : 'S';
  747.                     sbuf[1] = 0;
  748.                     if (sbuf[0] == 'S' &&
  749.                         type->smax->val.type == tp_boolean) {
  750.                         ex = makeexpr_assign(ex->args[0],
  751.                                              makeexpr_bin(EK_BAND, tp_integer,
  752.                                                    copyexpr(ex->args[0]),
  753.                                                    makeexpr_un(EK_BNOT, tp_integer,
  754.                                                           makeexpr_bin(EK_LSH, tp_integer,
  755.                                                                        makeexpr_longcast(makeexpr_long(1),
  756.                                                                                          type->basetype
  757.                                                                                                == tp_unsigned),
  758.                                                                        ex->args[1]))));
  759.                     } else
  760.                         strchange(&ex->val.s, format_s(cp, sbuf));
  761.                 } else if (!strcmp(cp, "fopen")) {
  762.     if (which_lang == LANG_HP &&
  763. ex->args[0]->kind == EK_CONST &&
  764. ex->args[0]->val.type->kind == TK_STRING &&
  765. ex->args[0]->val.i >= 1 &&
  766. ex->args[0]->val.i <= 2 &&
  767. isdigit(ex->args[0]->val.s[0]) &&
  768. (ex->args[0]->val.i == 1 ||
  769.  isdigit(ex->args[0]->val.s[1]))) {
  770. strchange(&ex->val.s, "fdopen");
  771. ex->args[0] = makeexpr_long(atoi(ex->args[0]->val.s));
  772.     }
  773. }
  774.             }
  775.             break;
  777.         case EK_NOT:
  778.             ex = makeexpr_not(fixexpr(grabarg(ex, 0), ENV_BOOL));
  779.             break;
  781.         case EK_AND:
  782.         case EK_OR:
  783.             for (i = 0; i < ex->nargs; i++)
  784.                 ex->args[i] = fixexpr(ex->args[i], ENV_BOOL);
  785.             break;
  787.         case EK_EQ:
  788.         case EK_NE:
  789.             ex->args[0] = fixexpr(ex->args[0], ENV_EXPR);
  790.             ex->args[1] = fixexpr(ex->args[1], ENV_EXPR);
  791.             if (checkconst(ex->args[1], 0) && env == ENV_BOOL &&
  792.                 ord_type(ex->args[1]->val.type)->kind != TK_ENUM &&
  793.                 (implicitzero > 0 ||
  794.                  (implicitzero < 0 && ex->args[0]->kind == EK_BICALL &&
  795.                                       boolean_bicall(ex->args[0]->val.s)))) {
  796.                 if (ex->kind == EK_EQ)
  797.                     ex = makeexpr_not(grabarg(ex, 0));
  798.                 else {
  799.                     ex = grabarg(ex, 0);
  800.                     ex->val.type = tp_boolean;
  801.                 }
  802.             }
  803.             break;
  805.         case EK_COND:
  806.             ex->args[0] = fixexpr(ex->args[0], ENV_BOOL);
  807. #if 0
  808.             val = eval_expr(ex->args[0]);
  809. #else
  810.     val = ex->args[0]->val;
  811.     if (ex->args[0]->kind != EK_CONST)
  812. val.type = NULL;
  813. #endif
  814.             if (val.type == tp_boolean) {
  815.                 ex = grabarg(ex, (val.i) ? 1 : 2);
  816.                 ex = fixexpr(ex, env);
  817.             } else {
  818.                 ex->args[1] = fixexpr(ex->args[1], env);
  819.                 ex->args[2] = fixexpr(ex->args[2], env);
  820.             }
  821.             break;
  823.         case EK_COMMA:
  824.             for (i = 0; i < ex->nargs-1; ) {
  825.                 ex->args[i] = fixexpr(ex->args[i], ENV_STMT);
  826.                 if (nosideeffects(ex->args[i], 1))
  827.                     delfreearg(&ex, i);
  828.                 else
  829.                     i++;
  830.             }
  831.             ex->args[ex->nargs-1] = fixexpr(ex->args[ex->nargs-1], env);
  832.             if (ex->nargs == 1)
  833.                 ex = grabarg(ex, 0);
  834.             break;
  836.         case EK_CHECKNIL:
  837.             ex->args[0] = fixexpr(ex->args[0], ENV_EXPR);
  838.             if (ex->nargs == 2) {
  839.                 ex->args[1] = fixexpr(ex->args[1], ENV_EXPR);
  840.                 ex2 = makeexpr_assign(copyexpr(ex->args[1]), ex->args[0]);
  841.                 ex3 = ex->args[1];
  842.             } else {
  843.                 ex2 = copyexpr(ex->args[0]);
  844.                 ex3 = ex->args[0];
  845.             }
  846.             type = ex->args[0]->val.type;
  847.             type2 = ex->val.type;
  848.             ex = makeexpr_cond(makeexpr_rel(EK_NE, ex2, makeexpr_nil()),
  849.                                ex3,
  850.                                makeexpr_cast(makeexpr_bicall_0(name_NILCHECK,
  851.                                                                tp_int),
  852.                                              type));
  853.             ex->val.type = type2;
  854.             ex = fixexpr(ex, env);
  855.             break;
  857.         case EK_CAST:
  858.         case EK_ACTCAST:
  859.             if (env == ENV_STMT) {
  860.                 ex = fixexpr(grabarg(ex, 0), ENV_STMT);
  861.             } else {
  862.                 ex->args[0] = fixexpr(ex->args[0], ENV_EXPR);
  863.             }
  864.             break;
  866.         default:
  867.             for (i = 0; i < ex->nargs; i++)
  868.                 ex->args[i] = fixexpr(ex->args[i], ENV_EXPR);
  869.             break;
  870.     }
  871.     return fix_expression(ex, env);
  872. }
  881. /* Output an expression */
  884. #define bitOp(k)  ((k)==EK_BAND || (k)==EK_BOR || (k)==EK_BXOR)
  886. #define shfOp(k)  ((k)==EK_LSH || (k)==EK_RSH)
  888. #define logOp(k)  ((k)==EK_AND || (k)==EK_OR)
  890. #define relOp(k)  ((k)==EK_EQ || (k)==EK_LT || (k)==EK_GT ||    
  891.    (k)==EK_NE || (k)==EK_GE || (k)==EK_LE)
  893. #define mathOp(k) ((k)==EK_PLUS || (k)==EK_TIMES || (k)==EK_NEG ||   
  894.    (k)==EK_DIV || (k)==EK_DIVIDE || (k)==EK_MOD)
  896. #define divOp(k)  ((k)==EK_DIV || (k)==EK_DIVIDE)
  899. Static int incompat(ex, num, prec)
  900. Expr *ex;
  901. int num, prec;
  902. {
  903.     Expr *subex = ex->args[num];
  905.     if (extraparens == 0)
  906. return prec;
  907.     if (ex->kind == subex->kind) {
  908. if (logOp(ex->kind) || bitOp(ex->kind) ||
  909.     (divOp(ex->kind) && num == 0))
  910.     return -99;   /* not even invisible parens */
  911. else if (extraparens != 2)
  912.     return prec;
  913.     }
  914.     if (extraparens == 2)
  915. return 15;
  916.     if (divOp(ex->kind) && num == 0 &&
  917. (subex->kind == EK_TIMES || divOp(subex->kind)))
  918. return -99;
  919.     if (bitOp(ex->kind) || shfOp(ex->kind))
  920. return 15;
  921.     if (relOp(ex->kind) && relOp(subex->kind))
  922. return 15;
  923.     if ((relOp(ex->kind) || logOp(ex->kind)) && bitOp(subex->kind))
  924. return 15;
  925.     if (ex->kind == EK_COMMA)
  926. return 15;
  927.     if (ex->kind == EK_ASSIGN && relOp(subex->kind))
  928. return 15;
  929.     if (extraparens != 1)
  930. return prec;
  931.     if (ex->kind == EK_ASSIGN)
  932. return prec;
  933.     if (relOp(ex->kind) && mathOp(subex->kind))
  934. return prec;
  935.     return 15;
  936. }
  941. #define EXTRASPACE() if (spaceexprs == 1) output(" ")
  942. #define NICESPACE()  if (spaceexprs != 0) output(" ")
  944. #define setprec(p) 
  945.     if ((subprec=(p)) <= prec) { 
  946.         parens = 1; output("("); 
  947.     }
  949. #define setprec2(p) 
  950.     if ((subprec=(p)) <= prec) { 
  951.         parens = 1; output("("); 
  952.     } else if (prec != -99) { 
  953.         parens = 2; output((breakparens == 1) ? "10" : "03"); 
  954.     }
  956. #define setprec3(p) 
  957.     if ((subprec=(p)) <= prec) { 
  958.          parens = 1; output("("); 
  959.     } else if (prec != -99) { 
  960.          parens = 2; output((prec > 2 && breakparens != 0) ? "10" 
  961.                                    : "03"); 
  962.     }
  965. Static void outop3(breakbefore, name)
  966. int breakbefore;
  967. char *name;
  968. {
  969.     if (breakbefore & BRK_LEFT) {
  970. output("02");
  971. if (breakbefore & BRK_RPREF)
  972.     output("13");
  973.     }
  974.     output(name);
  975.     if (breakbefore & BRK_HANG)
  976. output("15");
  977.     if (breakbefore & BRK_RIGHT) {
  978. output("02");
  979. if (breakbefore & BRK_LPREF)
  980.     output("13");
  981.     }
  982. }
  984. #define outop(name) do { 
  985.     NICESPACE(); outop3(breakflag, name); NICESPACE(); 
  986. } while (0)
  988. #define outop2(name) do { 
  989.     EXTRASPACE(); outop3(breakflag, name); EXTRASPACE(); 
  990. } while (0)
  992. #define checkbreak(code) do { 
  993.     breakflag=(code); 
  994.     if ((prec != -99) && (breakflag & BRK_ALLNONE)) output("07"); 
  995. } while (0)
  998. Static void out_ctx(ctx, address)
  999. Meaning *ctx;
  1000. int address;
  1001. {
  1002.     Meaning *ctx2;
  1003.     int breakflag = breakbeforedot;
  1005.     if (ctx->kind == MK_FUNCTION && ctx->varstructflag) {
  1006.         if (curctx != ctx) {
  1007.     if (address && curctx->ctx && curctx->ctx != ctx) {
  1008. output("03");
  1009. if (breakflag & BRK_ALLNONE)
  1010.     output("07");
  1011.     }
  1012.             output(format_s(name_LINK, curctx->ctx->name));
  1013.             ctx2 = curctx->ctx;
  1014.             while (ctx2 && ctx2 != ctx) {
  1015.                 outop2("->");
  1016.                 output(format_s(name_LINK, ctx2->ctx->name));
  1017.                 ctx2 = ctx2->ctx;
  1018.             }
  1019.             if (ctx2 != ctx)
  1020.                 intwarning("out_ctx",
  1021.                            format_s("variable from %s not present in context path [307]",
  1022.                                      ctx->name));
  1023.     if (address && curctx->ctx && curctx->ctx != ctx)
  1024. output("04");
  1025.             if (!address)
  1026.                 outop2("->");
  1027.         } else {
  1028.             if (address) {
  1029.                 output("&");
  1030. EXTRASPACE();
  1031.     }
  1032.             output(format_s(name_VARS, curctx->name));
  1033.             if (!address) {
  1034.                 outop2(".");
  1035.     }
  1036.         }
  1037.     } else {
  1038.         if (address)
  1039.             output("NULL");
  1040.     }
  1041. }
  1045. void out_var(mp, prec)
  1046. Meaning *mp;
  1047. int prec;
  1048. {
  1049.     switch (mp->kind) {
  1051.         case MK_CONST:
  1052.             output(mp->name);
  1053.             return;
  1055.         case MK_VAR:
  1056.         case MK_VARREF:
  1057.         case MK_VARMAC:
  1058.         case MK_PARAM:
  1059.         case MK_VARPARAM:
  1060.             if (mp->varstructflag) {
  1061. output("03");
  1062.                 out_ctx(mp->ctx, 0);
  1063. output(mp->name);
  1064. output("04");
  1065.     } else
  1066. output(mp->name);
  1067.             return;
  1069. default:
  1070.     if (mp->name)
  1071. output(mp->name);
  1072.     else
  1073. intwarning("out_var", "mp->sym == NULL [308]");
  1074.     return;
  1075.     }
  1076. }
  1080. Static int scanfield(variants, unions, lev, mp, field)
  1081. Meaning **variants, *mp, *field;
  1082. short *unions;
  1083. int lev;
  1084. {
  1085.     int i, num, breakflag;
  1086.     Value v;
  1088.     unions[lev] = (mp && mp->kind == MK_VARIANT);
  1089.     while (mp && mp->kind == MK_FIELD) {
  1090.         if (mp == field) {
  1091.             for (i = 0; i < lev; i++) {
  1092. v = variants[i]->val;    /* sidestep a Sun 386i compiler bug */
  1093.                 num = ord_value(v);
  1094. breakflag = breakbeforedot;
  1095.                 if (!unions[i]) {
  1096.                     output(format_s(name_UNION, ""));
  1097.     outop2(".");
  1098.                 }
  1099.                 if (variants[i]->ctx->cnext ||
  1100.                     variants[i]->ctx->kind != MK_FIELD) {
  1101.                     output(format_s(name_VARIANT, variantfieldname(num)));
  1102.     outop2(".");
  1103.                 }
  1104.             }
  1105.             output(mp->name);
  1106.             return 1;
  1107.         }
  1108.         mp = mp->cnext;
  1109.     }
  1110.     while (mp && mp->kind == MK_VARIANT) {
  1111.         variants[lev] = mp;
  1112.         if (scanfield(variants, unions, lev+1, mp->ctx, field))
  1113.             return 1;
  1114.         mp = mp->cnext;
  1115.     }
  1116.     return 0;
  1117. }
  1120. void out_field(mp)
  1121. Meaning *mp;
  1122. {
  1123.     Meaning *variants[50];
  1124.     short unions[51];
  1126.     if (!scanfield(variants, unions, 0, mp->rectype->fbase, mp))
  1127.         intwarning("out_field", "field name not in tree [309]");
  1128.     else if (mp->warnifused) {
  1129.         if (mp->rectype->meaning)
  1130.             note(format_ss("Reference to field %s of record %s [282]", 
  1131.                            mp->name, mp->rectype->meaning->name));
  1132.         else
  1133.             note(format_s("Reference to field %s [282]", mp->name));
  1134.     }
  1135. }
  1140. Static void wrexpr(ex, prec)
  1141. Expr *ex;
  1142. int prec;
  1143. {
  1144.     short parens = 0;
  1145.     int subprec, i, j, minusflag, breakflag = 0;
  1146.     int saveindent;
  1147.     Expr *ex2, *ex3;
  1148.     char *cp;
  1149.     Meaning *mp;
  1150.     Symbol *sp;
  1152.     if (debug>2) { fprintf(outf,"wrexpr{"); dumpexpr(ex); fprintf(outf,", %d}n", prec); }
  1153.     switch (ex->kind) {
  1155.         case EK_VAR:
  1156.             mp = (Meaning *)ex->val.i;
  1157.             if (mp->warnifused)
  1158.                 note(format_s("Reference to %s [283]", mp->name));
  1159.             out_var(mp, prec);
  1160.             break;
  1162.         case EK_NAME:
  1163.             output(ex->val.s);
  1164.             break;
  1166.         case EK_MACARG:
  1167.             output("<meef>");
  1168.             intwarning("wrexpr", "Stray EK_MACARG encountered [310]");
  1169.             break;
  1171.         case EK_CTX:
  1172.             out_ctx((Meaning *)ex->val.i, 1);
  1173.             break;
  1175.         case EK_CONST:
  1176.             if (ex->nargs > 0)
  1177.                 cp = value_name(ex->val, ex->args[0]->val.s, 0);
  1178.             else
  1179.                 cp = value_name(ex->val, NULL, 0);
  1180.             if (*cp == '-')
  1181.                 setprec(14);
  1182.             output(cp);
  1183.             break;
  1185.         case EK_LONGCONST:
  1186.             if (ex->nargs > 0)
  1187.                 cp = value_name(ex->val, ex->args[0]->val.s, 1);
  1188.             else
  1189.                 cp = value_name(ex->val, NULL, 1);
  1190.             if (*cp == '-')
  1191.                 setprec(14);
  1192.             output(cp);
  1193.             break;
  1195.         case EK_STRUCTCONST:
  1196.             ex3 = NULL;
  1197.             for (i = 0; i < ex->nargs; i++) {
  1198.                 ex2 = ex->args[i];
  1199.                 if (ex2->kind == EK_STRUCTOF) {
  1200.                     j = ex2->val.i;
  1201.                     ex2 = ex2->args[0];
  1202.                 } else
  1203.                     j = 1;
  1204.                 if (ex2->kind == EK_VAR) {
  1205.                     mp = (Meaning *)ex2->val.i;
  1206.                     if (mp->kind == MK_CONST &&
  1207.                         (mp->val.type->kind == TK_RECORD ||
  1208.                          mp->val.type->kind == TK_ARRAY)) {
  1209.                         if (foldconsts != 1)
  1210.                             note(format_s("Expanding constant %s into another constant [284]",
  1211.                                           mp->name));
  1212.                         ex2 = (Expr *)mp->val.i;
  1213.                     }
  1214.                 }
  1215.                 while (--j >= 0) {
  1216.                     if (ex3) {
  1217.                         if (ex3->kind == EK_STRUCTCONST ||
  1218.                             ex2->kind == EK_STRUCTCONST)
  1219.                             output(",n");
  1220.                         else
  1221.                             output(",01 ");
  1222.                     }
  1223.                     if (ex2->kind == EK_STRUCTCONST) {
  1224.                         output("{ 05");
  1225. saveindent = outindent;
  1226. moreindent(extrainitindent);
  1227.                         out_expr(ex2);
  1228.                         outindent = saveindent;
  1229.                         output(" }");
  1230.                     } else
  1231.                         out_expr(ex2);
  1232.                     ex3 = ex2;
  1233.                 }
  1234.             }
  1235.             break;
  1237.         case EK_FUNCTION:
  1238.             mp = (Meaning *)ex->val.i;
  1239.     sp = findsymbol_opt(mp->name);
  1240.     if ((sp && (sp->flags & WARNLIBR)) || mp->warnifused)
  1241.                 note(format_s("Called procedure %s [285]", mp->name));
  1242.             output(mp->name);
  1243.             output("(02");
  1244.     j = sp ? (sp->flags & FUNCBREAK) : 0;
  1245.     if (j == FALLBREAK)
  1246. output("07");
  1247.             for (i = 0; i < ex->nargs; i++) {
  1248. if ((j == FSPCARG1 && i == 1) ||
  1249.     (j == FSPCARG2 && i == 2) ||
  1250.     (j == FSPCARG3 && i == 3))
  1251.     output(",11 ");
  1252.                 else if (i > 0)
  1253.                     output(",02 ");
  1254.                 out_expr(ex->args[i]);
  1255.             }
  1256.             if (mp->ctx->kind == MK_FUNCTION && mp->ctx->varstructflag) {
  1257.                 if (i > 0)
  1258.                     output(",02 ");
  1259.                 out_ctx(mp->ctx, 1);
  1260.             }
  1261.             output(")");
  1262.             break;
  1264.         case EK_BICALL:
  1265.             cp = ex->val.s;
  1266.             while (*cp == '*')
  1267.                 cp++;
  1268.     sp = findsymbol_opt(cp);
  1269.     if (sp && (sp->flags & WARNLIBR))
  1270.                 note(format_s("Called library procedure %s [286]", cp));
  1271.             output(cp);
  1272.             output("(02");
  1273.     j = sp ? (sp->flags & FUNCBREAK) : 0;
  1274.     if (j == FALLBREAK)
  1275. output("07");
  1276.             for (i = 0; i < ex->nargs; i++) {
  1277. if ((j == FSPCARG1 && i == 1) ||
  1278.     (j == FSPCARG2 && i == 2) ||
  1279.     (j == FSPCARG3 && i == 3))
  1280.     output(",11 ");
  1281.                 else if (i > 0)
  1282.                     output(",02 ");
  1283.                 out_expr(ex->args[i]);
  1284.             }
  1285.             output(")");
  1286.             break;
  1288.         case EK_SPCALL:
  1289.             setprec(16);
  1290.             if (starfunctions) {
  1291.                 output("(02*");
  1292.                 wrexpr(ex->args[0], 13);
  1293.                 output(")");
  1294.             } else
  1295.                 wrexpr(ex->args[0], subprec-1);
  1296.             output("(02");
  1297.             for (i = 1; i < ex->nargs; i++) {
  1298.                 if (i > 1)
  1299.                     output(",02 ");
  1300.                 out_expr(ex->args[i]);
  1301.             }
  1302.             output(")");
  1303.             break;
  1305.         case EK_INDEX:
  1306.             setprec(16);
  1307.             wrexpr(ex->args[0], subprec-1);
  1308.     if (lookback(1) == ']')
  1309. output("01");
  1310.             output("[");
  1311.             out_expr(ex->args[1]);
  1312.             output("]");
  1313.             break;
  1315.         case EK_DOT:
  1316.             setprec2(16);
  1317.     checkbreak(breakbeforedot);
  1318.             if (ex->args[0]->kind == EK_HAT) {
  1319.                 wrexpr(ex->args[0]->args[0], subprec-1);
  1320.                 outop2("->");
  1321.             } else if (ex->args[0]->kind == EK_CTX) {
  1322.                 out_ctx((Meaning *)ex->args[0]->val.i, 0);
  1323.             } else {
  1324.                 wrexpr(ex->args[0], subprec-1);
  1325.                 outop2(".");
  1326.             }
  1327.             if (ex->val.i)
  1328.                 out_field((Meaning *)ex->val.i);
  1329.             else
  1330.                 output(ex->val.s);
  1331.             break;
  1333.         case EK_POSTINC:
  1334.     if (prec == 0 && !postincrement) {
  1335. setprec(14);
  1336. output("++");
  1337. EXTRASPACE();
  1338. wrexpr(ex->args[0], subprec);
  1339.     } else {
  1340. setprec(15);
  1341. wrexpr(ex->args[0], subprec);
  1342. EXTRASPACE();
  1343. output("++");
  1344.     }
  1345.             break;
  1347.         case EK_POSTDEC:
  1348.     if (prec == 0 && !postincrement) {
  1349. setprec(14);
  1350. output("--");
  1351. EXTRASPACE();
  1352. wrexpr(ex->args[0], subprec);
  1353.     } else {
  1354. setprec(15);
  1355. wrexpr(ex->args[0], subprec);
  1356. EXTRASPACE();
  1357. output("--");
  1358.     }
  1359.             break;
  1361.         case EK_HAT:
  1362.             setprec(14);
  1363.     if (lookback_prn(1) == '/')
  1364. output(" ");
  1365.             output("*");
  1366.             EXTRASPACE();
  1367.             wrexpr(ex->args[0], subprec-1);
  1368.             break;
  1370.         case EK_ADDR:
  1371.             setprec(14);
  1372.     if (lookback_prn(1) == '&')
  1373. output(" ");
  1374.             output("&");
  1375.             EXTRASPACE();
  1376.             wrexpr(ex->args[0], subprec-1);
  1377.             break;
  1379.         case EK_NEG:
  1380.             setprec(14);
  1381.             output("-");
  1382.             EXTRASPACE();
  1383.             if (ex->args[0]->kind == EK_TIMES)
  1384.                 wrexpr(ex->args[0], 12);
  1385.             else
  1386.                 wrexpr(ex->args[0], subprec-1);
  1387.             break;
  1389.         case EK_NOT:
  1390.             setprec(14);
  1391.             output("!");
  1392.             EXTRASPACE();
  1393.             wrexpr(ex->args[0], subprec-1);
  1394.             break;
  1396.         case EK_BNOT:
  1397.             setprec(14);
  1398.             output("~");
  1399.             EXTRASPACE();
  1400.             wrexpr(ex->args[0], subprec-1);
  1401.             break;
  1403.         case EK_CAST:
  1404.         case EK_ACTCAST:
  1405.             if (similartypes(ex->val.type, ex->args[0]->val.type)) {
  1406.                 wrexpr(ex->args[0], prec);
  1407.             } else if (ord_type(ex->args[0]->val.type)->kind == TK_ENUM &&
  1408.                        ex->val.type == tp_int && !useenum) {
  1409.                 wrexpr(ex->args[0], prec);
  1410.             } else {
  1411.                 setprec2(14);
  1412.                 output("(");
  1413.                 out_type(ex->val.type, 0);
  1414.                 output(")02");
  1415.                 EXTRASPACE();
  1416.                 if (extraparens != 0)
  1417.                     wrexpr(ex->args[0], 15);
  1418.                 else
  1419.                     wrexpr(ex->args[0], subprec-1);
  1420.             }
  1421.             break;
  1423.         case EK_LITCAST:
  1424.             setprec2(14);
  1425.             output("(");
  1426.             out_expr(ex->args[0]);
  1427.             output(")02");
  1428.             EXTRASPACE();
  1429.             if (extraparens != 0)
  1430.                 wrexpr(ex->args[1], 15);
  1431.             else
  1432.                 wrexpr(ex->args[1], subprec-1);
  1433.             break;
  1435.         case EK_SIZEOF:
  1436.             setprec(14);
  1437.             output("sizeof(");
  1438.     out_expr(ex->args[0]);
  1439.             output(")");
  1440.             break;
  1442. case EK_TYPENAME:
  1443.     out_type(ex->val.type, 1);
  1444.     break;
  1446.         case EK_TIMES:
  1447.     setprec2(13);
  1448.     checkbreak(breakbeforearith);
  1449.             ex2 = copyexpr(ex);
  1450.             if (expr_looks_neg(ex2->args[ex2->nargs-1])) {
  1451.                 ex2->args[0] = makeexpr_neg(ex2->args[0]);
  1452.                 ex2->args[ex2->nargs-1] = makeexpr_neg(ex2->args[ex2->nargs-1]);
  1453.             }
  1454.             wrexpr(ex2->args[0], incompat(ex2, 0, subprec-1));
  1455.             for (i = 1; i < ex2->nargs; i++) {
  1456.                 outop("*");
  1457.                 wrexpr(ex2->args[i], incompat(ex2, i, subprec));
  1458.             }
  1459.             freeexpr(ex2);
  1460.             break;
  1462.         case EK_DIV:
  1463.         case EK_DIVIDE:
  1464.             setprec2(13);
  1465.     checkbreak(breakbeforearith);
  1466.     wrexpr(ex->args[0], incompat(ex, 0, subprec-1));
  1467.             outop("/");
  1468.             wrexpr(ex->args[1], incompat(ex, 1, subprec));
  1469.             break;
  1471.         case EK_MOD:
  1472.             setprec2(13);
  1473.     checkbreak(breakbeforearith);
  1474.             wrexpr(ex->args[0], incompat(ex, 0, subprec-1));
  1475.             outop("%");
  1476.             wrexpr(ex->args[1], incompat(ex, 1, subprec));
  1477.             break;
  1479.         case EK_PLUS:
  1480.             setprec2(12);
  1481.     checkbreak(breakbeforearith);
  1482.             ex2 = copyexpr(ex);
  1483.             minusflag = 0;
  1484.             if (expr_looks_neg(ex2->args[0])) {
  1485.                 j = 1;
  1486.                 while (j < ex2->nargs && expr_looks_neg(ex2->args[j])) j++;
  1487.                 if (j < ex2->nargs)
  1488.                     swapexprs(ex2->args[0], ex2->args[j]);
  1489.             } else if (ex2->val.i && ex2->nargs == 2) {   /* this was originally "a-b" */
  1490.                 if (isliteralconst(ex2->args[1], NULL) != 2) {
  1491.                     if (expr_neg_cost(ex2->args[1]) <= 0) {
  1492.                         minusflag = 1;
  1493.                     } else if (expr_neg_cost(ex2->args[0]) <= 0) {
  1494.                         swapexprs(ex2->args[0], ex2->args[1]);
  1495.                         if (isliteralconst(ex2->args[0], NULL) != 2)
  1496.                             minusflag = 1;
  1497.                     }
  1498.                 }
  1499.             }
  1500.             wrexpr(ex2->args[0], incompat(ex, 0, subprec));
  1501.             for (i = 1; i < ex2->nargs; i++) {
  1502.                 if (expr_looks_neg(ex2->args[i]) || minusflag) {
  1503.                     outop("-");
  1504.                     ex2->args[i] = makeexpr_neg(ex2->args[i]);
  1505.                 } else
  1506.                     outop("+");
  1507.                 wrexpr(ex2->args[i], incompat(ex, i, subprec));
  1508.             }
  1509.             freeexpr(ex2);
  1510.             break;
  1512.         case EK_LSH:
  1513.             setprec3(11);
  1514.     checkbreak(breakbeforearith);
  1515.             wrexpr(ex->args[0], incompat(ex, 0, subprec));
  1516.             outop("<<");
  1517.             wrexpr(ex->args[1], incompat(ex, 1, subprec));
  1518.             break;
  1520.         case EK_RSH:
  1521.             setprec3(11);
  1522.     checkbreak(breakbeforearith);
  1523.     wrexpr(ex->args[0], incompat(ex, 0, subprec));
  1524.             outop(">>");
  1525.             wrexpr(ex->args[1], incompat(ex, 1, subprec));
  1526.             break;
  1528.         case EK_LT:
  1529.             setprec2(10);
  1530.     checkbreak(breakbeforerel);
  1531.             wrexpr(ex->args[0], incompat(ex, 0, subprec));
  1532.             outop("<");
  1533.             wrexpr(ex->args[1], incompat(ex, 0, subprec));
  1534.             break;
  1536.         case EK_GT: