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

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

编译器/解释器

开发平台：

C/C++

expr.c.3：源码内容
  1.         if (!nosideeffects(ex->args[i], mode))
  2.             return 0;
  3.     }
  4.     return 1;
  5. }
  8. /* mode=0: liberal about bicall's: safe unless sideeffects_bicall() */
  9. /* mode=1: conservative about bicall's: must be explicitly NOSIDEEFF */
  11. int nosideeffects(ex, mode)
  12. Expr *ex;
  13. int mode;
  14. {
  15.     if (debug>2) { fprintf(outf,"nosideeffects("); dumpexpr(ex); fprintf(outf,")n"); }
  16.     if (!noargsideeffects(ex, mode))
  17.         return 0;
  18.     switch (ex->kind) {
  20.         case EK_BICALL:
  21.             if (mode == 0)
  22.                 return !sideeffects_bicall(ex->val.s);
  24.         /* fall through */
  25.         case EK_FUNCTION:
  26.             return nosideeffects_func(ex);
  28.         case EK_SPCALL:
  29.         case EK_ASSIGN:
  30.         case EK_POSTINC:
  31.         case EK_POSTDEC:
  32.             return 0;
  34.         default:
  35.             return 1;
  36.     }
  37. }
  41. int exproccurs(ex, ex2)
  42. Expr *ex, *ex2;
  43. {
  44.     int i, count = 0;
  46.     if (debug>2) { fprintf(outf,"exproccurs("); dumpexpr(ex); fprintf(outf,", "); dumpexpr(ex2); fprintf(outf,")n"); }
  47.     for (i = 0; i < ex->nargs; i++)
  48.         count += exproccurs(ex->args[i], ex2);
  49.     if (exprsame(ex, ex2, 0))
  50.         count++;
  51.     return count;
  52. }
  56. Expr *singlevar(ex)
  57. Expr *ex;
  58. {
  59.     if (debug>2) { fprintf(outf,"singlevar("); dumpexpr(ex); fprintf(outf,")n"); }
  60.     switch (ex->kind) {
  62.         case EK_VAR:
  63.         case EK_MACARG:
  64.             return ex;
  66.         case EK_HAT:
  67.         case EK_ADDR:
  68.         case EK_DOT:
  69.             return singlevar(ex->args[0]);
  71.         case EK_INDEX:
  72.             if (!nodependencies(ex->args[1], 1))
  73.                 return NULL;
  74.             return singlevar(ex->args[0]);
  76. default:
  77.     return NULL;
  78.     }
  79. }
  83. /* Is "ex" a function which takes a return buffer pointer as its
  84.    first argument, and returns a copy of that pointer? */
  86. int structuredfunc(ex)
  87. Expr *ex;
  88. {
  89.     Meaning *mp;
  90.     Symbol *sp;
  92.     if (debug>2) { fprintf(outf,"structuredfunc("); dumpexpr(ex); fprintf(outf,")n"); }
  93.     switch (ex->kind) {
  95.         case EK_FUNCTION:
  96.             mp = (Meaning *)ex->val.i;
  97.             if (mp->isfunction && mp->cbase && mp->cbase->kind == MK_VARPARAM)
  98.                 return 1;
  99.             sp = findsymbol_opt(mp->name);
  100.             return sp && (sp->flags & (STRUCTF|STRLAPF));
  102.         case EK_BICALL:
  103.             sp = findsymbol_opt(ex->val.s);
  104.             return sp && (sp->flags & (STRUCTF|STRLAPF));
  106. default:
  107.     return 0;
  108.     }
  109. }
  113. int strlapfunc(ex)
  114. Expr *ex;
  115. {
  116.     Meaning *mp;
  117.     Symbol *sp;
  119.     switch (ex->kind) {
  121.         case EK_FUNCTION:
  122.             mp = (Meaning *)ex->val.i;
  123.             sp = findsymbol_opt(mp->name);
  124.             return sp && (sp->flags & STRLAPF);
  126.         case EK_BICALL:
  127.             sp = findsymbol_opt(ex->val.s);
  128.             return sp && (sp->flags & STRLAPF);
  130.         default:
  131.             return 0;
  132.     }
  133. }
  137. Meaning *istempvar(ex)
  138. Expr *ex;
  139. {
  140.     Meaning *mp;
  142.     if (debug>2) { fprintf(outf,"istempvar("); dumpexpr(ex); fprintf(outf,")n"); }
  143.     if (ex->kind == EK_VAR) {
  144.         mp = (Meaning *)ex->val.i;
  145.         if (mp->istemporary)
  146.             return mp;
  147.         else
  148.             return NULL;
  149.     }
  150.     return NULL;
  151. }
  155. Meaning *isretvar(ex)
  156. Expr *ex;
  157. {
  158.     Meaning *mp;
  160.     if (debug>2) { fprintf(outf,"isretvar("); dumpexpr(ex); fprintf(outf,")n"); }
  161.     if (ex->kind == EK_HAT)
  162.         ex = ex->args[0];
  163.     if (ex->kind == EK_VAR) {
  164.         mp = (Meaning *)ex->val.i;
  165.         if (mp->ctx && mp->ctx->kind == MK_FUNCTION &&
  166.             mp->ctx->isfunction && mp == mp->ctx->cbase)
  167.             return mp;
  168.         else
  169.             return NULL;
  170.     }
  171.     return NULL;
  172. }
  176. Expr *bumpstring(ex, index, offset)
  177. Expr *ex, *index;
  178. int offset;
  179. {
  180.     if (checkconst(index, offset)) {
  181.         freeexpr(index);
  182.         return ex;
  183.     }
  184.     if (addindex != 0)
  185.         ex = makeexpr_plus(makeexpr_addrstr(ex),
  186.    makeexpr_minus(index, makeexpr_long(offset)));
  187.     else
  188.         ex = makeexpr_addr(makeexpr_index(ex, index, makeexpr_long(offset)));
  189.     ex->val.type = tp_str255;
  190.     return ex;
  191. }
  195. long po2m1(n)
  196. int n;
  197. {
  198.     if (n == 32)
  199.         return -1;
  200.     else if (n == 31)
  201.         return 0x7fffffff;
  202.     else
  203.         return (1<<n) - 1;
  204. }
  208. int isarithkind(kind)
  209. enum exprkind kind;
  210. {
  211.     return (kind == EK_EQ || kind == EK_LT || kind == EK_GT ||
  212.     kind == EK_NE || kind == EK_LE || kind == EK_GE ||
  213.     kind == EK_PLUS || kind == EK_TIMES || kind == EK_DIVIDE ||
  214.     kind == EK_DIV || kind == EK_MOD || kind == EK_NEG ||
  215.     kind == EK_AND || kind == EK_OR || kind == EK_NOT ||
  216.     kind == EK_BAND || kind == EK_BOR || kind == EK_BXOR ||
  217.     kind == EK_LSH || kind == EK_RSH || kind == EK_BNOT ||
  218.     kind == EK_FUNCTION || kind == EK_BICALL);
  219. }
  222. Expr *makeexpr_assign(a, b)
  223. Expr *a, *b;
  224. {
  225.     int i, j;
  226.     Expr *ex, *ex2, *ex3, **ep;
  227.     Meaning *mp;
  228.     Type *tp;
  230.     if (debug>2) { fprintf(outf,"makeexpr_assign("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")n"); }
  231.     if (stringtrunclimit > 0 &&
  232. a->val.type->kind == TK_STRING &&
  233. (i = strmax(a)) <= stringtrunclimit &&
  234. strmax(b) > i) {
  235. note("Possible string truncation in assignment [145]");
  236.     }
  237.     a = un_sign_extend(a);
  238.     b = gentle_cast(b, a->val.type);
  239.     if (b->kind == EK_BICALL && !strcmp(b->val.s, "sprintf") &&
  240.          (mp = istempvar(b->args[0])) != NULL &&
  241.          b->nargs >= 2 &&
  242.          b->args[1]->kind == EK_CONST &&              /* all this handles string appending */
  243.          b->args[1]->val.i > 2 &&                     /*   of the form, "s := s + ..." */
  244.          !strncmp(b->args[1]->val.s, "%s", 2) &&
  245.          exprsame(a, b->args[2], 1) &&
  246.          nosideeffects(a, 0) &&
  247.          (ex = singlevar(a)) != NULL) {
  248.         ex2 = copyexpr(b);
  249.         delfreearg(&ex2, 2);
  250.         freeexpr(ex2->args[1]);
  251.         ex2->args[1] = makeexpr_lstring(b->args[1]->val.s+2,
  252.                                         b->args[1]->val.i-2);
  253.         if (/*(ex = singlevar(a)) != NULL && */
  254.            /* noargdependencies(ex2) && */ !exproccurs(ex2, ex)) {
  255.             freeexpr(b);
  256.             if (ex2->args[1]->val.i == 2 &&     /* s := s + s2 */
  257.                 !strncmp(ex2->args[1]->val.s, "%s", 2)) {
  258.                 canceltempvar(mp);
  259. tp = ex2->val.type;
  260.                 return makeexpr_bicall_2("strcat", tp,
  261.                                          makeexpr_addrstr(a), grabarg(ex2, 2));
  262.             } else if (sprintflength(ex2, 0) >= 0) {    /* s := s + 's2' */
  263. tp = ex2->val.type;
  264.                 return makeexpr_bicall_2("strcat", tp,
  265.                                          makeexpr_addrstr(a), 
  266.                                          makeexpr_unsprintfify(ex2));
  267.             } else {                            /* general case */
  268.                 canceltempvar(mp);
  269.                 freeexpr(ex2->args[0]);
  270.                 ex = makeexpr_bicall_1("strlen", tp_int, copyexpr(a));
  271.                 ex2->args[0] = bumpstring(a, ex, 0);
  272.                 return ex2;
  273.             }
  274.         } else
  275.             freeexpr(ex2);
  276.     }
  277.     if (b->kind == EK_BICALL && !strcmp(b->val.s, "sprintf") &&
  278.          istempvar(b->args[0]) &&
  279.          (ex = singlevar(a)) != NULL) {
  280.         j = -1;     /* does lhs var appear exactly once on rhs? */
  281.         for (i = 2; i < b->nargs; i++) {
  282.             if (exprsame(b->args[i], ex, 1) && j < 0)
  283.                 j = i;
  284.             else if (exproccurs(b->args[i], ex))
  285.                 break;
  286.         }
  287.         if (i == b->nargs && j > 0) {
  288.             b->args[j] = makeexpr_bicall_2("strcpy", tp_str255,
  289.                                            makeexpr_addrstr(b->args[0]),
  290.                                            makeexpr_addrstr(b->args[j]));
  291.             b->args[0] = makeexpr_addrstr(a);
  292.             return b;
  293.         }
  294.     }
  295.     if (structuredfunc(b) && (ex2 = singlevar(a)) != NULL) {
  296. ep = &b->args[0];
  297. i = strlapfunc(b);
  298. while (structuredfunc((ex = *ep))) {
  299.     i = i && strlapfunc(ex);
  300.     ep = &ex->args[0];
  301. }
  302. if ((mp = istempvar(ex)) != NULL &&
  303.     (i || !exproccurs(b, ex2))) {
  304.     canceltempvar(mp);
  305.     freeexpr(*ep);
  306.     *ep = makeexpr_addrstr(a);
  307.     return b;
  308. }
  309.     }
  310.     if (a->val.type->kind == TK_PROCPTR &&
  311.         (mp = istempprocptr(b)) != NULL &&
  312.         nosideeffects(a, 0)) {
  313.         freeexpr(b->args[0]->args[0]->args[0]);
  314.         b->args[0]->args[0]->args[0] = copyexpr(a);
  315. if (b->nargs == 3) {
  316.     freeexpr(b->args[1]->args[0]->args[0]);
  317.     b->args[1]->args[0]->args[0] = a;
  318.     delfreearg(&b, 2);
  319. } else {
  320.     freeexpr(b->args[1]);
  321.     b->args[1] = makeexpr_assign(makeexpr_dotq(a, "link", tp_anyptr),
  322.  makeexpr_nil());
  323. }
  324.         canceltempvar(mp);
  325.         return b;
  326.     }
  327.     if (a->val.type->kind == TK_PROCPTR &&
  328. (b->val.type->kind == TK_CPROCPTR ||
  329.  checkconst(b, 0))) {
  330. ex = makeexpr_dotq(copyexpr(a), "proc", tp_anyptr);
  331. b = makeexpr_comma(makeexpr_assign(ex, b),
  332.    makeexpr_assign(makeexpr_dotq(a, "link", tp_anyptr),
  333.    makeexpr_nil()));
  334. return b;
  335.     }
  336.     if (a->val.type->kind == TK_CPROCPTR &&
  337. (mp = istempprocptr(b)) != NULL &&
  338. nosideeffects(a, 0)) {
  339. freeexpr(b->args[0]->args[0]);
  340. b->args[0]->args[0] = a;
  341. if (b->nargs == 3)
  342.     delfreearg(&b, 1);
  343. delfreearg(&b, 1);
  344. canceltempvar(mp);
  345. return b;
  346.     }
  347.     if (a->val.type->kind == TK_CPROCPTR &&
  348. b->val.type->kind == TK_PROCPTR) {
  349. b = makeexpr_dotq(b, "proc", tp_anyptr);
  350.     }
  351.     if (a->val.type->kind == TK_STRING) {
  352.         if (b->kind == EK_CONST && b->val.i == 0 && !isretvar(a)) {
  353.                 /* optimizing retvar would mess up "return" optimization */
  354.             return makeexpr_assign(makeexpr_hat(a, 0),
  355.                                    makeexpr_char(0));
  356.         }
  357.         a = makeexpr_addrstr(a);
  358.         b = makeexpr_addrstr(b);
  359.         return makeexpr_bicall_2("strcpy", a->val.type, a, b);
  360.     }
  361.     if (a->kind == EK_BICALL && !strcmp(a->val.s, "strlen")) {
  362.         if (b->kind == EK_CAST &&
  363.              ord_type(b->args[0]->val.type)->kind == TK_INTEGER) {
  364.             b = grabarg(b, 0);
  365.         }
  366.         j = (b->kind == EK_PLUS &&      /* handle "s[0] := xxx" */
  367.              b->args[0]->kind == EK_BICALL &&
  368.              !strcmp(b->args[0]->val.s, "strlen") &&
  369.              exprsame(a->args[0], b->args[0]->args[0], 0) &&
  370.              isliteralconst(b->args[1], NULL) == 2);
  371.         if (j && b->args[1]->val.i > 0 &&
  372.                  b->args[1]->val.i <= 5) {     /* lengthening the string */
  373.             a = grabarg(a, 0);
  374.             i = b->args[1]->val.i;
  375.             freeexpr(b);
  376.             if (i == 1)
  377.                 b = makeexpr_string(" ");
  378.             else
  379.                 b = makeexpr_lstring("12345", i);
  380.             return makeexpr_bicall_2("strcat", a->val.type, a, b);
  381.         } else {      /* maybe shortening the string */
  382.             if (!j && !isconstexpr(b, NULL))
  383.                 note("Modification of string length may translate incorrectly [146]");
  384.             a = grabarg(a, 0);
  385.             b = makeexpr_ord(b);
  386.             return makeexpr_assign(makeexpr_index(a, b, NULL),
  387.                                    makeexpr_char(0));
  388.         }
  389.     }
  390.     if (a->val.type->kind == TK_ARRAY ||
  391. (a->val.type->kind == TK_PROCPTR && copystructs < 1) ||
  392. (a->val.type->kind == TK_RECORD &&
  393.  (copystructs < 1 || a->val.type != b->val.type))) {
  394.         ex = makeexpr_sizeof(copyexpr(a), 0);
  395.         ex2 = makeexpr_sizeof(copyexpr(b), 0);
  396.         if (!exprsame(ex, ex2, 1) &&
  397.             !(a->val.type->kind == TK_ARRAY &&
  398.               b->val.type->kind != TK_ARRAY))
  399.             warning("Incompatible types or sizes [167]");
  400.         freeexpr(ex2);
  401.         ex = makeexpr_arglong(ex, (size_t_long != 0));
  402.         a = makeexpr_addrstr(a);
  403.         b = makeexpr_addrstr(b);
  404.         return makeexpr_bicall_3("memcpy", a->val.type, a, b, ex);
  405.     }
  406.     if (a->val.type->kind == TK_SET) {
  407.         a = makeexpr_addrstr(a);
  408.         b = makeexpr_addrstr(b);
  409.         return makeexpr_bicall_2(setcopyname, a->val.type, a, b);
  410.     }
  411.     for (ep = &a; (ex3 = *ep); ) {
  412.         if (ex3->kind == EK_COMMA)
  413.             ep = &ex3->args[ex3->nargs-1];
  414.         else if (ex3->kind == EK_CAST || ex3->kind == EK_ACTCAST)
  415.             ep = &ex3->args[0];
  416.         else
  417.             break;
  418.     }
  419.     if (ex3->kind == EK_BICALL) {
  420.         if (!strcmp(ex3->val.s, getbitsname)) {
  421.     tp = ex3->args[0]->val.type;
  422.     if (tp->kind == TK_ARRAY)
  423. ex3->args[0] = makeexpr_addr(ex3->args[0]);
  424.             ex3->val.type = tp_void;
  425.             if (checkconst(b, 0) && *clrbitsname) {
  426.                 strchange(&ex3->val.s, clrbitsname);
  427.             } else if (*putbitsname &&
  428.                        ((ISCONST(b->kind) &&
  429.                          (b->val.i | ~((1 << (1 << tp->escale)) - 1)) == -1) ||
  430.                         checkconst(b, (1 << (1 << tp->escale)) - 1))) {
  431.                 strchange(&ex3->val.s, putbitsname);
  432.                 insertarg(ep, 2, makeexpr_arglong(makeexpr_ord(b), 0));
  433.             } else {
  434.                 b = makeexpr_arglong(makeexpr_ord(b), 0);
  435.                 if (*storebitsname) {
  436.                     strchange(&ex3->val.s, storebitsname);
  437.                     insertarg(ep, 2, b);
  438.                 } else {
  439.                     if (exproccurs(b, ex3->args[0])) {
  440.                         mp = makestmttempvar(b->val.type, name_TEMP);
  441.                         ex2 = makeexpr_assign(makeexpr_var(mp), b);
  442.                         b = makeexpr_var(mp);
  443.                     } else
  444.                         ex2 = NULL;
  445.                     ex = copyexpr(ex3);
  446.                     strchange(&ex3->val.s, putbitsname);
  447.                     insertarg(&ex3, 2, b);
  448.                     strchange(&ex->val.s, clrbitsname);
  449.                     *ep = makeexpr_comma(ex2, makeexpr_comma(ex, ex3));
  450.                 }
  451.             }
  452.             return a;
  453.         } else if (!strcmp(ex3->val.s, getfbufname)) {
  454.     ex3->val.type = tp_void;
  455.     strchange(&ex3->val.s, putfbufname);
  456.     insertarg(ep, 2, b);
  457.     return a;
  458.         } else if (!strcmp(ex3->val.s, chargetfbufname)) {
  459.     ex3->val.type = tp_void;
  460.     if (*charputfbufname) {
  461. strchange(&ex3->val.s, charputfbufname);
  462. insertarg(ep, 1, b);
  463.     } else {
  464. strchange(&ex3->val.s, putfbufname);
  465. insertarg(ep, 1, makeexpr_type(ex3->val.type->basetype->basetype));
  466. insertarg(ep, 2, b);
  467.     }
  468.     return a;
  469.         } else if (!strcmp(ex3->val.s, arraygetfbufname)) {
  470.     ex3->val.type = tp_void;
  471.     if (*arrayputfbufname) {
  472. strchange(&ex3->val.s, arrayputfbufname);
  473. insertarg(ep, 1, b);
  474.     } else {
  475. strchange(&ex3->val.s, putfbufname);
  476. insertarg(ep, 1, makeexpr_type(ex3->val.type->basetype->basetype));
  477. insertarg(ep, 2, b);
  478.     }
  479.     return a;
  480. }
  481.     }
  482.     while (a->kind == EK_CAST || a->kind == EK_ACTCAST) {
  483. if (ansiC < 2 ||     /* in GNU C, a cast is an lvalue */
  484.     isarithkind(a->args[0]->kind) ||
  485.     (a->val.type->kind == TK_POINTER &&
  486.      a->args[0]->val.type->kind == TK_POINTER)) {
  487.     if (a->kind == EK_CAST)
  488. b = makeexpr_cast(b, a->args[0]->val.type);
  489.     else
  490. b = makeexpr_actcast(b, a->args[0]->val.type);
  491.             a = grabarg(a, 0);
  492.         } else
  493.     break;
  494.     }
  495.     if (a->kind == EK_NEG)
  496. return makeexpr_assign(grabarg(a, 0), makeexpr_neg(b));
  497.     if (a->kind == EK_NOT)
  498. return makeexpr_assign(grabarg(a, 0), makeexpr_not(b));
  499.     if (a->kind == EK_BNOT)
  500. return makeexpr_assign(grabarg(a, 0),
  501.        makeexpr_un(EK_BNOT, b->val.type, b));
  502.     if (a->kind == EK_PLUS) {
  503. for (i = 0; i < a->nargs && a->nargs > 1; ) {
  504.     if (isconstantexpr(a->args[i])) {
  505. b = makeexpr_minus(b, a->args[i]);
  506. deletearg(&a, i);
  507.     } else
  508. i++;
  509. }
  510. if (a->nargs == 1)
  511.     return makeexpr_assign(grabarg(a, 0), b);
  512.     }
  513.     if (a->kind == EK_TIMES) {
  514. for (i = 0; i < a->nargs && a->nargs > 1; ) {
  515.     if (isconstantexpr(a->args[i])) {
  516. if (a->val.type->kind == TK_REAL)
  517.     b = makeexpr_divide(b, a->args[i]);
  518. else {
  519.     if (ISCONST(b->kind) && ISCONST(a->args[i]->kind) &&
  520. (b->val.i % a->args[i]->val.i) != 0) {
  521. break;
  522.     }
  523.     b = makeexpr_div(b, a->args[i]);
  524. }
  525. deletearg(&a, i);
  526.     } else
  527. i++;
  528. }
  529. if (a->nargs == 1)
  530.     return makeexpr_assign(grabarg(a, 0), b);
  531.     }
  532.     if ((a->kind == EK_DIVIDE || a->kind == EK_DIV) &&
  533.  isconstantexpr(a->args[1])) {
  534. b = makeexpr_times(b, a->args[1]);
  535. return makeexpr_assign(a->args[0], b);
  536.     }
  537.     if (a->kind == EK_LSH && isconstantexpr(a->args[1])) {
  538. if (ISCONST(b->kind) && ISCONST(a->args[1]->kind)) {
  539.     if ((b->val.i & ((1L << a->args[1]->val.i)-1)) == 0) {
  540. b->val.i >>= a->args[1]->val.i;
  541. return makeexpr_assign(grabarg(a, 0), b);
  542.     }
  543. } else {
  544.     b = makeexpr_bin(EK_RSH, b->val.type, b, a->args[1]);
  545.     return makeexpr_assign(a->args[0], b);
  546. }
  547.     }
  548.     if (a->kind == EK_RSH && isconstantexpr(a->args[1])) {
  549. if (ISCONST(b->kind) && ISCONST(a->args[1]->kind))
  550.     b->val.i <<= a->args[1]->val.i;
  551. else
  552.     b = makeexpr_bin(EK_LSH, b->val.type, b, a->args[1]);
  553. return makeexpr_assign(a->args[0], b);
  554.     }
  555.     if (isarithkind(a->kind))
  556. warning("Invalid assignment [168]");
  557.     return makeexpr_bin(EK_ASSIGN, a->val.type, a, makeexpr_unlongcast(b));
  558. }
  563. Expr *makeexpr_comma(a, b)
  564. Expr *a, *b;
  565. {
  566.     Type *type;
  568.     if (!a || nosideeffects(a, 1))
  569.         return b;
  570.     if (!b)
  571.         return a;
  572.     type = b->val.type;
  573.     a = commute(a, b, EK_COMMA);
  574.     a->val.type = type;
  575.     return a;
  576. }
  581. int strmax(ex)
  582. Expr *ex;
  583. {
  584.     Meaning *mp;
  585.     long smin, smax;
  586.     Value val;
  587.     Type *type;
  589.     type = ex->val.type;
  590.     if (type->kind == TK_POINTER)
  591.         type = type->basetype;
  592.     if (type->kind == TK_CHAR)
  593.         return 1;
  594.     if (type->kind == TK_ARRAY && type->basetype->kind == TK_CHAR) {
  595.         if (ord_range(type->indextype, &smin, &smax))
  596.             return smax - smin + 1;
  597.         else
  598.             return stringceiling;
  599.     }
  600.     if (type->kind != TK_STRING) {
  601.         intwarning("strmax", "strmax encountered a non-string value [169]");
  602.         return stringceiling;
  603.     }
  604.     if (ex->kind == EK_CONST)
  605.         return ex->val.i;
  606.     if (ex->kind == EK_VAR && foldstrconsts != 0 &&
  607.         (mp = (Meaning *)(ex->val.i))->kind == MK_CONST)
  608.         return mp->val.i;
  609.     if (ex->kind == EK_BICALL) {
  610. if (!strcmp(ex->val.s, strsubname)) {
  611.     if (isliteralconst(ex->args[3], &val) && val.type)
  612. return val.i;
  613. }
  614.     }
  615.     if (ord_range(type->indextype, NULL, &smax))
  616.         return smax;
  617.     else
  618.         return stringceiling;
  619. }
  624. int strhasnull(val)
  625. Value val;
  626. {
  627.     int i;
  629.     for (i = 0; i < val.i; i++) {
  630.         if (!val.s[i])
  631.             return (i == val.i-1) ? 1 : 2;
  632.     }
  633.     return 0;
  634. }
  638. int istempsprintf(ex)
  639. Expr *ex;
  640. {
  641.     return (ex->kind == EK_BICALL && !strcmp(ex->val.s, "sprintf") &&
  642.             ex->nargs >= 2 &&
  643.             istempvar(ex->args[0]) && 
  644.             ex->args[1]->kind == EK_CONST && 
  645.             ex->args[1]->val.type->kind == TK_STRING);
  646. }
  650. Expr *makeexpr_sprintfify(ex)
  651. Expr *ex;
  652. {
  653.     Meaning *tvar;
  654.     char stringbuf[500];
  655.     char *cp, ch;
  656.     int j, nnulls;
  657.     Expr *ex2;
  659.     if (debug>2) { fprintf(outf,"makeexpr_sprintfify("); dumpexpr(ex); fprintf(outf,")n"); }
  660.     if (istempsprintf(ex))
  661.         return ex;
  662.     ex = makeexpr_stringcast(ex);
  663.     tvar = makestmttempvar(tp_str255, name_STRING);
  664.     if (ex->kind == EK_CONST && ex->val.type->kind == TK_STRING) {
  665.         cp = stringbuf;
  666.         nnulls = 0;
  667.         for (j = 0; j < ex->val.i; j++) {
  668.             ch = ex->val.s[j];
  669.             if (!ch) {
  670.                 if (j < ex->val.i-1)
  671.                     note("Null character in sprintf control string [147]");
  672.                 else
  673.                     note("Null character at end of sprintf control string [148]");
  674.                 if (keepnulls) {
  675.                     *cp++ = '%';
  676.                     *cp++ = 'c';
  677.                     nnulls++;
  678.                 }
  679.             } else {
  680.                 *cp++ = ch;
  681.                 if (ch == '%')
  682.                     *cp++ = ch;
  683.             }
  684.         }
  685.         *cp = 0;
  686.         ex = makeexpr_bicall_2("sprintf", tp_str255,
  687.                                makeexpr_var(tvar),
  688.                                makeexpr_string(stringbuf));
  689.         while (--nnulls >= 0)
  690.             insertarg(&ex, 2, makeexpr_char(0));
  691.         return ex;
  692.     } else if (ex->val.type->kind == TK_ARRAY &&
  693.                ex->val.type->basetype->kind == TK_CHAR) {
  694.         ex2 = arraysize(ex->val.type, 0);
  695.         return cleansprintf(
  696.                 makeexpr_bicall_4("sprintf", tp_str255,
  697.                                   makeexpr_var(tvar),
  698.                                   makeexpr_string("%.*s"),
  699.                                   ex2,
  700.                                   makeexpr_addrstr(ex)));
  701.     } else {
  702.         if (ord_type(ex->val.type)->kind == TK_CHAR)
  703.             cp = "%c";
  704.         else if (ex->val.type->kind == TK_STRING)
  705.             cp = "%s";
  706.         else {
  707.             warning("Mixing non-strings with strings [170]");
  708.             return ex;
  709.         }
  710.         return makeexpr_bicall_3("sprintf", tp_str255,
  711.                                  makeexpr_var(tvar),
  712.                                  makeexpr_string(cp),
  713.                                  ex);
  714.     }
  715. }
  719. Expr *makeexpr_unsprintfify(ex)
  720. Expr *ex;
  721. {
  722.     char stringbuf[500];
  723.     char *cp, ch;
  724.     int i;
  726.     if (debug>2) { fprintf(outf,"makeexpr_unsprintfify("); dumpexpr(ex); fprintf(outf,")n"); }
  727.     if (!istempsprintf(ex))
  728.         return ex;
  729.     canceltempvar(istempvar(ex->args[0]));
  730.     for (i = 2; i < ex->nargs; i++) {
  731.         if (ex->args[i]->val.type->kind != TK_CHAR ||
  732.             !checkconst(ex, 0))
  733.             return ex;
  734.     }
  735.     cp = stringbuf;
  736.     for (i = 0; i < ex->args[1]->val.i; i++) {
  737.         ch = ex->args[1]->val.s[i];
  738.         *cp++ = ch;
  739.         if (ch == '%') {
  740.             if (++i == ex->args[1]->val.i)
  741.                 return ex;
  742.             ch = ex->args[1]->val.s[i];
  743.             if (ch == 'c')
  744.                 cp[-1] = 0;
  745.             else if (ch != '%')
  746.                 return ex;
  747.         }
  748.     }
  749.     freeexpr(ex);
  750.     return makeexpr_lstring(stringbuf, cp - stringbuf);
  751. }
  755. /* Returns >= 0 iff unsprintfify would return a string constant */
  757. int sprintflength(ex, allownulls)
  758. Expr *ex;
  759. int allownulls;
  760. {
  761.     int i, len;
  763.     if (!istempsprintf(ex))
  764.         return -1;
  765.     for (i = 2; i < ex->nargs; i++) {
  766.         if (!allownulls ||
  767.             ex->args[i]->val.type->kind != TK_CHAR ||
  768.             !checkconst(ex, 0))
  769.             return -1;
  770.     }
  771.     len = 0;
  772.     for (i = 0; i < ex->args[1]->val.i; i++) {
  773.         len++;
  774.         if (ex->args[1]->val.s[i] == '%') {
  775.             if (++i == ex->args[1]->val.i)
  776.                 return -1;
  777.             if (ex->args[1]->val.s[i] != 'c' &&
  778.                 ex->args[1]->val.s[i] != '%')
  779.                 return -1;
  780.         }
  781.     }
  782.     return len;
  783. }
  787. Expr *makeexpr_concat(a, b, usesprintf)
  788. Expr *a, *b;
  789. int usesprintf;
  790. {
  791.     int i, ii, j, len, nargs;
  792.     Type *type;
  793.     Meaning *mp, *tvar;
  794.     Expr *ex, *args[2];
  795.     int akind[2];
  796.     Value val, val1, val2;
  797.     char formatstr[300];
  799.     if (debug>2) { fprintf(outf,"makeexpr_concat("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")n"); }
  800.     if (!a)
  801.         return b;
  802.     if (!b)
  803.         return a;
  804.     a = makeexpr_stringcast(a);
  805.     b = makeexpr_stringcast(b);
  806.     if (checkconst(a, 0)) {
  807.         freeexpr(a);
  808.         return b;
  809.     }
  810.     if (checkconst(b, 0)) {
  811.         freeexpr(b);
  812.         return a;
  813.     }
  814.     len = strmax(a) + strmax(b);
  815.     type = makestringtype(len);
  816.     if (a->kind == EK_CONST && b->kind == EK_CONST) {
  817.         val1 = a->val;
  818.         val2 = b->val;
  819.         val.i = val1.i + val2.i;
  820.         val.s = ALLOC(val.i+1, char, literals);
  821. val.s[val.i] = 0;
  822.         val.type = type;
  823.         memcpy(val.s, val1.s, val1.i);
  824.         memcpy(val.s + val1.i, val2.s, val2.i);
  825.         freeexpr(a);
  826.         freeexpr(b);
  827.         return makeexpr_val(val);
  828.     }
  829.     tvar = makestmttempvar(type, name_STRING);
  830.     if (sprintf_value != 2 || usesprintf) {
  831.         nargs = 2;                 /* Generate a call to sprintf(), unfolding */
  832.         args[0] = a;               /*  nested sprintf()'s. */
  833.         args[1] = b;
  834.         *formatstr = 0;
  835.         for (i = 0; i < 2; i++) {
  836. #if 1
  837.             ex = args[i] = makeexpr_sprintfify(args[i]);
  838.     if (!ex->args[1] || !ex->args[1]->val.s)
  839. intwarning("makeexpr_concat", "NULL in ex->args[1]");
  840.     else
  841. strncat(formatstr, ex->args[1]->val.s, ex->args[1]->val.i);
  842.             canceltempvar(istempvar(ex->args[0]));
  843.             nargs += (ex->nargs - 2);
  844.             akind[i] = 0;      /* now obsolete */
  845. #else
  846.             ex = args[i];
  847.             if (ex->kind == EK_CONST)
  848.                 ex = makeexpr_sprintfify(ex);
  849.             if (istempsprintf(ex)) {
  850.                 strncat(formatstr, ex->args[1]->val.s, ex->args[1]->val.i);
  851.                 canceltempvar(istempvar(ex->args[0]));
  852.                 nargs += (ex->nargs - 2);
  853.                 akind[i] = 0;
  854.             } else {
  855.                 strcat(formatstr, "%s");
  856.                 nargs++;
  857.                 akind[i] = 1;
  858.             }
  859. #endif
  860.         }
  861.         ex = makeexpr(EK_BICALL, nargs);
  862.         ex->val.type = type;
  863.         ex->val.s = stralloc("sprintf");
  864.         ex->args[0] = makeexpr_var(tvar);
  865.         ex->args[1] = makeexpr_string(formatstr);
  866.         j = 2;
  867.         for (i = 0; i < 2; i++) {
  868.             switch (akind[i]) {
  869.                 case 0:   /* flattened sub-sprintf */
  870.                     for (ii = 2; ii < args[i]->nargs; ii++)
  871.                         ex->args[j++] = copyexpr(args[i]->args[ii]);
  872.                     freeexpr(args[i]);
  873.                     break;
  874.                 case 1:   /* included string expr */
  875.                     ex->args[j++] = args[i];
  876.                     break;
  877.             }
  878.         }
  879.     } else {
  880.         ex = a;
  881.         while (ex->kind == EK_BICALL && !strcmp(ex->val.s, "strcat"))
  882.             ex = ex->args[0];
  883.         if (ex->kind == EK_BICALL && !strcmp(ex->val.s, "strcpy") &&
  884.             (mp = istempvar(ex->args[0])) != NULL) {
  885.             canceltempvar(mp);
  886.             freeexpr(ex->args[0]);
  887.             ex->args[0] = makeexpr_var(tvar);
  888.         } else {
  889.             a = makeexpr_bicall_2("strcpy", type, makeexpr_var(tvar), a);
  890.         }
  891.         ex = makeexpr_bicall_2("strcat", type, a, b);
  892.     }
  893.     if (debug>2) { fprintf(outf,"makeexpr_concat returns "); dumpexpr(ex); fprintf(outf,"n"); }
  894.     return ex;
  895. }
  899. Expr *cleansprintf(ex)
  900. Expr *ex;
  901. {
  902.     int fidx, i, j, k, len, changed = 0;
  903.     char *cp, *bp;
  904.     char fmtbuf[300];
  906.     if (ex->kind != EK_BICALL)
  907. return ex;
  908.     if (!strcmp(ex->val.s, "printf"))
  909. fidx = 0;
  910.     else if (!strcmp(ex->val.s, "sprintf") ||
  911.      !strcmp(ex->val.s, "fprintf"))
  912. fidx = 1;
  913.     else
  914. return ex;
  915.     len = ex->args[fidx]->val.i;
  916.     cp = ex->args[fidx]->val.s;      /* printf("%*d",17,x)  =>  printf("%17d",x) */
  917.     bp = fmtbuf;
  918.     j = fidx + 1;
  919.     for (i = 0; i < len; i++) {
  920.         *bp++ = cp[i];
  921.         if (cp[i] == '%') {
  922.     if (cp[i+1] == 's' && ex->args[j]->kind == EK_CONST) {
  923. bp--;
  924. for (k = 0; k < ex->args[j]->val.i; k++)
  925.     *bp++ = ex->args[j]->val.s[k];
  926. delfreearg(&ex, j);
  927. changed = 1;
  928. i++;
  929. continue;
  930.     }
  931.             for (i++; i < len &&
  932.                       !(isalpha(cp[i]) && cp[i] != 'l'); i++) {
  933.                 if (cp[i] == '*') {
  934.                     if (isliteralconst(ex->args[j], NULL) == 2) {
  935.                         sprintf(bp, "%ld", ex->args[j]->val.i);
  936.                         bp += strlen(bp);
  937.                         delfreearg(&ex, j);
  938.                         changed = 1;
  939.                     } else {
  940.                         *bp++ = cp[i];
  941.                         j++;
  942.                     }
  943.                 } else
  944.                     *bp++ = cp[i];
  945.             }
  946.             if (i < len)
  947.                 *bp++ = cp[i];
  948.             j++;
  949.         }
  950.     }
  951.     *bp = 0;
  952.     if (changed) {
  953.         freeexpr(ex->args[fidx]);
  954.         ex->args[fidx] = makeexpr_string(fmtbuf);
  955.     }
  956.     return ex;
  957. }
  961. Expr *makeexpr_substring(vex, ex, exi, exj)
  962. Expr *vex, *ex, *exi, *exj;
  963. {
  964.     exi = makeexpr_unlongcast(exi);
  965.     exj = makeexpr_longcast(exj, 0);
  966.     ex = bumpstring(ex, exi, 1);
  967.     return cleansprintf(makeexpr_bicall_4("sprintf", tp_str255,
  968.                                           vex,
  969.                                           makeexpr_string("%.*s"),
  970.                                           exj,
  971.                                           ex));
  972. }
  977. Expr *makeexpr_dot(ex, mp)
  978. Expr *ex;
  979. Meaning *mp;
  980. {
  981.     Type *ot1, *ot2;
  982.     Expr *ex2, *ex3, *nex;
  983.     Meaning *tvar;
  985.     if (ex->kind == EK_FUNCTION && copystructfuncs > 0) {
  986.         tvar = makestmttempvar(ex->val.type, name_TEMP);
  987.         ex2 = makeexpr_assign(makeexpr_var(tvar), ex);
  988.         ex = makeexpr_var(tvar);
  989.     } else
  990.         ex2 = NULL;
  991.     if (mp->constdefn) {
  992.         nex = makeexpr(EK_MACARG, 0);
  993.         nex->val.type = tp_integer;
  994.         ex3 = replaceexprexpr(copyexpr(mp->constdefn), nex, ex);
  995.         freeexpr(ex);
  996.         freeexpr(nex);
  997.         ex = gentle_cast(ex3, mp->val.type);
  998.     } else {
  999.         ex = makeexpr_un(EK_DOT, mp->type, ex);
  1000.         ex->val.i = (long)mp;
  1001.         ot1 = ord_type(mp->type);
  1002.         ot2 = ord_type(mp->val.type);
  1003.         if (ot1->kind != ot2->kind && ot2->kind == TK_ENUM && ot2->meaning && useenum)
  1004.             ex = makeexpr_cast(ex, mp->val.type);
  1005.         else if (mp->val.i && !hassignedchar &&
  1006.  (mp->type == tp_sint || mp->type == tp_abyte)) {
  1007.             if (*signextname) {
  1008.                 ex = makeexpr_bicall_2(signextname, tp_integer,
  1009.                                        ex, makeexpr_long(mp->val.i));
  1010.             } else
  1011.                 note(format_s("Unable to sign-extend field %s [149]", mp->name));
  1012.         }
  1013.     }
  1014.     ex->val.type = mp->val.type;
  1015.     return makeexpr_comma(ex2, ex);
  1016. }
  1020. Expr *makeexpr_dotq(ex, name, type)
  1021. Expr *ex;
  1022. char *name;
  1023. Type *type;
  1024. {
  1025.     ex = makeexpr_un(EK_DOT, type, ex);
  1026.     ex->val.s = stralloc(name);
  1027.     return ex;
  1028. }
  1032. Expr *strmax_func(ex)
  1033. Expr *ex;
  1034. {
  1035.     Meaning *mp;
  1036.     Expr *ex2;
  1037.     Type *type;
  1039.     type = ex->val.type;
  1040.     if (type->kind == TK_POINTER) {
  1041.         intwarning("strmax_func", "got a pointer instead of a string [171]");
  1042.         type = type->basetype;
  1043.     }
  1044.     if (type->kind == TK_CHAR)
  1045.         return makeexpr_long(1);
  1046.     if (type->kind != TK_STRING) {
  1047.         warning("STRMAX of non-string value [172]");
  1048.         return makeexpr_long(stringceiling);
  1049.     }
  1050.     if (ex->kind == EK_CONST)
  1051. return makeexpr_long(ex->val.i);
  1052.     if (ex->kind == EK_VAR &&
  1053. (mp = (Meaning *)ex->val.i)->kind == MK_CONST &&
  1054. mp->type == tp_str255)
  1055. return makeexpr_long(mp->val.i);
  1056.     if (ex->kind == EK_VAR &&
  1057.         (mp = (Meaning *)ex->val.i)->kind == MK_VARPARAM &&
  1058.         mp->type == tp_strptr) {
  1059. if (mp->anyvarflag) {
  1060.     if (mp->ctx != curctx && mp->ctx->kind == MK_FUNCTION)
  1061. note(format_s("Reference to STRMAX of parent proc's "%s" must be fixed [150]",
  1062.       mp->name));
  1063.     return makeexpr_name(format_s(name_STRMAX, mp->name), tp_int);
  1064. } else
  1065.     note(format_s("STRMAX of "%s" wants VarStrings=1 [151]", mp->name));
  1066.     }
  1067.     ord_range_expr(type->indextype, NULL, &ex2);
  1068.     return copyexpr(ex2);
  1069. }
  1074. Expr *makeexpr_nil()
  1075. {
  1076.     Expr *ex;
  1078.     ex = makeexpr(EK_CONST, 0);
  1079.     ex->val.type = tp_anyptr;
  1080.     ex->val.i = 0;
  1081.     ex->val.s = NULL;
  1082.     return ex;
  1083. }
  1087. Expr *makeexpr_ctx(ctx)
  1088. Meaning *ctx;
  1089. {
  1090.     Expr *ex;
  1092.     ex = makeexpr(EK_CTX, 0);
  1093.     ex->val.type = tp_text;     /* handy pointer type */
  1094.     ex->val.i = (long)ctx;
  1095.     return ex;
  1096. }
  1101. Expr *force_signed(ex)
  1102. Expr *ex;
  1103. {
  1104.     Type *tp;
  1106.     if (isliteralconst(ex, NULL) == 2 && ex->nargs == 0)
  1107.         return ex;
  1108.     tp = true_type(ex);
  1109.     if (tp == tp_ushort || tp == tp_ubyte || tp == tp_uchar)
  1110. return makeexpr_cast(ex, tp_sshort);
  1111.     else if (tp == tp_unsigned || tp == tp_uint) {
  1112. if (exprlongness(ex) < 0)
  1113.     return makeexpr_cast(ex, tp_sint);
  1114. else
  1115.     return makeexpr_cast(ex, tp_integer);
  1116.     }
  1117.     return ex;
  1118. }
  1122. Expr *force_unsigned(ex)
  1123. Expr *ex;
  1124. {
  1125.     Type *tp;
  1127.     if (isliteralconst(ex, NULL) == 2 && !expr_is_neg(ex))
  1128.         return ex;
  1129.     tp = true_type(ex);
  1130.     if (tp == tp_unsigned || tp == tp_uint || tp == tp_ushort ||
  1131. tp == tp_ubyte || tp == tp_uchar)
  1132.         return ex;
  1133.     if (tp->kind == TK_CHAR)
  1134. return makeexpr_actcast(ex, tp_uchar);
  1135.     else if (exprlongness(ex) < 0)
  1136.         return makeexpr_cast(ex, tp_uint);
  1137.     else
  1138.         return makeexpr_cast(ex, tp_unsigned);
  1139. }
  1144. #define CHECKSIZE(size) (((size) > 0 && (size)%charsize == 0) ? (size)/charsize : 0)
  1146. long type_sizeof(type, pasc)
  1147. Type *type;
  1148. int pasc;
  1149. {
  1150.     long s1, smin, smax;
  1151.     int charsize = (sizeof_char) ? sizeof_char : CHAR_BIT;      /* from <limits.h> */
  1153.     switch (type->kind) {
  1155.         case TK_INTEGER:
  1156.             if (type == tp_integer ||
  1157.                 type == tp_unsigned)
  1158.                 return pasc ? 4 : CHECKSIZE(sizeof_integer);
  1159.             else
  1160.                 return pasc ? 2 : CHECKSIZE(sizeof_short);
  1162.         case TK_CHAR:
  1163.         case TK_BOOLEAN:
  1164.             return 1;
  1166.         case TK_SUBR:
  1167.             type = findbasetype(type, 0);
  1168.             if (pasc) {
  1169.                 if (type == tp_integer || type == tp_unsigned)
  1170.                     return 4;
  1171.                 else
  1172.                     return 2;
  1173.             } else {
  1174.                 if (type == tp_abyte || type == tp_ubyte || type == tp_sbyte)
  1175.                     return 1;
  1176.                 else if (type == tp_ushort || type == tp_sshort)
  1177.                     return CHECKSIZE(sizeof_short);
  1178.                 else
  1179.                     return CHECKSIZE(sizeof_integer);
  1180.             }
  1182.         case TK_POINTER:
  1183.             return pasc ? 4 : CHECKSIZE(sizeof_pointer);
  1185.         case TK_REAL:
  1186.     if (type == tp_longreal)
  1187. return pasc ? (which_lang == LANG_TURBO ? 6 : 8) : CHECKSIZE(sizeof_double);
  1188.     else
  1189. return pasc ? 4 : CHECKSIZE(sizeof_float);
  1191.         case TK_ENUM:
  1192.     if (!pasc)
  1193. return CHECKSIZE(sizeof_enum);
  1194.     type = findbasetype(type, 0);
  1195.             return type->kind != TK_ENUM ? type_sizeof(type, pasc)
  1196.    : CHECKSIZE(pascalenumsize);
  1198.         case TK_SMALLSET:
  1199.         case TK_SMALLARRAY:
  1200.             return pasc ? 0 : type_sizeof(type->basetype, pasc);
  1202.         case TK_ARRAY:
  1203.             s1 = type_sizeof(type->basetype, pasc);
  1204.             if (s1 && ord_range(type->indextype, &smin, &smax))
  1205.                 return s1 * (smax - smin + 1);
  1206.             else
  1207.                 return 0;
  1209.         case TK_RECORD:
  1210.             if (pasc && type->meaning) {
  1211.                 if (!strcmp(type->meaning->sym->name, "NA_WORD"))
  1212.                     return 2;
  1213.                 else if (!strcmp(type->meaning->sym->name, "NA_LONGWORD"))
  1214.                     return 4;
  1215.                 else if (!strcmp(type->meaning->sym->name, "NA_QUADWORD"))
  1216.                     return 8;
  1217.                 else
  1218.                     return 0;
  1219.             } else
  1220.                 return 0;
  1222.         default:
  1223.             return 0;
  1224.     }
  1225. }
  1229. Static Value eval_expr_either(ex, pasc)
  1230. Expr *ex;
  1231. int pasc;
  1232. {
  1233.     Value val, val2;
  1234.     Meaning *mp;
  1235.     int i;
  1237.     if (debug>2) { fprintf(outf,"eval_expr("); dumpexpr(ex); fprintf(outf,")n"); }
  1238.     switch (ex->kind) {
  1240.         case EK_CONST:
  1241.         case EK_LONGCONST:
  1242.             return ex->val;
  1244.         case EK_VAR:
  1245.             mp = (Meaning *) ex->val.i;
  1246.             if (mp->kind == MK_CONST && 
  1247.                 (foldconsts != 0 ||
  1248.                  mp == mp_maxint || mp == mp_minint))
  1249.                 return mp->val;
  1250.             break;
  1252.         case EK_SIZEOF:
  1253.             i = type_sizeof(ex->args[0]->val.type, pasc);
  1254.             if (i)
  1255.                 return make_ord(tp_integer, i);
  1256.             break;
  1258.         case EK_PLUS:
  1259.             val = eval_expr_either(ex->args[0], pasc);
  1260.             if (!val.type || ord_type(val.type) != tp_integer)
  1261.                 val.type = NULL;
  1262.             for (i = 1; val.type && i < ex->nargs; i++) {
  1263.                 val2 = eval_expr_either(ex->args[i], pasc);
  1264.                 if (!val2.type || ord_type(val2.type) != tp_integer)
  1265.                     val.type = NULL;
  1266.                 else
  1267.                     val.i += val2.i;
  1268.             }
  1269.             return val;
  1271.         case EK_TIMES:
  1272.             val = eval_expr_either(ex->args[0], pasc);
  1273.             if (!val.type || ord_type(val.type) != tp_integer)
  1274.                 val.type = NULL;
  1275.             for (i = 1; val.type && i < ex->nargs; i++) {
  1276.                 val2 = eval_expr_either(ex->args[i], pasc);
  1277.                 if (!val2.type || ord_type(val2.type) != tp_integer)
  1278.                     val.type = NULL;
  1279.                 else
  1280.                     val.i *= val2.i;
  1281.             }
  1282.             return val;
  1284.         case EK_DIV:
  1285.             val = eval_expr_either(ex->args[0], pasc);
  1286.             val2 = eval_expr_either(ex->args[1], pasc);
  1287.             if (val.type && ord_type(val.type) == tp_integer &&
  1288.                 val2.type && ord_type(val2.type) == tp_integer && val2.i) {
  1289.                 val.i /= val2.i;
  1290.                 return val;
  1291.             }
  1292.             break;
  1294.         case EK_MOD:
  1295.             val = eval_expr_either(ex->args[0], pasc);
  1296.             val2 = eval_expr_either(ex->args[1], pasc);
  1297.             if (val.type && ord_type(val.type) == tp_integer &&
  1298.                 val2.type && ord_type(val2.type) == tp_integer && val2.i) {
  1299.                 val.i %= val2.i;
  1300.                 return val;
  1301.             }
  1302.             break;
  1304.         case EK_NEG:
  1305.             val = eval_expr_either(ex->args[0], pasc);
  1306.             if (val.type) {
  1307.                 val.i = -val.i;
  1308.                 return val;
  1309.             }
  1310.             break;
  1312.         case EK_LSH:
  1313.             val = eval_expr_either(ex->args[0], pasc);
  1314.             val2 = eval_expr_either(ex->args[1], pasc);
  1315.             if (val.type && val2.type) {
  1316.                 val.i <<= val2.i;
  1317.                 return val;
  1318.             }
  1319.             break;
  1321.         case EK_RSH:
  1322.             val = eval_expr_either(ex->args[0], pasc);
  1323.             val2 = eval_expr_either(ex->args[1], pasc);
  1324.             if (val.type && val2.type) {
  1325.                 val.i >>= val2.i;
  1326.                 return val;
  1327.             }
  1328.             break;
  1330.         case EK_BAND:
  1331.             val = eval_expr_either(ex->args[0], pasc);
  1332.             val2 = eval_expr_either(ex->args[1], pasc);
  1333.             if (val.type && val2.type) {
  1334.                 val.i &= val2.i;
  1335.                 return val;
  1336.             }
  1337.             break;
  1339.         case EK_BOR:
  1340.             val = eval_expr_either(ex->args[0], pasc);
  1341.             val2 = eval_expr_either(ex->args[1], pasc);
  1342.             if (val.type && val2.type) {
  1343.                 val.i |= val2.i;
  1344.                 return val;
  1345.             }
  1346.             break;
  1348.         case EK_BXOR:
  1349.             val = eval_expr_either(ex->args[0], pasc);
  1350.             val2 = eval_expr_either(ex->args[1], pasc);
  1351.             if (val.type && val2.type) {
  1352.                 val.i ^= val2.i;
  1353.                 return val;
  1354.             }
  1355.             break;
  1357.         case EK_BNOT:
  1358.             val = eval_expr_either(ex->args[0], pasc);
  1359.             if (val.type) {
  1360.                 val.i = ~val.i;
  1361.                 return val;
  1362.             }
  1363.             break;
  1365.         case EK_EQ:
  1366.         case EK_NE:
  1367.         case EK_GT:
  1368.         case EK_LT:
  1369.         case EK_GE:
  1370.         case EK_LE:
  1371.             val = eval_expr_either(ex->args[0], pasc);
  1372.             val2 = eval_expr_either(ex->args[1], pasc);
  1373.             if (val.type) {
  1374.                 if (val.i == val2.i)
  1375.                     val.i = (ex->kind == EK_EQ || ex->kind == EK_GE || ex->kind == EK_LE);
  1376.                 else if (val.i < val2.i)
  1377.                     val.i = (ex->kind == EK_LT || ex->kind == EK_LE || ex->kind == EK_NE);
  1378.                 else
  1379.                     val.i = (ex->kind == EK_GT || ex->kind == EK_GE || ex->kind == EK_NE);
  1380.                 val.type = tp_boolean;
  1381.                 return val;
  1382.             }
  1383.             break;
  1385.         case EK_NOT:
  1386.             val = eval_expr_either(ex->args[0], pasc);
  1387.             if (val.type)
  1388.                 val.i = !val.i;
  1389.             return val;
  1391.         case EK_AND:
  1392.             for (i = 0; i < ex->nargs; i++) {
  1393.                 val = eval_expr_either(ex->args[i], pasc);
  1394.                 if (!val.type || !val.i)
  1395.                     return val;
  1396.             }
  1397.             return val;
  1399.         case EK_OR:
  1400.             for (i = 0; i < ex->nargs; i++) {
  1401.                 val = eval_expr_either(ex->args[i], pasc);
  1402.                 if (!val.type || val.i)
  1403.                     return val;
  1404.             }
  1405.             return val;
  1407.         case EK_COMMA:
  1408.             return eval_expr_either(ex->args[ex->nargs-1], pasc);
  1410. default:
  1411.     break;
  1412.     }
  1413.     val.type = NULL;
  1414.     return val;
  1415. }
  1418. Value eval_expr(ex)
  1419. Expr *ex;
  1420. {
  1421.     return eval_expr_either(ex, 0);
  1422. }
  1425. Value eval_expr_consts(ex)
  1426. Expr *ex;
  1427. {
  1428.     Value val;
  1429.     short save_fold = foldconsts;
  1431.     foldconsts = 1;
  1432.     val = eval_expr_either(ex, 0);
  1433.     foldconsts = save_fold;
  1434.     return val;
  1435. }
  1438. Value eval_expr_pasc(ex)
  1439. Expr *ex;
  1440. {
  1441.     return eval_expr_either(ex, 1);
  1442. }
  1446. int expr_is_const(ex)
  1447. Expr *ex;
  1448. {
  1449.     int i;
  1451.     switch (ex->kind) {
  1453.         case EK_CONST:
  1454.         case EK_LONGCONST:
  1455.         case EK_SIZEOF:
  1456.             return 1;
  1458.         case EK_VAR:
  1459.             return (((Meaning *)ex->val.i)->kind == MK_CONST);
  1461.         case EK_HAT:
  1462.         case EK_ASSIGN:
  1463.         case EK_POSTINC:
  1464.         case EK_POSTDEC:
  1465.             return 0;
  1467.         case EK_ADDR:
  1468.             if (ex->args[0]->kind == EK_VAR)
  1469.                 return 1;
  1470.             return 0;   /* conservative */
  1472.         case EK_FUNCTION:
  1473.             if (!nosideeffects_func(ex))
  1474.                 return 0;
  1475.             break;
  1477.         case EK_BICALL:
  1478.             if (!nosideeffects_func(ex))
  1479.                 return 0;
  1480.             break;
  1482. default:
  1483.     break;
  1484.     }
  1485.     for (i = 0; i < ex->nargs; i++) {
  1486.         if (!expr_is_const(ex->args[i]))
  1487.             return 0;
  1488.     }
  1489.     return 1;
  1490. }
  1496. Expr *eatcasts(ex)
  1497. Expr *ex;
  1498. {
  1499.     while (ex->kind == EK_CAST)
  1500.         ex = grabarg(ex, 0);
  1501.     return ex;
  1502. }
  1508. /* End. */