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

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

编译器/解释器

开发平台：

C/C++

expr.c.2：源码内容
  1.                                                   a->args[i]->val.i - a->args[j]->val.i);
  2.                     for (k = 0; k < - a->args[j]->val.i; k++)
  3.                         a->args[i]->val.s[k] = '>';
  4.                     delfreearg(&a, j);
  5.                     j--;
  6.                 }
  7.             }
  8.         }
  9.     }
  10.     if (checkconst(a->args[a->nargs-1], 0))
  11.         delfreearg(&a, a->nargs-1);
  12.     for (i = 0; i < a->nargs; i++) {
  13.         if (a->args[i]->kind == EK_NEG && nosideeffects(a->args[i], 1)) {
  14.             for (j = 0; j < a->nargs; j++) {
  15.                 if (exprsame(a->args[j], a->args[i]->args[0], 1)) {
  16.                     delfreearg(&a, i);
  17.                     if (i < j) j--; else i--;
  18.                     delfreearg(&a, j);
  19.                     i--;
  20.                     break;
  21.                 }
  22.             }
  23.         }
  24.     }
  25.     if (a->nargs < 2) {
  26.         if (a->nargs < 1) {
  27.     type = a->val.type;
  28.             FREE(a);
  29.             a = gentle_cast(makeexpr_long(0), type);
  30.     a->val.type = type;
  31.     return a;
  32.         } else {
  33.             b = a->args[0];
  34.             FREE(a);
  35.             return b;
  36.         }
  37.     }
  38.     if (a->nargs == 2 && ISCONST(a->args[1]->kind) &&
  39. a->args[1]->val.i <= -127 &&
  40. true_type(a->args[0]) == tp_char && signedchars != 0) {
  41. a->args[0] = force_unsigned(a->args[0]);
  42.     }
  43.     if (a->nargs > 2 &&
  44. ISCONST(a->args[a->nargs-1]->kind) &&
  45. ISCONST(a->args[a->nargs-2]->kind) &&
  46. ischartype(a->args[a->nargs-1]) &&
  47. ischartype(a->args[a->nargs-2])) {
  48. i = a->args[a->nargs-1]->val.i;
  49. j = a->args[a->nargs-2]->val.i;
  50. if ((i == 'a' || i == 'A' || i == -'a' || i == -'A') &&
  51.     (j == 'a' || j == 'A' || j == -'a' || j == -'A')) {
  52.     if (abs(i+j) == 32) {
  53. delfreearg(&a, a->nargs-1);
  54. delsimpfreearg(&a, a->nargs-1);
  55. a = makeexpr_bicall_1((i+j > 0) ? "_tolower" : "_toupper",
  56.       tp_char, a);
  57.     }
  58. }
  59.     }
  60.     return a;
  61. }
  64. Expr *makeexpr_minus(a, b)
  65. Expr *a, *b;
  66. {
  67.     int okneg;
  69.     if (debug>2) { fprintf(outf,"makeexpr_minus("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")n"); }
  70.     if (ISCONST(b->kind) && b->val.i == 0 &&       /* kludge for array indexing */
  71.         ord_type(b->val.type)->kind == TK_ENUM) {
  72.         b->val.type = tp_integer;
  73.     }
  74.     okneg = (a->kind != EK_PLUS && b->kind != EK_PLUS);
  75.     a = makeexpr_plus(a, makeexpr_neg(b));
  76.     if (okneg && a->kind == EK_PLUS)
  77.         a->val.i = 1;   /* this flag says to write as "a-b" if possible */
  78.     return a;
  79. }
  82. Expr *makeexpr_inc(a, b)
  83. Expr *a, *b;
  84. {
  85.     Type *type;
  87.     type = a->val.type;
  88.     a = makeexpr_plus(makeexpr_charcast(a), b);
  89.     if (ord_type(type)->kind != TK_INTEGER &&
  90. ord_type(type)->kind != TK_CHAR)
  91. a = makeexpr_cast(a, type);
  92.     return a;
  93. }
  97. /* Apply the distributive law for a sum of products */
  98. Expr *distribute_plus(ex)
  99. Expr *ex;
  100. {
  101.     int i, j, icom;
  102.     Expr *common, *outer, *ex2, **exp;
  104.     if (debug>2) { fprintf(outf,"distribute_plus("); dumpexpr(ex); fprintf(outf,")n"); }
  105.     if (ex->kind != EK_PLUS)
  106.         return ex;
  107.     for (i = 0; i < ex->nargs; i++)
  108.         if (ex->args[i]->kind == EK_TIMES)
  109.             break;
  110.     if (i == ex->nargs)
  111.         return ex;
  112.     outer = NULL;
  113.     icom = 0;
  114.     for (;;) {
  115. ex2 = ex->args[0];
  116. if (ex2->kind == EK_NEG)
  117.     ex2 = ex2->args[0];
  118.         if (ex2->kind == EK_TIMES) {
  119.     if (icom >= ex2->nargs)
  120. break;
  121.             common = ex2->args[icom];
  122.     if (common->kind == EK_NEG)
  123. common = common->args[0];
  124.         } else {
  125.     if (icom > 0)
  126. break;
  127.             common = ex2;
  128.     icom++;
  129. }
  130.         for (i = 1; i < ex->nargs; i++) {
  131.     ex2 = ex->args[i];
  132.     if (ex2->kind == EK_NEG)
  133. ex2 = ex2->args[i];
  134.             if (ex2->kind == EK_TIMES) {
  135.                 for (j = ex2->nargs; --j >= 0; ) {
  136.                     if (exprsame(ex2->args[j], common, 1) ||
  137. (ex2->args[j]->kind == EK_NEG &&
  138.  exprsame(ex2->args[j]->args[0], common, 1)))
  139.                         break;
  140.                 }
  141.                 if (j < 0)
  142.                     break;
  143.             } else {
  144.                 if (!exprsame(ex2, common, 1))
  145.                     break;
  146.             }
  147.         }
  148.         if (i == ex->nargs) {
  149.             if (debug>2) { fprintf(outf,"distribute_plus does "); dumpexpr(common); fprintf(outf,"n"); }
  150.     common = copyexpr(common);
  151.             for (i = 0; i < ex->nargs; i++) {
  152. if (ex->args[i]->kind == EK_NEG)
  153.     ex2 = *(exp = &ex->args[i]->args[0]);
  154. else
  155.     ex2 = *(exp = &ex->args[i]);
  156. if (ex2->kind == EK_TIMES) {
  157.                     for (j = ex2->nargs; --j >= 0; ) {
  158.                         if (exprsame(ex2->args[j], common, 1)) {
  159.                             delsimpfreearg(exp, j);
  160.                             break;
  161.                         } else if (ex2->args[j]->kind == EK_NEG &&
  162.    exprsame(ex2->args[j]->args[0], common,1)) {
  163.     freeexpr(ex2->args[j]);
  164.     ex2->args[j] = makeexpr_long(-1);
  165.     break;
  166. }
  167.                     }
  168. } else {
  169.     freeexpr(ex2);
  170.     *exp = makeexpr_long(1);
  171.                 }
  172. ex->args[i] = resimplify(ex->args[i]);
  173.             }
  174.             outer = makeexpr_times(common, outer);
  175.         } else
  176.     icom++;
  177.     }
  178.     return makeexpr_times(resimplify(ex), outer);
  179. }
  185. Expr *makeexpr_times(a, b)
  186. Expr *a, *b;
  187. {
  188.     int i, n;
  189.     Type *type;
  191.     if (debug>2) { fprintf(outf,"makeexpr_times("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")n"); }
  192.     if (!a)
  193.         return b;
  194.     if (!b)
  195.         return a;
  196.     a = commute(a, b, EK_TIMES);
  197.     if (a->val.type->kind == TK_INTEGER) {
  198.         i = a->nargs-1;
  199.         if (i > 0 && ISCONST(a->args[i-1]->kind)) {
  200.             a->args[i-1]->val.i *= a->args[i]->val.i;
  201.             delfreearg(&a, i);
  202.         }
  203.     }
  204.     for (i = n = 0; i < a->nargs; i++) {
  205.         if (expr_neg_cost(a->args[i]) < 0)
  206.             n++;
  207.     }
  208.     if (n & 1) {
  209.         for (i = 0; i < a->nargs; i++) {
  210.             if (ISCONST(a->args[i]->kind) &&
  211.                 expr_neg_cost(a->args[i]) >= 0) {
  212.                 a->args[i] = makeexpr_neg(a->args[i]);
  213.                 n++;
  214.                 break;
  215.             }
  216.         }
  217.     } else
  218.         n++;
  219.     for (i = 0; i < a->nargs && n >= 2; i++) {
  220.         if (expr_neg_cost(a->args[i]) < 0) {
  221.             a->args[i] = makeexpr_neg(a->args[i]);
  222.             n--;
  223.         }
  224.     }
  225.     if (checkconst(a->args[a->nargs-1], 1))
  226.         delfreearg(&a, a->nargs-1);
  227.     if (checkconst(a->args[a->nargs-1], -1)) {
  228.         delfreearg(&a, a->nargs-1);
  229. a->args[0] = makeexpr_neg(a->args[0]);
  230.     }
  231.     if (checkconst(a->args[a->nargs-1], 0) && nosideeffects(a, 1)) {
  232.         type = a->val.type;
  233.         return makeexpr_cast(grabarg(a, a->nargs-1), type);
  234.     }
  235.     if (a->nargs < 2) {
  236.         if (a->nargs < 1) {
  237.             FREE(a);
  238.             a = makeexpr_long(1);
  239.         } else {
  240.             b = a->args[0];
  241.             FREE(a);
  242.             a = b;
  243.         }
  244.     }
  245.     return a;
  246. }
  250. Expr *makeexpr_sqr(ex, cube)
  251. Expr *ex;
  252. int cube;
  253. {
  254.     Expr *ex2;
  255.     Meaning *tvar;
  256.     Type *type;
  258.     if (exprspeed(ex) <= 2 && nosideeffects(ex, 0)) {
  259. ex2 = NULL;
  260.     } else {
  261. type = (ex->val.type->kind == TK_REAL) ? tp_longreal : tp_integer;
  262. tvar = makestmttempvar(type, name_TEMP);
  263. ex2 = makeexpr_assign(makeexpr_var(tvar), ex);
  264. ex = makeexpr_var(tvar);
  265.     }
  266.     if (cube)
  267. ex = makeexpr_times(ex, makeexpr_times(copyexpr(ex), copyexpr(ex)));
  268.     else
  269. ex = makeexpr_times(ex, copyexpr(ex));
  270.     return makeexpr_comma(ex2, ex);
  271. }
  275. Expr *makeexpr_divide(a, b)
  276. Expr *a, *b;
  277. {
  278.     Expr *ex;
  279.     int p;
  281.     if (debug>2) { fprintf(outf,"makeexpr_divide("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")n"); }
  282.     if (a->val.type->kind != TK_REAL &&
  283. b->val.type->kind != TK_REAL) {     /* must do a real division */
  284.         ex = docast(a, tp_longreal);
  285.         if (ex)
  286.             a = ex;
  287.         else {
  288.             ex = docast(b, tp_longreal);
  289.             if (ex)
  290.                 b = ex;
  291.             else
  292.                 a = makeexpr_cast(a, tp_longreal);
  293.         }
  294.     }
  295.     if (a->kind == EK_TIMES) {
  296. for (p = 0; p < a->nargs; p++)
  297.     if (exprsame(a->args[p], b, 1))
  298. break;
  299. if (p < a->nargs) {
  300.     delfreearg(&a, p);
  301.     freeexpr(b);
  302.     if (a->nargs == 1)
  303. return grabarg(a, 0);
  304.     else
  305. return a;
  306. }
  307.     }
  308.     if (expr_neg_cost(a) < 0 && expr_neg_cost(b) < 0) {
  309.         a = makeexpr_neg(a);
  310.         b = makeexpr_neg(b);
  311.     }
  312.     if (checkconst(b, 0))
  313.         warning("Division by zero [163]");
  314.     return makeexpr_bin(EK_DIVIDE, tp_longreal, a, b);
  315. }
  320. int gcd(a, b)
  321. int a, b;
  322. {
  323.     if (a < 0) a = -a;
  324.     if (b < 0) b = -b;
  325.     while (a != 0) {
  326. b %= a;
  327. if (b != 0)
  328.     a %= b;
  329. else
  330.     return a;
  331.     }
  332.     return b;
  333. }
  337. /* possible signs of ex: 1=may be neg, 2=may be zero, 4=may be pos */
  339. int negsigns(mask)
  340. int mask;
  341. {
  342.     return (mask & 2) |
  343.    ((mask & 1) << 2) |
  344.    ((mask & 4) >> 2);
  345. }
  348. int possiblesigns(ex)
  349. Expr *ex;
  350. {
  351.     Value val;
  352.     Type *tp;
  353.     char *cp;
  354.     int i, mask, mask2;
  356.     if (isliteralconst(ex, &val) && val.type) {
  357. if (val.type == tp_real || val.type == tp_longreal) {
  358.     if (realzero(val.s))
  359. return 2;
  360.     if (*val.s == '-')
  361. return 1;
  362.     return 4;
  363. } else
  364.     return (val.i < 0) ? 1 : (val.i == 0) ? 2 : 4;
  365.     }
  366.     if (ex->kind == EK_CAST &&
  367. similartypes(ex->val.type, ex->args[0]->val.type))
  368. return possiblesigns(ex->args[0]);
  369.     if (ex->kind == EK_NEG)
  370. return negsigns(possiblesigns(ex->args[0]));
  371.     if (ex->kind == EK_TIMES || ex->kind == EK_DIVIDE) {
  372. mask = possiblesigns(ex->args[0]);
  373. for (i = 1; i < ex->nargs; i++) {
  374.     mask2 = possiblesigns(ex->args[i]);
  375.     if (mask2 & 2)
  376. mask |= 2;
  377.     if ((mask2 & (1|4)) == 1)
  378. mask = negsigns(mask);
  379.     else if ((mask2 & (1|4)) != 4)
  380. mask = 1|2|4;
  381. }
  382. return mask;
  383.     }
  384.     if (ex->kind == EK_DIV || ex->kind == EK_MOD) {
  385. mask = possiblesigns(ex->args[0]);
  386. mask2 = possiblesigns(ex->args[1]);
  387. if (!((mask | mask2) & 1))
  388.     return 2|4;
  389.     }
  390.     if (ex->kind == EK_PLUS) {
  391. mask = 0;
  392. for (i = 0; i < ex->nargs; i++) {
  393.     mask2 = possiblesigns(ex->args[i]);
  394.     if ((mask & negsigns(mask2)) & (1|4))
  395. mask |= (1|2|4);
  396.     else
  397. mask |= mask2;
  398. }
  399. return mask;
  400.     }
  401.     if (ex->kind == EK_COND) {
  402. return possiblesigns(ex->args[1]) | possiblesigns(ex->args[2]);
  403.     }
  404.     if (ex->kind == EK_EQ || ex->kind == EK_LT || ex->kind == EK_GT ||
  405. ex->kind == EK_NE || ex->kind == EK_LE || ex->kind == EK_GE ||
  406. ex->kind == EK_AND || ex->kind == EK_OR || ex->kind == EK_NOT)
  407. return 2|4;
  408.     if (ex->kind == EK_BICALL) {
  409. cp = ex->val.s;
  410. if (!strcmp(cp, "strlen") ||
  411.     !strcmp(cp, "abs") ||
  412.     !strcmp(cp, "labs") ||
  413.     !strcmp(cp, "fabs"))
  414.     return 2|4;
  415.     }
  416.     tp = (ex->kind == EK_VAR) ? ((Meaning *)ex->val.i)->type : ex->val.type;
  417.     if (ord_range(ex->val.type, &val.i, NULL)) {
  418. if (val.i > 0)
  419.     return 4;
  420. if (val.i >= 0)
  421.     return 2|4;
  422.     }
  423.     if (ord_range(ex->val.type, NULL, &val.i)) {
  424. if (val.i < 0)
  425.     return 1;
  426. if (val.i <= 0)
  427.     return 1|2;
  428.     }
  429.     return 1|2|4;
  430. }
  436. Expr *dodivmod(funcname, ekind, a, b)
  437. char *funcname;
  438. enum exprkind ekind;
  439. Expr *a, *b;
  440. {
  441.     Meaning *tvar;
  442.     Type *type;
  443.     Expr *asn;
  444.     int sa, sb;
  446.     type = promote_type_bin(a->val.type, b->val.type);
  447.     tvar = NULL;
  448.     sa = possiblesigns(a);
  449.     sb = possiblesigns(b);
  450.     if ((sa & 1) || (sb & 1)) {
  451. if (*funcname) {
  452.     asn = NULL;
  453.     if (*funcname == '*') {
  454. if (exprspeed(a) >= 5 || !nosideeffects(a, 0)) {
  455.     tvar = makestmttempvar(a->val.type, name_TEMP);
  456.     asn = makeexpr_assign(makeexpr_var(tvar), a);
  457.     a = makeexpr_var(tvar);
  458. }
  459. if (exprspeed(b) >= 5 || !nosideeffects(b, 0)) {
  460.     tvar = makestmttempvar(b->val.type, name_TEMP);
  461.     asn = makeexpr_comma(asn,
  462.  makeexpr_assign(makeexpr_var(tvar),
  463.  b));
  464.     b = makeexpr_var(tvar);
  465. }
  466.     }
  467.     return makeexpr_comma(asn,
  468.   makeexpr_bicall_2(funcname, type, a, b));
  469. } else {
  470.     if ((sa & 1) && (ekind == EK_MOD))
  471. note("Using % for possibly-negative arguments [317]");
  472.     return makeexpr_bin(ekind, type, a, b);
  473. }
  474.     } else
  475. return makeexpr_bin(ekind, type, a, b);
  476. }
  480. Expr *makeexpr_div(a, b)
  481. Expr *a, *b;
  482. {
  483.     Meaning *mp;
  484.     Type *type;
  485.     long i;
  486.     int p;
  488.     if (ISCONST(a->kind) && ISCONST(b->kind)) {
  489.         if (a->val.i >= 0 && b->val.i > 0) {
  490.     a->val.i /= b->val.i;
  491.     freeexpr(b);
  492.     return a;
  493. }
  494. i = gcd(a->val.i, b->val.i);
  495. if (i >= 0) {
  496.     a->val.i /= i;
  497.     b->val.i /= i;
  498. }
  499.     }
  500.     if (((b->kind == EK_CONST && (i = b->val.i)) ||
  501.          (b->kind == EK_VAR && (mp = (Meaning *)b->val.i)->kind == MK_CONST &&
  502.                                (i = mp->val.i) && foldconsts != 0)) && i > 0) {
  503.         if (i == 1)
  504.             return a;
  505.         if (div_po2 > 0) {
  506.             p = 0;
  507.             while (!(i&1))
  508.                 p++, i >>= 1;
  509.             if (i == 1) {
  510. type = promote_type_bin(a->val.type, b->val.type);
  511.                 return makeexpr_bin(EK_RSH, type, a, makeexpr_long(p));
  512.             }
  513.         }
  514.     }
  515.     if (a->kind == EK_TIMES) {
  516. for (p = 0; p < a->nargs; p++) {
  517.     if (exprsame(a->args[p], b, 1)) {
  518. delfreearg(&a, p);
  519. freeexpr(b);
  520. if (a->nargs == 1)
  521.     return grabarg(a, 0);
  522. else
  523.     return a;
  524.     } else if (ISCONST(a->args[p]->kind) && ISCONST(b->kind)) {
  525. i = gcd(a->args[p]->val.i, b->val.i);
  526. if (i > 1) {
  527.     a->args[p]->val.i /= i;
  528.     b->val.i /= i;
  529.     i = a->args[p]->val.i;
  530.     delfreearg(&a, p);
  531.     a = makeexpr_times(a, makeexpr_long(i));   /* resimplify */
  532.     p = -1;   /* start the loop over */
  533. }
  534.     }
  535. }
  536.     }
  537.     if (checkconst(b, 1)) {
  538.         freeexpr(b);
  539.         return a;
  540.     } else if (checkconst(b, -1)) {
  541.         freeexpr(b);
  542.         return makeexpr_neg(a);
  543.     } else {
  544.         if (checkconst(b, 0))
  545.             warning("Division by zero [163]");
  546.         return dodivmod(divname, EK_DIV, a, b);
  547.     }
  548. }
  552. Expr *makeexpr_mod(a, b)
  553. Expr *a, *b;
  554. {
  555.     Meaning *mp;
  556.     Type *type;
  557.     long i;
  559.     if (a->kind == EK_CONST && b->kind == EK_CONST &&
  560.         a->val.i >= 0 && b->val.i > 0) {
  561.         a->val.i %= b->val.i;
  562.         freeexpr(b);
  563.         return a;
  564.     }
  565.     if (((b->kind == EK_CONST && (i = b->val.i)) ||
  566.          (b->kind == EK_VAR && (mp = (Meaning *)b->val.i)->kind == MK_CONST &&
  567.                                (i = mp->val.i) && foldconsts != 0)) && i > 0) {
  568.         if (i == 1)
  569.             return makeexpr_long(0);
  570.         if (mod_po2 != 0) {
  571.             while (!(i&1))
  572.                 i >>= 1;
  573.             if (i == 1) {
  574. type = promote_type_bin(a->val.type, b->val.type);
  575.                 return makeexpr_bin(EK_BAND, type, a,
  576.                                     makeexpr_minus(b, makeexpr_long(1)));
  577.             }
  578.         }
  579.     }
  580.     if (checkconst(b, 0))
  581.         warning("Division by zero [163]");
  582.     return dodivmod(modname, EK_MOD, a, b);
  583. }
  587. Expr *makeexpr_rem(a, b)
  588. Expr *a, *b;
  589. {
  590.     if (!(possiblesigns(a) & 1) && !(possiblesigns(b) & 1))
  591. return makeexpr_mod(a, b);
  592.     if (checkconst(b, 0))
  593.         warning("Division by zero [163]");
  594.     if (!*remname)
  595. note("Translating REM same as MOD [141]");
  596.     return dodivmod(*remname ? remname : modname, EK_MOD, a, b);
  597. }
  603. int expr_not_cost(a)
  604. Expr *a;
  605. {
  606.     int i, c;
  608.     switch (a->kind) {
  610.         case EK_CONST:
  611.             return 0;
  613.         case EK_NOT:
  614.             return -1;
  616.         case EK_EQ:
  617.         case EK_NE:
  618.         case EK_LT:
  619.         case EK_GT:
  620.         case EK_LE:
  621.         case EK_GE:
  622.             return 0;
  624.         case EK_AND:
  625.         case EK_OR:
  626.             c = 0;
  627.             for (i = 0; i < a->nargs; i++)
  628.                 c += expr_not_cost(a->args[i]);
  629.             return (c > 1) ? 1 : c;
  631.         case EK_BICALL:
  632.             if (!strcmp(a->val.s, oddname) ||
  633.                 !strcmp(a->val.s, evenname))
  634.                 return 0;
  635.             return 1;
  637.         default:
  638.             return 1;
  639.     }
  640. }
  644. Expr *makeexpr_not(a)
  645. Expr *a;
  646. {
  647.     Expr *ex;
  648.     int i;
  650.     if (debug>2) { fprintf(outf,"makeexpr_not("); dumpexpr(a); fprintf(outf,")n"); }
  651.     switch (a->kind) {
  653.         case EK_CONST:
  654.             if (a->val.type == tp_boolean) {
  655.                 a->val.i = !a->val.i;
  656.                 return a;
  657.             }
  658.             break;
  660.         case EK_EQ:
  661.             a->kind = EK_NE;
  662.             return a;
  664.         case EK_NE:
  665.             a->kind = EK_EQ;
  666.             return a;
  668.         case EK_LT:
  669.             a->kind = EK_GE;
  670.             return a;
  672.         case EK_GT:
  673.             a->kind = EK_LE;
  674.             return a;
  676.         case EK_LE:
  677.             a->kind = EK_GT;
  678.             return a;
  680.         case EK_GE:
  681.             a->kind = EK_LT;
  682.             return a;
  684.         case EK_AND:
  685.         case EK_OR:
  686.             if (expr_not_cost(a) > 0)
  687.                 break;
  688.             a->kind = (a->kind == EK_OR) ? EK_AND : EK_OR;
  689.             for (i = 0; i < a->nargs; i++)
  690.                 a->args[i] = makeexpr_not(a->args[i]);
  691.             return a;
  693.         case EK_NOT:
  694.             ex = a->args[0];
  695.             FREE(a);
  696.             ex->val.type = tp_boolean;
  697.             return ex;
  699.         case EK_BICALL:
  700.             if (!strcmp(a->val.s, oddname) && *evenname) {
  701.                 strchange(&a->val.s, evenname);
  702.                 return a;
  703.             } else if (!strcmp(a->val.s, evenname)) {
  704.                 strchange(&a->val.s, oddname);
  705.                 return a;
  706.             }
  707.             break;
  709. default:
  710.     break;
  711.     }
  712.     return makeexpr_un(EK_NOT, tp_boolean, a);
  713. }
  718. Type *mixsets(ep1, ep2)
  719. Expr **ep1, **ep2;
  720. {
  721.     Expr *ex1 = *ep1, *ex2 = *ep2;
  722.     Meaning *tvar;
  723.     long min1, max1, min2, max2;
  724.     Type *type;
  726.     if (ex1->val.type->kind == TK_SMALLSET &&
  727.         ex2->val.type->kind == TK_SMALLSET)
  728.         return ex1->val.type;
  729.     if (ex1->val.type->kind == TK_SMALLSET) {
  730.         tvar = makestmttempvar(ex2->val.type, name_SET);
  731.         ex1 = makeexpr_bicall_2(setexpandname, ex2->val.type,
  732.                                 makeexpr_var(tvar),
  733.                                 makeexpr_arglong(ex1, 1));
  734.     }
  735.     if (ex2->val.type->kind == TK_SMALLSET) {
  736.         tvar = makestmttempvar(ex1->val.type, name_SET);
  737.         ex2 = makeexpr_bicall_2(setexpandname, ex1->val.type,
  738.                                 makeexpr_var(tvar),
  739.                                 makeexpr_arglong(ex2, 1));
  740.     }
  741.     if (ord_range(ex1->val.type->indextype, &min1, &max1) &&
  742.         ord_range(ex2->val.type->indextype, &min2, &max2)) {
  743.         if (min1 <= min2 && max1 >= max2)
  744.             type = ex1->val.type;
  745.         else if (min2 <= min1 && max2 >= max1)
  746.             type = ex2->val.type;
  747.         else {
  748.             if (min2 < min1) min1 = min2;
  749.             if (max2 > max1) max1 = max2;
  750.             type = maketype(TK_SET);
  751.             type->basetype = tp_integer;
  752.             type->indextype = maketype(TK_SUBR);
  753.             type->indextype->basetype = ord_type(ex1->val.type->indextype);
  754.             type->indextype->smin = makeexpr_long(min1);
  755.             type->indextype->smax = makeexpr_long(max1);
  756.         }
  757.     } else
  758. type = ex1->val.type;
  759.     *ep1 = ex1, *ep2 = ex2;
  760.     return type;
  761. }
  765. Meaning *istempprocptr(ex)
  766. Expr *ex;
  767. {
  768.     Meaning *mp;
  770.     if (debug>2) { fprintf(outf,"istempprocptr("); dumpexpr(ex); fprintf(outf,")n"); }
  771.     if (ex->kind == EK_COMMA && ex->nargs == 3) {
  772.         if ((mp = istempvar(ex->args[2])) != NULL &&
  773.     mp->type->kind == TK_PROCPTR &&
  774.     ex->args[0]->kind == EK_ASSIGN &&
  775.     ex->args[0]->args[0]->kind == EK_DOT &&
  776.     exprsame(ex->args[0]->args[0]->args[0], ex->args[2], 1) &&
  777.     ex->args[1]->kind == EK_ASSIGN &&
  778.     ex->args[1]->args[0]->kind == EK_DOT &&
  779.     exprsame(ex->args[1]->args[0]->args[0], ex->args[2], 1))
  780.     return mp;
  781.     }
  782.     if (ex->kind == EK_COMMA && ex->nargs == 2) {
  783.         if ((mp = istempvar(ex->args[1])) != NULL &&
  784.     mp->type->kind == TK_CPROCPTR &&
  785.     ex->args[0]->kind == EK_ASSIGN &&
  786.     exprsame(ex->args[0]->args[0], ex->args[1], 1))
  787.     return mp;
  788.     }
  789.     return NULL;
  790. }
  795. Expr *makeexpr_stringify(ex)
  796. Expr *ex;
  797. {
  798.     ex = makeexpr_stringcast(ex);
  799.     if (ex->val.type->kind == TK_STRING)
  800.         return ex;
  801.     return makeexpr_sprintfify(ex);
  802. }
  806. Expr *makeexpr_rel(rel, a, b)
  807. enum exprkind rel;
  808. Expr *a, *b;
  809. {
  810.     int i, sign;
  811.     Expr *ex, *ex2;
  812.     Meaning *mp;
  813.     char *name;
  815.     if (debug>2) { fprintf(outf,"makeexpr_rel(%s,", exprkindname(rel)); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")n"); }
  817.     a = makeexpr_unlongcast(a);
  818.     b = makeexpr_unlongcast(b);
  819.     if ((compenums == 0 || (compenums < 0 && ansiC <= 0)) &&
  820. (rel != EK_EQ && rel != EK_NE)){
  821. a = enum_to_int(a);
  822. b = enum_to_int(b);
  823.     }
  824.     if (a->val.type != b->val.type) {
  825.         if (a->val.type->kind == TK_STRING &&
  826.             a->kind != EK_CONST) {
  827.             b = makeexpr_stringify(b);
  828.         } else if (b->val.type->kind == TK_STRING &&
  829.                    b->kind != EK_CONST) {
  830.             a = makeexpr_stringify(a);
  831.         } else if (ord_type(a->val.type)->kind == TK_CHAR ||
  832.                    a->val.type->kind == TK_ARRAY) {
  833.             b = gentle_cast(b, ord_type(a->val.type));
  834.         } else if (ord_type(b->val.type)->kind == TK_CHAR ||
  835.                    b->val.type->kind == TK_ARRAY) {
  836.             a = gentle_cast(a, ord_type(b->val.type));
  837.         } else if (a->val.type == tp_anyptr && !voidstar) {
  838.             a = gentle_cast(a, b->val.type);
  839.         } else if (b->val.type == tp_anyptr && !voidstar) {
  840.             b = gentle_cast(b, a->val.type);
  841.         }
  842.     }
  843.     if (useisspace && b->val.type->kind == TK_CHAR && checkconst(b, ' ')) {
  844.         if (rel == EK_EQ) {
  845.             freeexpr(b);
  846.             return makeexpr_bicall_1("isspace", tp_boolean, a);
  847.         } else if (rel == EK_NE) {
  848.             freeexpr(b);
  849.             return makeexpr_not(makeexpr_bicall_1("isspace", tp_boolean, a));
  850.         }
  851.     }
  852.     if (rel == EK_LT || rel == EK_GE)
  853.         sign = 1;
  854.     else if (rel == EK_GT || rel == EK_LE)
  855.         sign = -1;
  856.     else
  857.         sign = 0;
  858.     if (ord_type(b->val.type)->kind == TK_INTEGER ||
  859. ord_type(b->val.type)->kind == TK_CHAR) {
  860.         for (;;) {
  861.             if (a->kind == EK_PLUS && ISCONST(a->args[a->nargs-1]->kind) &&
  862.                  a->args[a->nargs-1]->val.i &&
  863.                  (ISCONST(b->kind) ||
  864.                   (b->kind == EK_PLUS && ISCONST(b->args[b->nargs-1]->kind)))) {
  865.                 b = makeexpr_minus(b, copyexpr(a->args[a->nargs-1]));
  866.                 a = makeexpr_minus(a, copyexpr(a->args[a->nargs-1]));
  867.                 continue;
  868.             }
  869.             if (b->kind == EK_PLUS && ISCONST(b->args[b->nargs-1]->kind) &&
  870.                  b->args[b->nargs-1]->val.i &&
  871.                  ISCONST(a->kind)) {
  872.                 a = makeexpr_minus(a, copyexpr(b->args[b->nargs-1]));
  873.                 b = makeexpr_minus(b, copyexpr(b->args[b->nargs-1]));
  874.                 continue;
  875.             }
  876.             if (b->kind == EK_PLUS && sign &&
  877.                  checkconst(b->args[b->nargs-1], sign)) {
  878.                 b = makeexpr_plus(b, makeexpr_long(-sign));
  879.                 switch (rel) {
  880.                     case EK_LT:
  881.                         rel = EK_LE;
  882.                         break;
  883.                     case EK_GT:
  884.                         rel = EK_GE;
  885.                         break;
  886.                     case EK_LE:
  887.                         rel = EK_LT;
  888.                         break;
  889.                     case EK_GE:
  890.                         rel = EK_GT;
  891.                         break;
  892.     default:
  893. break;
  894.                 }
  895.                 sign = -sign;
  896.                 continue;
  897.             }
  898.             if (a->kind == EK_TIMES && checkconst(b, 0) && !sign) {
  899.                 for (i = 0; i < a->nargs; i++) {
  900.                     if (ISCONST(a->args[i]->kind) && a->args[i]->val.i)
  901.                         break;
  902.                     if (a->args[i]->kind == EK_SIZEOF)
  903.                         break;
  904.                 }
  905.                 if (i < a->nargs) {
  906.                     delfreearg(&a, i);
  907.                     continue;
  908.                 }
  909.             }
  910.             break;
  911.         }
  912.         if (a->kind == EK_BICALL && !strcmp(a->val.s, "strlen") &&
  913.             checkconst(b, 0)) {
  914.             if (rel == EK_LT || rel == EK_GE) {
  915.                 note("Unusual use of STRLEN encountered [142]");
  916.             } else {
  917.                 freeexpr(b);
  918.                 a = makeexpr_hat(grabarg(a, 0), 0);
  919.                 b = makeexpr_char(0);      /* "strlen(a) = 0" => "*a == 0" */
  920.                 if (rel == EK_EQ || rel == EK_LE)
  921.                     return makeexpr_rel(EK_EQ, a, b);
  922.                 else
  923.                     return makeexpr_rel(EK_NE, a, b);
  924.             }
  925.         }
  926.         if (ISCONST(a->kind) && ISCONST(b->kind)) {
  927.             if ((a->val.i == b->val.i && (rel == EK_EQ || rel == EK_GE || rel == EK_LE)) ||
  928.                 (a->val.i <  b->val.i && (rel == EK_NE || rel == EK_LE || rel == EK_LT)) ||
  929.                 (a->val.i >  b->val.i && (rel == EK_NE || rel == EK_GE || rel == EK_GT)))
  930.                 return makeexpr_val(make_ord(tp_boolean, 1));
  931.             else
  932.                 return makeexpr_val(make_ord(tp_boolean, 0));
  933.         }
  934. if ((a->val.type == tp_char || true_type(a) == tp_char) &&
  935.     ISCONST(b->kind) && signedchars != 0) {
  936.     i = (b->val.i == 128 && sign == 1) ||
  937. (b->val.i == 127 && sign == -1);
  938.     if (highcharbits && (highcharbits > 0 || signedchars < 0) && i) {
  939. if (highcharbits == 2)
  940.     b = makeexpr_long(128);
  941. else
  942.     b = makeexpr_un(EK_BNOT, tp_integer, makeexpr_long(127));
  943. return makeexpr_rel((rel == EK_GE || rel == EK_GT)
  944.     ? EK_NE : EK_EQ,
  945.     makeexpr_bin(EK_BAND, tp_integer,
  946.  eatcasts(a), b),
  947.     makeexpr_long(0));
  948.     } else if (signedchars == 1 && i) {
  949. return makeexpr_rel((rel == EK_GE || rel == EK_GT)
  950.     ? EK_LT : EK_GE,
  951.     eatcasts(a), makeexpr_long(0));
  952.     } else if (signedchars == 1 && b->val.i >= 128 && sign == 0) {
  953. b->val.i -= 256;
  954.     } else if (b->val.i >= 128 ||
  955.        (b->val.i == 127 && sign != 0)) {
  956. if (highcharbits && (highcharbits > 0 || signedchars < 0))
  957.     a = makeexpr_bin(EK_BAND, a->val.type, eatcasts(a),
  958.      makeexpr_long(255));
  959. else
  960.     a = force_unsigned(a);
  961.     }
  962. }
  963.     } else if (a->val.type->kind == TK_STRING &&
  964.                b->val.type->kind == TK_STRING) {
  965.         if (b->kind == EK_CONST && b->val.i == 0 && !sign) {
  966.             a = makeexpr_hat(a, 0);
  967.             b = makeexpr_char(0);      /* "a = ''" => "*a == 0" */
  968.         } else {
  969.             a = makeexpr_bicall_2("strcmp", tp_int, a, b);
  970.             b = makeexpr_long(0);
  971.         }
  972.     } else if ((a->val.type->kind == TK_ARRAY ||
  973. a->val.type->kind == TK_STRING ||
  974. a->val.type->kind == TK_RECORD) &&
  975.        (b->val.type->kind == TK_ARRAY ||
  976. b->val.type->kind == TK_STRING ||
  977. b->val.type->kind == TK_RECORD)) {
  978.         if (a->val.type->kind == TK_ARRAY) {
  979.             if (b->val.type->kind == TK_ARRAY) {
  980.                 ex = makeexpr_sizeof(copyexpr(a), 0);
  981.                 ex2 = makeexpr_sizeof(copyexpr(b), 0);
  982.                 if (!exprsame(ex, ex2, 1))
  983.                     warning("Incompatible array sizes [164]");
  984.                 freeexpr(ex2);
  985.             } else {
  986.                 ex = makeexpr_sizeof(copyexpr(a), 0);
  987.             }
  988.         } else
  989.             ex = makeexpr_sizeof(copyexpr(b), 0);
  990. name = (usestrncmp &&
  991. a->val.type->kind == TK_ARRAY &&
  992. a->val.type->basetype->kind == TK_CHAR) ? "strncmp" : "memcmp";
  993.         a = makeexpr_bicall_3(name, tp_int,
  994.       makeexpr_addr(a), 
  995.       makeexpr_addr(b), ex);
  996.         b = makeexpr_long(0);
  997.     } else if (a->val.type->kind == TK_SET ||
  998.                a->val.type->kind == TK_SMALLSET) {
  999.         if (rel == EK_GE) {
  1000.             swapexprs(a, b);
  1001.             rel = EK_LE;
  1002.         }
  1003.         if (mixsets(&a, &b)->kind == TK_SMALLSET) {
  1004.             if (rel == EK_LE) {
  1005.                 a = makeexpr_bin(EK_BAND, tp_integer,
  1006.                                  a, makeexpr_un(EK_BNOT, tp_integer, b));
  1007.                 b = makeexpr_long(0);
  1008.                 rel = EK_EQ;
  1009.             }
  1010.         } else if (b->kind == EK_BICALL &&
  1011.                    !strcmp(b->val.s, setexpandname) &&
  1012.                    (mp = istempvar(b->args[0])) != NULL &&
  1013.                    checkconst(b->args[1], 0)) {
  1014.             canceltempvar(mp);
  1015.             a = makeexpr_hat(a, 0);
  1016.             b = grabarg(b, 1);
  1017.             if (rel == EK_LE)
  1018.                 rel = EK_EQ;
  1019.         } else {
  1020.             ex = makeexpr_bicall_2((rel == EK_LE) ? subsetname : setequalname,
  1021.                                    tp_boolean, a, b);
  1022.             return (rel == EK_NE) ? makeexpr_not(ex) : ex;
  1023.         }
  1024.     } else if (a->val.type->kind == TK_PROCPTR ||
  1025.        a->val.type->kind == TK_CPROCPTR) {
  1026.         /* we compare proc only (not link) -- same as Pascal compiler! */
  1027. if (a->val.type->kind == TK_PROCPTR)
  1028.     a = makeexpr_dotq(a, "proc", tp_anyptr);
  1029.         if ((mp = istempprocptr(b)) != NULL) {
  1030.             canceltempvar(mp);
  1031.     b = grabarg(grabarg(b, 0), 1);
  1032.             if (!voidstar)
  1033.                 b = makeexpr_cast(b, tp_anyptr);
  1034.         } else if (b->val.type->kind == TK_PROCPTR)
  1035.             b = makeexpr_dotq(b, "proc", tp_anyptr);
  1036.     }
  1037.     return makeexpr_bin(rel, tp_boolean, a, b);
  1038. }
  1043. Expr *makeexpr_and(a, b)
  1044. Expr *a, *b;
  1045. {
  1046.     Expr *ex, **exp, *low;
  1048.     if (!a)
  1049.         return b;
  1050.     if (!b)
  1051.         return a;
  1052.     for (exp = &a; (ex = *exp)->kind == EK_AND; exp = &ex->args[1]) ;
  1053.     if ((b->kind == EK_LT || b->kind == EK_LE) &&
  1054.         ((ex->kind == EK_LE && exprsame(ex->args[1], b->args[0], 1)) ||
  1055.          (ex->kind == EK_GE && exprsame(ex->args[0], b->args[0], 1)))) {
  1056.         low = (ex->kind == EK_LE) ? ex->args[0] : ex->args[1];
  1057.         if (unsignedtrick && checkconst(low, 0)) {
  1058.             freeexpr(ex);
  1059.             b->args[0] = force_unsigned(b->args[0]);
  1060.             *exp = b;
  1061.             return a;
  1062.         }
  1063.         if (b->args[1]->val.type->kind == TK_CHAR && useisalpha) {
  1064.             if (checkconst(low, 'A') && checkconst(b->args[1], 'Z')) {
  1065.                 freeexpr(ex);
  1066.                 *exp = makeexpr_bicall_1("isupper", tp_boolean, grabarg(b, 0));
  1067.                 return a;
  1068.             }
  1069.             if (checkconst(low, 'a') && checkconst(b->args[1], 'z')) {
  1070.                 freeexpr(ex);
  1071.                 *exp = makeexpr_bicall_1("islower", tp_boolean, grabarg(b, 0));
  1072.                 return a;
  1073.             }
  1074.             if (checkconst(low, '0') && checkconst(b->args[1], '9')) {
  1075.                 freeexpr(ex);
  1076.                 *exp = makeexpr_bicall_1("isdigit", tp_boolean, grabarg(b, 0));
  1077.                 return a;
  1078.             }
  1079.         }
  1080.     }
  1081.     return makeexpr_bin(EK_AND, tp_boolean, a, b);
  1082. }
  1086. Expr *makeexpr_or(a, b)
  1087. Expr *a, *b;
  1088. {
  1089.     Expr *ex, **exp, *low;
  1091.     if (!a)
  1092.         return b;
  1093.     if (!b)
  1094.         return a;
  1095.     for (exp = &a; (ex = *exp)->kind == EK_OR; exp = &ex->args[1]) ;
  1096.     if (((b->kind == EK_BICALL && !strcmp(b->val.s, "isdigit") &&
  1097.           ex->kind == EK_BICALL && !strcmp(ex->val.s, "isalpha")) ||
  1098.          (b->kind == EK_BICALL && !strcmp(b->val.s, "isalpha") &&
  1099.           ex->kind == EK_BICALL && !strcmp(ex->val.s, "isdigit"))) &&
  1100.         exprsame(ex->args[0], b->args[0], 1)) {
  1101.         strchange(&ex->val.s, "isalnum");
  1102.         freeexpr(b);
  1103.         return a;
  1104.     }
  1105.     if (((b->kind == EK_BICALL && !strcmp(b->val.s, "islower") &&
  1106.           ex->kind == EK_BICALL && !strcmp(ex->val.s, "isupper")) ||
  1107.          (b->kind == EK_BICALL && !strcmp(b->val.s, "isupper") &&
  1108.           ex->kind == EK_BICALL && !strcmp(ex->val.s, "islower"))) &&
  1109.         exprsame(ex->args[0], b->args[0], 1)) {
  1110.         strchange(&ex->val.s, "isalpha");
  1111.         freeexpr(b);
  1112.         return a;
  1113.     }
  1114.     if ((b->kind == EK_GT || b->kind == EK_GE) &&
  1115.         ((ex->kind == EK_GT && exprsame(ex->args[1], b->args[0], 1)) ||
  1116.          (ex->kind == EK_LT && exprsame(ex->args[0], b->args[0], 1)))) {
  1117.         low = (ex->kind == EK_GT) ? ex->args[0] : ex->args[1];
  1118.         if (unsignedtrick && checkconst(low, 0)) {
  1119.             freeexpr(ex);
  1120.             b->args[0] = force_unsigned(b->args[0]);
  1121.             *exp = b;
  1122.             return a;
  1123.         }
  1124.     }
  1125.     return makeexpr_bin(EK_OR, tp_boolean, a, b);
  1126. }
  1130. Expr *makeexpr_range(ex, exlow, exhigh, higheq)
  1131. Expr *ex, *exlow, *exhigh;
  1132. int higheq;
  1133. {
  1134.     Expr *ex2;
  1135.     enum exprkind rel = (higheq) ? EK_LE : EK_LT;
  1137.     if (exprsame(exlow, exhigh, 1) && higheq)
  1138.         return makeexpr_rel(EK_EQ, ex, exlow);
  1139.     ex2 = makeexpr_rel(rel, copyexpr(ex), exhigh);
  1140.     if (lelerange)
  1141.         return makeexpr_and(makeexpr_rel(EK_LE, exlow, ex), ex2);
  1142.     else
  1143.         return makeexpr_and(makeexpr_rel(EK_GE, ex, exlow), ex2);
  1144. }
  1149. Expr *makeexpr_cond(c, a, b)
  1150. Expr *c, *a, *b;
  1151. {
  1152.     Expr *ex;
  1154.     ex = makeexpr(EK_COND, 3);
  1155.     ex->val.type = a->val.type;
  1156.     ex->args[0] = c;
  1157.     ex->args[1] = a;
  1158.     ex->args[2] = b;
  1159.     if (debug>2) { fprintf(outf,"makeexpr_cond returns "); dumpexpr(ex); fprintf(outf,"n"); }
  1160.     return ex;
  1161. }
  1166. int expr_is_lvalue(ex)
  1167. Expr *ex;
  1168. {
  1169.     Meaning *mp;
  1171.     switch (ex->kind) {
  1173.         case EK_VAR:
  1174.             mp = (Meaning *)ex->val.i;
  1175.             return ((mp->kind == MK_VAR || mp->kind == MK_PARAM) ||
  1176.                     (mp->kind == MK_CONST &&
  1177.                      (mp->type->kind == TK_ARRAY ||
  1178.                       mp->type->kind == TK_RECORD ||
  1179.                       mp->type->kind == TK_SET)));
  1181.         case EK_HAT:
  1182.             return 1;
  1184.         case EK_INDEX:
  1185.             return expr_is_lvalue(ex->args[0]);
  1187. case EK_DOT:
  1188.     return expr_is_lvalue(ex->args[0]);
  1190.         default:
  1191.             return 0;
  1192.     }
  1193. }
  1196. int expr_has_address(ex)
  1197. Expr *ex;
  1198. {
  1199.     if (ex->kind == EK_DOT &&
  1200. ((Meaning *)ex->val.i)->val.i)
  1201. return 0;    /* bit fields do not have an address */
  1202.     return expr_is_lvalue(ex);
  1203. }
  1207. Expr *checknil(ex)
  1208. Expr *ex;
  1209. {
  1210.     if (nilcheck == 1) {
  1211.         if (singlevar(ex)) {
  1212.             ex = makeexpr_un(EK_CHECKNIL, ex->val.type, ex);
  1213.         } else {
  1214.             ex = makeexpr_bin(EK_CHECKNIL, ex->val.type, ex,
  1215.                               makeexpr_var(makestmttempvar(ex->val.type,
  1216.                                                            name_PTR)));
  1217.         }
  1218.     }
  1219.     return ex;
  1220. }
  1223. int checkvarinlists(yes, no, def, mp)
  1224. Strlist *yes, *no;
  1225. int def;
  1226. Meaning *mp;
  1227. {
  1228.     char *cp;
  1229.     Meaning *ctx;
  1231.     if (mp->kind == MK_FIELD)
  1232. ctx = mp->rectype->meaning;
  1233.     else
  1234. ctx = mp->ctx;
  1235.     if (ctx && ctx->name)
  1236. cp = format_ss("%s.%s", ctx->name, mp->name);
  1237.     else
  1238. cp = NULL;
  1239.     if (strlist_cifind(yes, cp))
  1240. return 1;
  1241.     if (strlist_cifind(no, cp))
  1242. return 0;
  1243.     if (strlist_cifind(yes, mp->name))
  1244. return 1;
  1245.     if (strlist_cifind(no, mp->name))
  1246. return 0;
  1247.     if (strlist_cifind(yes, "1"))
  1248. return 1;
  1249.     if (strlist_cifind(no, "1"))
  1250. return 0;
  1251.     return def;
  1252. }
  1255. void requirefilebuffer(ex)
  1256. Expr *ex;
  1257. {
  1258.     Meaning *mp;
  1260.     mp = isfilevar(ex);
  1261.     if (!mp) {
  1262. if (ex->kind == EK_HAT)
  1263.     ex = ex->args[0];
  1264. if (ex->kind == EK_VAR) {
  1265.     mp = (Meaning *)ex->val.i;
  1266.     if (mp->kind == MK_PARAM || mp->kind == MK_VARPARAM)
  1267. note(format_s("File parameter %s needs its associated buffers [318]",
  1268.       mp->name));
  1269. }
  1270.     } else if (!mp->bufferedfile &&
  1271.        checkvarinlists(bufferedfiles, unbufferedfiles, 1, mp)) {
  1272. if (mp->wasdeclared)
  1273.     note(format_s("Discovered too late that %s should be buffered [143]",
  1274.   mp->name));
  1275. mp->bufferedfile = 1;
  1276.     }
  1277. }
  1280. Expr *makeexpr_hat(a, check)
  1281. Expr *a;
  1282. int check;
  1283. {
  1284.     Expr *ex;
  1286.     if (debug>2) { fprintf(outf,"makeexpr_hat("); dumpexpr(a); fprintf(outf,")n"); }
  1287.     if (isfiletype(a->val.type)) {
  1288. requirefilebuffer(a);
  1289. if (*chargetfbufname &&
  1290.     a->val.type->basetype->basetype->kind == TK_CHAR)
  1291.     return makeexpr_bicall_1(chargetfbufname,
  1292.      a->val.type->basetype->basetype, a);
  1293. else if (*arraygetfbufname &&
  1294.  a->val.type->basetype->basetype->kind == TK_ARRAY)
  1295.     return makeexpr_bicall_2(arraygetfbufname,
  1296.      a->val.type->basetype->basetype, a,
  1297.      makeexpr_type(a->val.type->basetype->basetype));
  1298. else
  1299.     return makeexpr_bicall_2(getfbufname,
  1300.      a->val.type->basetype->basetype, a,
  1301.      makeexpr_type(a->val.type->basetype->basetype));
  1302.     }
  1303.     if (a->kind == EK_PLUS && 
  1304.                (ex = a->args[0])->val.type->kind == TK_POINTER &&
  1305.                (ex->val.type->basetype->kind == TK_ARRAY ||
  1306.                 ex->val.type->basetype->kind == TK_STRING ||
  1307.                 ex->val.type->basetype->kind == TK_SET)) {
  1308.         ex->val.type = ex->val.type->basetype;   /* convert *(a+n) to a[n] */
  1309.         deletearg(&a, 0);
  1310.         if (a->nargs == 1)
  1311.             a = grabarg(a, 0);
  1312.         return makeexpr_bin(EK_INDEX, ex->val.type->basetype, ex, a);
  1313.     }
  1314.     if (a->val.type->kind == TK_STRING || 
  1315.         a->val.type->kind == TK_ARRAY ||
  1316.         a->val.type->kind == TK_SET) {
  1317.         if (starindex == 0)
  1318.             return makeexpr_bin(EK_INDEX, a->val.type->basetype, a, makeexpr_long(0));
  1319.         else
  1320.             return makeexpr_un(EK_HAT, a->val.type->basetype, a);
  1321.     }
  1322.     if (a->val.type->kind != TK_POINTER || !a->val.type->basetype) {
  1323.         warning("bad pointer dereference [165]");
  1324.         return a;
  1325.     }
  1326.     if (a->kind == EK_CAST &&
  1327. a->val.type->basetype->kind == TK_POINTER &&
  1328. a->args[0]->val.type->kind == TK_POINTER &&
  1329. a->args[0]->val.type->basetype->kind == TK_POINTER) {
  1330. return makeexpr_cast(makeexpr_hat(a->args[0], 0),
  1331.      a->val.type->basetype);
  1332.     }
  1333.     switch (a->val.type->basetype->kind) {
  1335.       case TK_ARRAY:
  1336.       case TK_STRING:
  1337.       case TK_SET:
  1338. if (a->kind != EK_HAT || 1 ||
  1339.     a->val.type == a->args[0]->val.type->basetype) {
  1340.     a->val.type = a->val.type->basetype;
  1341.     return a;
  1342. }
  1344.       default:
  1345. if (a->kind == EK_ADDR) {
  1346.     ex = a->args[0];
  1347.     FREE(a);
  1348.     return ex;
  1349. } else {
  1350.     if (check)
  1351. ex = checknil(a);
  1352.     else
  1353. ex = a;
  1354.     return makeexpr_un(EK_HAT, a->val.type->basetype, ex);
  1355.         }
  1356.     }
  1357. }
  1361. Expr *un_sign_extend(a)
  1362. Expr *a;
  1363. {
  1364.     if (a->kind == EK_BICALL &&
  1365.         !strcmp(a->val.s, signextname) && *signextname) {
  1366.         return grabarg(a, 0);
  1367.     }
  1368.     return a;
  1369. }
  1373. Expr *makeexpr_addr(a)
  1374. Expr *a;
  1375. {
  1376.     Expr *ex;
  1377.     Type *type;
  1379.     a = un_sign_extend(a);
  1380.     type = makepointertype(a->val.type);
  1381.     if (debug>2) { fprintf(outf,"makeexpr_addr("); dumpexpr(a); fprintf(outf,", "); dumptypename(type, 1); fprintf(outf,")n"); }
  1382.     if (a->kind == EK_CONST && a->val.type->kind == TK_STRING) {
  1383.         return a;     /* kludge to help assignments */
  1384.     } else if (a->kind == EK_INDEX &&
  1385.        (a->val.type->kind != TK_ARRAY &&
  1386. a->val.type->kind != TK_SET &&
  1387. a->val.type->kind != TK_STRING) &&
  1388.        (addindex == 1 ||
  1389. (addindex != 0 && checkconst(a->args[1], 0)))) {
  1390.         ex = makeexpr_plus(makeexpr_addr(a->args[0]), a->args[1]);
  1391.         FREE(a);
  1392.         ex->val.type = type;
  1393.         return ex;
  1394.     } else {
  1395.         switch (a->val.type->kind) {
  1396.     
  1397.   case TK_ARRAY:
  1398.   case TK_STRING:
  1399.   case TK_SET:
  1400.     if (a->val.type->smin) {
  1401. return makeexpr_un(EK_ADDR, type, 
  1402.    makeexpr_index(a, 
  1403.   copyexpr(a->val.type->smin),
  1404.   NULL));
  1405.     }
  1406.     a->val.type = type;
  1407.     return a;
  1408.     
  1409.   default:
  1410.     if (a->kind == EK_HAT) {
  1411. ex = a->args[0];
  1412. FREE(a);
  1413. return ex;
  1414.     } else if (a->kind == EK_ACTCAST)
  1415. return makeexpr_actcast(makeexpr_addr(grabarg(a, 0)), type);
  1416.     else if (a->kind == EK_CAST)
  1417. return makeexpr_cast(makeexpr_addr(grabarg(a, 0)), type);
  1418.     else
  1419. return makeexpr_un(EK_ADDR, type, a);
  1420. }
  1421.     }
  1422. }
  1426. Expr *makeexpr_addrstr(a)
  1427. Expr *a;
  1428. {
  1429.     if (debug>2) { fprintf(outf,"makeexpr_addrstr("); dumpexpr(a); fprintf(outf,")n"); }
  1430.     if (a->val.type->kind == TK_POINTER)
  1431. return a;
  1432.     return makeexpr_addr(a);
  1433. }
  1437. Expr *makeexpr_addrf(a)
  1438. Expr *a;
  1439. {
  1440.     Meaning *mp, *tvar;
  1442.     mp = (Meaning *)a->val.i;
  1443.     if ((a->kind == EK_VAR &&
  1444.          (mp == mp_input || mp == mp_output)) ||
  1445.         (a->kind == EK_NAME &&
  1446.          !strcmp(a->val.s, "stderr"))) {
  1447.         if (addrstdfiles == 0) {
  1448.             note(format_s("Taking address of %s; consider setting VarFiles = 0 [144]",
  1449.                           (a->kind == EK_VAR) ? ((Meaning *)a->val.i)->name
  1450.                                               : a->val.s));
  1451.             tvar = makestmttempvar(tp_text, name_TEMP);
  1452.             return makeexpr_comma(makeexpr_assign(makeexpr_var(tvar), a),
  1453.                                   makeexpr_addr(makeexpr_var(tvar)));
  1454.         }
  1455.     }
  1456.     if ((a->kind == EK_VAR &&
  1457.          mp->kind == MK_FIELD && mp->val.i) ||
  1458.         (a->kind == EK_BICALL &&
  1459.          !strcmp(a->val.s, getbitsname))) {
  1460.         warning("Can't take the address of a bit-field [166]");
  1461.     }
  1462.     return makeexpr_addr(a);
  1463. }
  1467. Expr *makeexpr_index(a, b, offset)
  1468. Expr *a, *b, *offset;
  1469. {
  1470.     Type *indextype, *btype;
  1472.     if (debug>2) { fprintf(outf,"makeexpr_index("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b);
  1473.                                                                  fprintf(outf,", "); dumpexpr(offset); fprintf(outf,")n"); }
  1474.     indextype = (a->val.type->kind == TK_ARRAY) ? a->val.type->indextype
  1475.                                                 : tp_integer;
  1476.     b = gentle_cast(b, indextype);
  1477.     if (!offset)
  1478.         offset = makeexpr_long(0);
  1479.     b = makeexpr_minus(b, gentle_cast(offset, indextype));
  1480.     btype = a->val.type;
  1481.     if (btype->basetype)
  1482. btype = btype->basetype;
  1483.     if (checkconst(b, 0) && starindex == 1)
  1484.         return makeexpr_un(EK_HAT, btype, a);
  1485.     else
  1486.         return makeexpr_bin(EK_INDEX, btype, a,
  1487.                             gentle_cast(b, indextype));
  1488. }
  1492. Expr *makeexpr_type(type)
  1493. Type *type;
  1494. {
  1495.     Expr *ex;
  1497.     ex = makeexpr(EK_TYPENAME, 0);
  1498.     ex->val.type = type;
  1499.     return ex;
  1500. }
  1503. Expr *makeexpr_sizeof(ex, incskipped)
  1504. Expr *ex;
  1505. int incskipped;
  1506. {
  1507.     Expr *ex2, *ex3;
  1508.     Type *btype;
  1509.     char *name;
  1511.     if (ex->val.type->meaning) {
  1512. name = find_special_variant(ex->val.type->meaning->name,
  1513.     "SpecialSizeOf", specialsizeofs, 1);
  1514. if (name) {
  1515.     freeexpr(ex);
  1516.     return pc_expr_str(name);
  1517. }
  1518.     }
  1519.     switch (ex->val.type->kind) {
  1521.         case TK_CHAR:
  1522.         case TK_BOOLEAN:
  1523.             freeexpr(ex);
  1524.             return makeexpr_long(1);
  1526.         case TK_SUBR:
  1527.     btype = findbasetype(ex->val.type, 0);
  1528.     if (btype->kind == TK_CHAR || btype == tp_abyte) {
  1529. freeexpr(ex);
  1530. return makeexpr_long(1);
  1531.     }
  1532.     break;
  1534.         case TK_STRING:
  1535.         case TK_ARRAY:
  1536.             if (!ex->val.type->meaning || ex->val.type->kind == TK_STRING) {
  1537.                 ex3 = arraysize(ex->val.type, incskipped);
  1538.                 return makeexpr_times(ex3,
  1539.                                       makeexpr_sizeof(makeexpr_type(
  1540.                                            ex->val.type->basetype), 1));
  1541.             }
  1542.             break;
  1544.         case TK_SET:
  1545.             ord_range_expr(ex->val.type->indextype, NULL, &ex2);
  1546.             freeexpr(ex);
  1547.             return makeexpr_times(makeexpr_plus(makeexpr_div(copyexpr(ex2),
  1548.                                                              makeexpr_setbits()),
  1549.                                                 makeexpr_long(2)),
  1550.                                   makeexpr_sizeof(makeexpr_type(tp_integer), 0));
  1551.             break;
  1553. default:
  1554.     break;
  1555.     }
  1556.     if (ex->kind != EK_CONST &&
  1557.         (findbasetype(ex->val.type,0)->meaning || /* if type has a name... */
  1558.          ex->val.type->kind == TK_STRING ||       /* if C sizeof(expr) will give wrong answer */
  1559.          ex->val.type->kind == TK_ARRAY ||
  1560.          ex->val.type->kind == TK_SET)) {
  1561.         ex2 = makeexpr_type(ex->val.type);
  1562.         freeexpr(ex);
  1563.         ex = ex2;
  1564.     }
  1565.     return makeexpr_un(EK_SIZEOF, tp_integer, ex);
  1566. }
  1571. /* Compute a measure of how fast or slow the expression is likely to be.
  1572.    0 is a constant, 1 is a variable, extra points added per "operation". */
  1574. int exprspeed(ex)
  1575. Expr *ex;
  1576. {
  1577.     Meaning *mp, *mp2;
  1578.     int i, cost, speed;
  1580.     switch (ex->kind) {
  1582.         case EK_VAR:
  1583.             mp = (Meaning *)ex->val.i;
  1584.             if (mp->kind == MK_CONST)
  1585.                 return 0;
  1586.             if (!mp->ctx || mp->ctx->kind == MK_FUNCTION)
  1587.                 return 1;
  1588.             i = 1;
  1589.             for (mp2 = curctx; mp2 && mp2 != mp->ctx; mp2 = mp2->ctx)
  1590.                 i++;    /* cost of following static links */
  1591.             return (i);
  1593.         case EK_CONST:
  1594.         case EK_LONGCONST:
  1595.         case EK_SIZEOF:
  1596.             return 0;
  1598.         case EK_ADDR:
  1599.             speed = exprspeed(ex->args[0]);
  1600.             return (speed > 1) ? speed : 0;
  1602.         case EK_DOT:
  1603.             return exprspeed(ex->args[0]);
  1605.         case EK_NEG:
  1606.             return exprspeed(ex->args[0]) + 1;
  1608.         case EK_CAST:
  1609.         case EK_ACTCAST:
  1610.             i = (ord_type(ex->val.type)->kind == TK_REAL) !=
  1611.                 (ord_type(ex->args[0]->val.type)->kind == TK_REAL);
  1612.             return (i + exprspeed(ex->args[0]));
  1614.         case EK_COND:
  1615.             return 2 + exprspeed(ex->args[0]) +
  1616.                    MAX(exprspeed(ex->args[1]), exprspeed(ex->args[2]));
  1618.         case EK_AND:
  1619.         case EK_OR:
  1620.         case EK_COMMA:
  1621.             speed = 2;
  1622.             for (i = 0; i < ex->nargs; i++)
  1623.                 speed += exprspeed(ex->args[i]);
  1624.             return speed;
  1626.         case EK_FUNCTION:
  1627.         case EK_BICALL:
  1628.         case EK_SPCALL:
  1629.             return 1000;
  1631.         case EK_ASSIGN:
  1632.         case EK_POSTINC:
  1633.         case EK_POSTDEC:
  1634.             return 100 + exprspeed(ex->args[0]) + exprspeed(ex->args[1]);
  1636.         default:
  1637.             cost = (ex->kind == EK_PLUS) ? 1 : 2;
  1638.             if (ex->val.type->kind == TK_REAL)
  1639.                 cost *= 2;
  1640.             speed = -cost;
  1641.             for (i = 0; i < ex->nargs; i++) {
  1642.                 if (!isliteralconst(ex->args[i], NULL) ||
  1643.                     ex->val.type->kind == TK_REAL)
  1644.                     speed += exprspeed(ex->args[i]) + cost;
  1645.             }
  1646.             return MAX(speed, 0);
  1647.     }
  1648. }
  1653. int noargdependencies(ex, vars)
  1654. Expr *ex;
  1655. int vars;
  1656. {
  1657.     int i;
  1659.     for (i = 0; i < ex->nargs; i++) {
  1660.         if (!nodependencies(ex->args[i], vars))
  1661.             return 0;
  1662.     }
  1663.     return 1;
  1664. }
  1667. int nodependencies(ex, vars)
  1668. Expr *ex;
  1669. int vars;   /* 1 if explicit dependencies on vars count as dependencies */
  1670. {           /* 2 if global but not local vars count as dependencies */
  1671.     Meaning *mp;
  1673.     if (debug>2) { fprintf(outf,"nodependencies("); dumpexpr(ex); fprintf(outf,")n"); }
  1674.     if (!noargdependencies(ex, vars))
  1675.         return 0;
  1676.     switch (ex->kind) {
  1678.         case EK_VAR:
  1679.             mp = (Meaning *)ex->val.i;
  1680.     if (mp->kind == MK_CONST)
  1681. return 1;
  1682.     if (vars == 2 &&
  1683. mp->ctx == curctx &&
  1684. mp->ctx->kind == MK_FUNCTION &&
  1685. !mp->varstructflag)
  1686. return 1;
  1687.             return (mp->kind == MK_CONST ||
  1688.     (!vars &&
  1689.      (mp->kind == MK_VAR || mp->kind == MK_VARREF ||
  1690.       mp->kind == MK_PARAM || mp->kind == MK_VARPARAM)));
  1692.         case EK_BICALL:
  1693.             return nosideeffects_func(ex);
  1695.         case EK_FUNCTION:
  1696.         case EK_SPCALL:
  1697.         case EK_ASSIGN:
  1698.         case EK_POSTINC:
  1699.         case EK_POSTDEC:
  1700.         case EK_HAT:
  1701.         case EK_INDEX:
  1702.             return 0;
  1704.         default:
  1705.             return 1;
  1706.     }
  1707. }
  1711. int exprdependsvar(ex, mp)
  1712. Expr *ex;
  1713. Meaning *mp;
  1714. {
  1715.     int i;
  1717.     i = ex->nargs;
  1718.     while (--i >= 0)
  1719. if (exprdependsvar(ex->args[i], mp))
  1720.     return 1;
  1721.     switch (ex->kind) {
  1723.         case EK_VAR:
  1724.     return ((Meaning *)ex->val.i == mp);
  1726. case EK_BICALL:
  1727.     if (nodependencies(ex, 1))
  1728. return 0;
  1730. /* fall through */
  1731. case EK_FUNCTION:
  1732. case EK_SPCALL:
  1733.     return (mp->ctx != curctx ||
  1734.     mp->ctx->kind != MK_FUNCTION ||
  1735.     mp->varstructflag);
  1737. case EK_HAT:
  1738.     return 1;
  1740. default:
  1741.     return 0;
  1742.     }
  1743. }
  1746. int exprdepends(ex, ex2)
  1747. Expr *ex, *ex2;     /* Expression ex somehow depends on value of ex2 */
  1748. {
  1749.     switch (ex2->kind) {
  1751.         case EK_VAR:
  1752.     return exprdependsvar(ex, (Meaning *)ex2->val.i);
  1754. case EK_CONST:
  1755. case EK_LONGCONST:
  1756.     return 0;
  1758. case EK_INDEX:
  1759. case EK_DOT:
  1760.     return exprdepends(ex, ex2->args[0]);
  1762. default:
  1763.     return !nodependencies(ex, 1);
  1764.     }
  1765. }
  1768. int nosideeffects_func(ex)
  1769. Expr *ex;
  1770. {
  1771.     Meaning *mp;
  1772.     Symbol *sp;
  1774.     switch (ex->kind) {
  1776.         case EK_FUNCTION:
  1777.             mp = (Meaning *)ex->val.i;
  1778.             sp = findsymbol_opt(mp->name);
  1779.             return sp && (sp->flags & (NOSIDEEFF|DETERMF));
  1781.         case EK_BICALL:
  1782.             sp = findsymbol_opt(ex->val.s);
  1783.             return sp && (sp->flags & (NOSIDEEFF|DETERMF));
  1785.         default:
  1786.             return 0;
  1787.     }
  1788. }
  1792. int deterministic_func(ex)
  1793. Expr *ex;
  1794. {
  1795.     Meaning *mp;
  1796.     Symbol *sp;
  1798.     switch (ex->kind) {
  1800.         case EK_FUNCTION:
  1801.             mp = (Meaning *)ex->val.i;
  1802.             sp = findsymbol_opt(mp->name);
  1803.             return sp && (sp->flags & DETERMF);
  1805.         case EK_BICALL:
  1806.             sp = findsymbol_opt(ex->val.s);
  1807.             return sp && (sp->flags & DETERMF);
  1809.         default:
  1810.             return 0;
  1811.     }
  1812. }
  1817. int noargsideeffects(ex, mode)
  1818. Expr *ex;
  1819. int mode;
  1820. {
  1821.     int i;
  1823.     for (i = 0; i < ex->nargs; i++) {