home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 379a.lha / p2c1_13a / src / src.zoo / expr3.c < prev    next >
C/C++ Source or Header  |  1990-03-11  |  34KB  |  1,175 lines
  1. /* "p2c", a Pascal to C translator.
  2.    Copyright (C) 1989 David Gillespie.
  3.    Author's address: daveg@csvax.caltech.edu; 256-80 Caltech/Pasadena CA 91125.
  4.  
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation (any version).
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  13.  
  14. You should have received a copy of the GNU General Public License
  15. along with this program; see the file COPYING.  If not, write to
  16. the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  17.  
  18. #define PROTO_EXPR3_C
  19. #include "trans.h"
  20.  
  21. #define ISCONST(kind) ((kind)==EK_CONST || (kind)==EK_LONGCONST)
  22. #define MOVCONST(ex) (ISCONST((ex)->kind) && (ex)->val.type->kind != TK_STRING)
  23. #define COMMUTATIVE (kind != EK_COMMA && type->kind != TK_REAL)
  24.  
  25. int ischartype(ex)
  26. Expr *ex;
  27. {
  28.     if (ord_type(ex->val.type)->kind == TK_CHAR)
  29.     return 1;
  30.     if (true_type(ex)->kind == TK_CHAR)
  31.     return 1;
  32.     if (ISCONST(ex->kind) && ex->nargs > 0 &&
  33.     ex->args[0]->kind == EK_NAME &&
  34.     ex->args[0]->val.s[0] == '\'')
  35.     return 1;
  36.     return 0;
  37. }
  38.  
  39. Expr *commute(a, b, kind)
  40. Expr *a, *b;
  41. enum exprkind kind;
  42. {
  43.     int i, di;
  44.     Type *type;
  45.  
  46.     if (debug>2) { fprintf(outf,"commute("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  47. #if 1
  48.     type = promote_type_bin(a->val.type, b->val.type);
  49. #else
  50.     type = a->val.type;
  51.     if (b->val.type->kind == TK_REAL)
  52.         type = b->val.type;
  53. #endif
  54.     if (MOVCONST(a) && !MOVCONST(b) && COMMUTATIVE)
  55.         swapexprs(a, b);                /* put constant last */
  56.     if (a->kind == kind) {
  57.         di = (MOVCONST(a->args[a->nargs-1]) && COMMUTATIVE) ? -1 : 0;
  58.         if (b->kind == kind) {
  59.             for (i = 0; i < b->nargs; i++)
  60.                 insertarg(&a, a->nargs + di, b->args[i]);
  61.             FREE(b);
  62.         } else
  63.             insertarg(&a, a->nargs + di, b);
  64.         a->val.type = type;
  65.     } else if (b->kind == kind) {
  66.         if (MOVCONST(a) && COMMUTATIVE)
  67.             insertarg(&b, b->nargs, a);
  68.         else
  69.             insertarg(&b, 0, a);
  70.         a = b;
  71.         a->val.type = type;
  72.     } else {
  73.         a = makeexpr_bin(kind, type, a, b);
  74.     }
  75.     if (debug>2) { fprintf(outf,"commute returns "); dumpexpr(a); fprintf(outf,"\n"); }
  76.     return a;
  77. }
  78.  
  79.  
  80. Expr *makeexpr_plus(a, b)
  81. Expr *a, *b;
  82. {
  83.     int i, j, k;
  84.     Type *type;
  85.  
  86.     if (debug>2) { fprintf(outf,"makeexpr_plus("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  87.     if (!a)
  88.         return b;
  89.     if (!b)
  90.         return a;
  91.     if (a->kind == EK_NEG && a->args[0]->kind == EK_PLUS)
  92.         a = neg_inside_sum(grabarg(a, 0));
  93.     if (b->kind == EK_NEG && b->args[0]->kind == EK_PLUS)
  94.         b = neg_inside_sum(grabarg(b, 0));
  95.     a = commute(enum_to_int(a), enum_to_int(b), EK_PLUS);
  96.     type = NULL;
  97.     for (i = 0; i < a->nargs; i++) {
  98.         if (ord_type(a->args[i]->val.type)->kind == TK_CHAR ||
  99.             a->args[i]->val.type->kind == TK_POINTER ||
  100.             a->args[i]->val.type->kind == TK_STRING) {   /* for string literals */
  101.             if (type == ord_type(a->args[i]->val.type))
  102.                 type = tp_integer;   /* 'z'-'a' and p1-p2 are integers */
  103.             else
  104.                 type = ord_type(a->args[i]->val.type);
  105.         }
  106.     }
  107.     if (type)
  108.         a->val.type = type;
  109.     for (i = 0; i < a->nargs && !ISCONST(a->args[i]->kind); i++) ;
  110.     if (i < a->nargs-1) {
  111.         for (j = i+1; j < a->nargs; j++) {
  112.             if (ISCONST(a->args[j]->kind)) {
  113.                 if ((ord_type(a->args[i]->val.type) == ord_type(a->args[j]->val.type) ||
  114.              ord_type(a->args[i]->val.type)->kind == TK_INTEGER ||
  115.              ord_type(a->args[j]->val.type)->kind == TK_INTEGER) &&
  116.             (!ischartype(a->args[i]) || !ischartype(a->args[j])) &&
  117.                     (a->args[i]->val.type->kind != TK_REAL &&
  118.                      a->args[i]->val.type->kind != TK_STRING &&
  119.                      a->args[j]->val.type->kind != TK_REAL &&
  120.                      a->args[j]->val.type->kind != TK_STRING)) {
  121.                     a->args[i]->val.i += a->args[j]->val.i;
  122.                     delfreearg(&a, j);
  123.                     j--;
  124.                 } else if (a->args[i]->val.type->kind == TK_STRING &&
  125.                            ord_type(a->args[j]->val.type)->kind == TK_INTEGER &&
  126.                            a->args[j]->val.i < 0 &&
  127.                            a->args[j]->val.i >= -stringleaders) {
  128.                     /* strictly speaking, the following is illegal pointer arithmetic */
  129.                     a->args[i] = makeexpr_lstring(a->args[i]->val.s + a->args[j]->val.i,
  130.                                                   a->args[i]->val.i - a->args[j]->val.i);
  131.                     for (k = 0; k < - a->args[j]->val.i; k++)
  132.                         a->args[i]->val.s[k] = '>';
  133.                     delfreearg(&a, j);
  134.                     j--;
  135.                 }
  136.             }
  137.         }
  138.     }
  139.     if (checkconst(a->args[a->nargs-1], 0))
  140.         delfreearg(&a, a->nargs-1);
  141.     for (i = 0; i < a->nargs; i++) {
  142.         if (a->args[i]->kind == EK_NEG && nosideeffects(a->args[i], 1)) {
  143.             for (j = 0; j < a->nargs; j++) {
  144.                 if (exprsame(a->args[j], a->args[i]->args[0], 1)) {
  145.                     delfreearg(&a, i);
  146.                     if (i < j) j--; else i--;
  147.                     delfreearg(&a, j);
  148.                     i--;
  149.                     break;
  150.                 }
  151.             }
  152.         }
  153.     }
  154.     if (a->nargs < 2) {
  155.         if (a->nargs < 1) {
  156.         type = a->val.type;
  157.             FREE(a);
  158.             a = gentle_cast(makeexpr_long(0), type);
  159.         a->val.type = type;
  160.         return a;
  161.         } else {
  162.             b = a->args[0];
  163.             FREE(a);
  164.             return b;
  165.         }
  166.     }
  167.     if (a->nargs == 2 && ISCONST(a->args[1]->kind) &&
  168.     a->args[1]->val.i <= -127 &&
  169.     true_type(a->args[0]) == tp_char && signedchars != 0) {
  170.     a->args[0] = force_unsigned(a->args[0]);
  171.     }
  172.     if (a->nargs > 2 &&
  173.     ISCONST(a->args[a->nargs-1]->kind) &&
  174.     ISCONST(a->args[a->nargs-2]->kind) &&
  175.     ischartype(a->args[a->nargs-1]) &&
  176.     ischartype(a->args[a->nargs-2])) {
  177.     i = a->args[a->nargs-1]->val.i;
  178.     j = a->args[a->nargs-2]->val.i;
  179.     if ((i == 'a' || i == 'A' || i == -'a' || i == -'A') &&
  180.         (j == 'a' || j == 'A' || j == -'a' || j == -'A')) {
  181.         if (abs(i+j) == 32) {
  182.         delfreearg(&a, a->nargs-1);
  183.         delsimpfreearg(&a, a->nargs-1);
  184.         a = makeexpr_bicall_1((i+j > 0) ? "_tolower" : "_toupper",
  185.                       tp_char, a);
  186.         }
  187.     }
  188.     }
  189.     return a;
  190. }
  191.  
  192.  
  193. Expr *makeexpr_minus(a, b)
  194. Expr *a, *b;
  195. {
  196.     int okneg;
  197.  
  198.     if (debug>2) { fprintf(outf,"makeexpr_minus("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  199.     if (ISCONST(b->kind) && b->val.i == 0 &&       /* kludge for array indexing */
  200.         ord_type(b->val.type)->kind == TK_ENUM) {
  201.         b->val.type = tp_integer;
  202.     }
  203.     okneg = (a->kind != EK_PLUS && b->kind != EK_PLUS);
  204.     a = makeexpr_plus(a, makeexpr_neg(b));
  205.     if (okneg && a->kind == EK_PLUS)
  206.         a->val.i = 1;   /* this flag says to write as "a-b" if possible */
  207.     return a;
  208. }
  209.  
  210.  
  211. Expr *makeexpr_inc(a, b)
  212. Expr *a, *b;
  213. {
  214.     Type *type;
  215.  
  216.     type = a->val.type;
  217.     a = makeexpr_plus(makeexpr_charcast(a), b);
  218.     if (ord_type(type)->kind != TK_INTEGER &&
  219.     ord_type(type)->kind != TK_CHAR)
  220.     a = makeexpr_cast(a, type);
  221.     return a;
  222. }
  223.  
  224.  
  225.  
  226. /* Apply the distributive law for a sum of products */
  227. Expr *distribute_plus(ex)
  228. Expr *ex;
  229. {
  230.     int i, j, icom;
  231.     Expr *common, *outer, *ex2, **exp;
  232.  
  233.     if (debug>2) { fprintf(outf,"distribute_plus("); dumpexpr(ex); fprintf(outf,")\n"); }
  234.     if (ex->kind != EK_PLUS)
  235.         return ex;
  236.     for (i = 0; i < ex->nargs; i++)
  237.         if (ex->args[i]->kind == EK_TIMES)
  238.             break;
  239.     if (i == ex->nargs)
  240.         return ex;
  241.     outer = NULL;
  242.     icom = 0;
  243.     for (;;) {
  244.     ex2 = ex->args[0];
  245.     if (ex2->kind == EK_NEG)
  246.         ex2 = ex2->args[0];
  247.         if (ex2->kind == EK_TIMES) {
  248.         if (icom >= ex2->nargs)
  249.         break;
  250.             common = ex2->args[icom];
  251.         if (common->kind == EK_NEG)
  252.         common = common->args[0];
  253.         } else {
  254.         if (icom > 0)
  255.         break;
  256.             common = ex2;
  257.         icom++;
  258.     }
  259.         for (i = 1; i < ex->nargs; i++) {
  260.         ex2 = ex->args[i];
  261.         if (ex2->kind == EK_NEG)
  262.         ex2 = ex2->args[i];
  263.             if (ex2->kind == EK_TIMES) {
  264.                 for (j = ex2->nargs; --j >= 0; ) {
  265.                     if (exprsame(ex2->args[j], common, 1) ||
  266.             (ex2->args[j]->kind == EK_NEG &&
  267.              exprsame(ex2->args[j]->args[0], common, 1)))
  268.                         break;
  269.                 }
  270.                 if (j < 0)
  271.                     break;
  272.             } else {
  273.                 if (!exprsame(ex2, common, 1))
  274.                     break;
  275.             }
  276.         }
  277.         if (i == ex->nargs) {
  278.             if (debug>2) { fprintf(outf,"distribute_plus does "); dumpexpr(common); fprintf(outf,"\n"); }
  279.         common = copyexpr(common);
  280.             for (i = 0; i < ex->nargs; i++) {
  281.         if (ex->args[i]->kind == EK_NEG)
  282.             ex2 = *(exp = &ex->args[i]->args[0]);
  283.         else
  284.             ex2 = *(exp = &ex->args[i]);
  285.         if (ex2->kind == EK_TIMES) {
  286.                     for (j = ex2->nargs; --j >= 0; ) {
  287.                         if (exprsame(ex2->args[j], common, 1)) {
  288.                             delsimpfreearg(exp, j);
  289.                             break;
  290.                         } else if (ex2->args[j]->kind == EK_NEG &&
  291.                    exprsame(ex2->args[j]->args[0], common,1)) {
  292.                 freeexpr(ex2->args[j]);
  293.                 ex2->args[j] = makeexpr_long(-1);
  294.                 break;
  295.             }
  296.                     }
  297.         } else {
  298.             freeexpr(ex2);
  299.             *exp = makeexpr_long(1);
  300.                 }
  301.         ex->args[i] = resimplify(ex->args[i]);
  302.             }
  303.             outer = makeexpr_times(common, outer);
  304.         } else
  305.         icom++;
  306.     }
  307.     return makeexpr_times(resimplify(ex), outer);
  308. }
  309.  
  310.  
  311.  
  312.  
  313.  
  314. Expr *makeexpr_times(a, b)
  315. Expr *a, *b;
  316. {
  317.     int i, n;
  318.     Type *type;
  319.  
  320.     if (debug>2) { fprintf(outf,"makeexpr_times("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  321.     if (!a)
  322.         return b;
  323.     if (!b)
  324.         return a;
  325.     a = commute(a, b, EK_TIMES);
  326.     if (a->val.type->kind == TK_INTEGER) {
  327.         i = a->nargs-1;
  328.         if (i > 0 && ISCONST(a->args[i-1]->kind)) {
  329.             a->args[i-1]->val.i *= a->args[i]->val.i;
  330.             delfreearg(&a, i);
  331.         }
  332.     }
  333.     for (i = n = 0; i < a->nargs; i++) {
  334.         if (expr_neg_cost(a->args[i]) < 0)
  335.             n++;
  336.     }
  337.     if (n & 1) {
  338.         for (i = 0; i < a->nargs; i++) {
  339.             if (ISCONST(a->args[i]->kind) &&
  340.                 expr_neg_cost(a->args[i]) >= 0) {
  341.                 a->args[i] = makeexpr_neg(a->args[i]);
  342.                 n++;
  343.                 break;
  344.             }
  345.         }
  346.     } else
  347.         n++;
  348.     for (i = 0; i < a->nargs && n >= 2; i++) {
  349.         if (expr_neg_cost(a->args[i]) < 0) {
  350.             a->args[i] = makeexpr_neg(a->args[i]);
  351.             n--;
  352.         }
  353.     }
  354.     if (checkconst(a->args[a->nargs-1], 1))
  355.         delfreearg(&a, a->nargs-1);
  356.     if (checkconst(a->args[a->nargs-1], -1)) {
  357.         delfreearg(&a, a->nargs-1);
  358.     a->args[0] = makeexpr_neg(a->args[0]);
  359.     }
  360.     if (checkconst(a->args[a->nargs-1], 0) && nosideeffects(a, 1)) {
  361.         type = a->val.type;
  362.         return makeexpr_cast(grabarg(a, a->nargs-1), type);
  363.     }
  364.     if (a->nargs < 2) {
  365.         if (a->nargs < 1) {
  366.             FREE(a);
  367.             a = makeexpr_long(1);
  368.         } else {
  369.             b = a->args[0];
  370.             FREE(a);
  371.             a = b;
  372.         }
  373.     }
  374.     return a;
  375. }
  376.  
  377.  
  378.  
  379. Expr *makeexpr_sqr(ex, cube)
  380. Expr *ex;
  381. int cube;
  382. {
  383.     Expr *ex2;
  384.     Meaning *tvar;
  385.     Type *type;
  386.  
  387.     if (exprspeed(ex) <= 2 && nosideeffects(ex, 0)) {
  388.     ex2 = NULL;
  389.     } else {
  390.     type = (ex->val.type->kind == TK_REAL) ? tp_longreal : tp_integer;
  391.     tvar = makestmttempvar(type, name_TEMP);
  392.     ex2 = makeexpr_assign(makeexpr_var(tvar), ex);
  393.     ex = makeexpr_var(tvar);
  394.     }
  395.     if (cube)
  396.     ex = makeexpr_times(ex, makeexpr_times(copyexpr(ex), copyexpr(ex)));
  397.     else
  398.     ex = makeexpr_times(ex, copyexpr(ex));
  399.     return makeexpr_comma(ex2, ex);
  400. }
  401.  
  402.  
  403.  
  404. Expr *makeexpr_divide(a, b)
  405. Expr *a, *b;
  406. {
  407.     Expr *ex;
  408.     int p;
  409.  
  410.     if (debug>2) {
  411.         fprintf(outf,"makeexpr_divide(");
  412.         dumpexpr(a);
  413.         fprintf(outf,", ");
  414.         dumpexpr(b);
  415.         fprintf(outf,")\n");
  416.     }
  417.     if (a->val.type->kind != TK_REAL &&
  418.     b->val.type->kind != TK_REAL) {     /* must do a real division */
  419.         ex = docast(a, tp_longreal);
  420.         if (ex)
  421.             a = ex;
  422.         else {
  423.             ex = docast(b, tp_longreal);
  424.             if (ex)
  425.                 b = ex;
  426.             else
  427.                 a = makeexpr_cast(a, tp_longreal);
  428.         }
  429.     }
  430.     if (a->kind == EK_TIMES) {
  431.     for (p = 0; p < a->nargs; p++)
  432.         if (exprsame(a->args[p], b, 1))
  433.         break;
  434.     if (p < a->nargs) {
  435.         delfreearg(&a, p);
  436.         freeexpr(b);
  437.         if (a->nargs == 1)
  438.         return grabarg(a, 0);
  439.         else
  440.         return a;
  441.     }
  442.     }
  443.     if (expr_neg_cost(a) < 0 && expr_neg_cost(b) < 0) {
  444.         a = makeexpr_neg(a);
  445.         b = makeexpr_neg(b);
  446.     }
  447.     if (checkconst(b, 0))
  448.         warning("Division by zero [163]");
  449.     return makeexpr_bin(EK_DIVIDE, tp_longreal, a, b);
  450. }
  451.  
  452.  
  453.  
  454.  
  455. int gcd(a, b)
  456. int a, b;
  457. {
  458.     if (a < 0) a = -a;
  459.     if (b < 0) b = -b;
  460.     while (a != 0) {
  461.     b %= a;
  462.     if (b != 0)
  463.         a %= b;
  464.     else
  465.         return a;
  466.     }
  467.     return b;
  468. }
  469.  
  470.  
  471.  
  472. /* possible signs of ex: 1=may be neg, 2=may be zero, 4=may be pos */
  473.  
  474. int negsigns(mask)
  475. int mask;
  476. {
  477.     return (mask & 2) |
  478.        ((mask & 1) << 2) |
  479.        ((mask & 4) >> 2);
  480. }
  481.  
  482.  
  483. int possiblesigns(ex)
  484. Expr *ex;
  485. {
  486.     Value val;
  487.     Type *tp;
  488.     char *cp;
  489.     int i, mask, mask2;
  490.  
  491.     if (isliteralconst(ex, &val) && val.type) {
  492.     if (val.type == tp_real || val.type == tp_longreal) {
  493.         if (realzero(val.s))
  494.         return 2;
  495.         if (*val.s == '-')
  496.         return 1;
  497.         return 4;
  498.     } else
  499.         return (val.i < 0) ? 1 : (val.i == 0) ? 2 : 4;
  500.     }
  501.     if (ex->kind == EK_CAST &&
  502.     similartypes(ex->val.type, ex->args[0]->val.type))
  503.     return possiblesigns(ex->args[0]);
  504.     if (ex->kind == EK_NEG)
  505.     return negsigns(possiblesigns(ex->args[0]));
  506.     if (ex->kind == EK_TIMES || ex->kind == EK_DIVIDE) {
  507.     mask = possiblesigns(ex->args[0]);
  508.     for (i = 1; i < ex->nargs; i++) {
  509.         mask2 = possiblesigns(ex->args[i]);
  510.         if (mask2 & 2)
  511.         mask |= 2;
  512.         if ((mask2 & (1|4)) == 1)
  513.         mask = negsigns(mask);
  514.         else if ((mask2 & (1|4)) != 4)
  515.         mask = 1|2|4;
  516.     }
  517.     return mask;
  518.     }
  519.     if (ex->kind == EK_DIV || ex->kind == EK_MOD) {
  520.     mask = possiblesigns(ex->args[0]);
  521.     mask2 = possiblesigns(ex->args[1]);
  522.     if (!((mask | mask2) & 1))
  523.         return 2|4;
  524.     }
  525.     if (ex->kind == EK_PLUS) {
  526.     mask = 0;
  527.     for (i = 0; i < ex->nargs; i++) {
  528.         mask2 = possiblesigns(ex->args[i]);
  529.         if ((mask & negsigns(mask2)) & (1|4))
  530.         mask |= (1|2|4);
  531.         else
  532.         mask |= mask2;
  533.     }
  534.     return mask;
  535.     }
  536.     if (ex->kind == EK_COND) {
  537.     return possiblesigns(ex->args[1]) | possiblesigns(ex->args[2]);
  538.     }
  539.     if (ex->kind == EK_EQ || ex->kind == EK_LT || ex->kind == EK_GT ||
  540.     ex->kind == EK_NE || ex->kind == EK_LE || ex->kind == EK_GE ||
  541.     ex->kind == EK_AND || ex->kind == EK_OR || ex->kind == EK_NOT)
  542.     return 2|4;
  543.     if (ex->kind == EK_BICALL) {
  544.     cp = ex->val.s;
  545.     if (!strcmp(cp, "strlen") ||
  546.         !strcmp(cp, "abs") ||
  547.         !strcmp(cp, "labs") ||
  548.         !strcmp(cp, "fabs"))
  549.         return 2|4;
  550.     }
  551.     tp = (ex->kind == EK_VAR) ? ((Meaning *)ex->val.i)->type : ex->val.type;
  552.     if (ord_range(ex->val.type, &val.i, NULL)) {
  553.     if (val.i > 0)
  554.         return 4;
  555.     if (val.i >= 0)
  556.         return 2|4;
  557.     }
  558.     if (ord_range(ex->val.type, NULL, &val.i)) {
  559.     if (val.i < 0)
  560.         return 1;
  561.     if (val.i <= 0)
  562.         return 1|2;
  563.     }
  564.     return 1|2|4;
  565. }
  566.  
  567.  
  568.  
  569.  
  570.  
  571. Expr *dodivmod(funcname, ekind, a, b)
  572. char *funcname;
  573. enum exprkind ekind;
  574. Expr *a, *b;
  575. {
  576.     Meaning *tvar;
  577.     Type *type;
  578.     Expr *asn;
  579.     int sa, sb;
  580.  
  581.     type = promote_type_bin(a->val.type, b->val.type);
  582.     tvar = NULL;
  583.     sa = possiblesigns(a);
  584.     sb = possiblesigns(b);
  585.     if ((sa & 1) || (sb & 1)) {
  586.     if (*funcname) {
  587.         asn = NULL;
  588.         if (*funcname == '*') {
  589.         if (exprspeed(a) >= 5 || !nosideeffects(a, 0)) {
  590.             tvar = makestmttempvar(a->val.type, name_TEMP);
  591.             asn = makeexpr_assign(makeexpr_var(tvar), a);
  592.             a = makeexpr_var(tvar);
  593.         }
  594.         if (exprspeed(b) >= 5 || !nosideeffects(b, 0)) {
  595.             tvar = makestmttempvar(b->val.type, name_TEMP);
  596.             asn = makeexpr_comma(asn,
  597.                      makeexpr_assign(makeexpr_var(tvar),
  598.                              b));
  599.             b = makeexpr_var(tvar);
  600.         }
  601.         }
  602.         return makeexpr_comma(asn,
  603.                   makeexpr_bicall_2(funcname, type, a, b));
  604.     } else {
  605.         if ((sa & 1) && (ekind == EK_MOD))
  606.         note("Using % for possibly-negative arguments [317]");
  607.         return makeexpr_bin(ekind, type, a, b);
  608.     }
  609.     } else
  610.     return makeexpr_bin(ekind, type, a, b);
  611. }
  612.  
  613.  
  614.  
  615. Expr *makeexpr_div(a, b)
  616. Expr *a, *b;
  617. {
  618.     Meaning *mp;
  619.     Type *type;
  620.     long i;
  621.     int p;
  622.  
  623.     if (ISCONST(a->kind) && ISCONST(b->kind)) {
  624.         if (a->val.i >= 0 && b->val.i > 0) {
  625.         a->val.i /= b->val.i;
  626.         freeexpr(b);
  627.         return a;
  628.     }
  629.     i = gcd(a->val.i, b->val.i);
  630.     if (i >= 0) {
  631.         a->val.i /= i;
  632.         b->val.i /= i;
  633.     }
  634.     }
  635.     if (((b->kind == EK_CONST && (i = b->val.i)) ||
  636.          (b->kind == EK_VAR && (mp = (Meaning *)b->val.i)->kind == MK_CONST &&
  637.                                (i = mp->val.i) && foldconsts != 0)) && i > 0) {
  638.         if (i == 1)
  639.             return a;
  640.         if (div_po2 > 0) {
  641.             p = 0;
  642.             while (!(i&1))
  643.                 p++, i >>= 1;
  644.             if (i == 1) {
  645.         type = promote_type_bin(a->val.type, b->val.type);
  646.                 return makeexpr_bin(EK_RSH, type, a, makeexpr_long(p));
  647.             }
  648.         }
  649.     }
  650.     if (a->kind == EK_TIMES) {
  651.     for (p = 0; p < a->nargs; p++) {
  652.         if (exprsame(a->args[p], b, 1)) {
  653.         delfreearg(&a, p);
  654.         freeexpr(b);
  655.         if (a->nargs == 1)
  656.             return grabarg(a, 0);
  657.         else
  658.             return a;
  659.         } else if (ISCONST(a->args[p]->kind) && ISCONST(b->kind)) {
  660.         i = gcd(a->args[p]->val.i, b->val.i);
  661.         if (i > 1) {
  662.             a->args[p]->val.i /= i;
  663.             b->val.i /= i;
  664.             i = a->args[p]->val.i;
  665.             delfreearg(&a, p);
  666.             a = makeexpr_times(a, makeexpr_long(i));   /* resimplify */
  667.             p = -1;   /* start the loop over */
  668.         }
  669.         }
  670.     }
  671.     }
  672.     if (checkconst(b, 1)) {
  673.         freeexpr(b);
  674.         return a;
  675.     } else if (checkconst(b, -1)) {
  676.         freeexpr(b);
  677.         return makeexpr_neg(a);
  678.     } else {
  679.         if (checkconst(b, 0))
  680.             warning("Division by zero [163]");
  681.         return dodivmod(divname, EK_DIV, a, b);
  682.     }
  683. }
  684.  
  685.  
  686.  
  687. Expr *makeexpr_mod(a, b)
  688. Expr *a, *b;
  689. {
  690.     Meaning *mp;
  691.     Type *type;
  692.     long i;
  693.  
  694.     if (a->kind == EK_CONST && b->kind == EK_CONST &&
  695.         a->val.i >= 0 && b->val.i > 0) {
  696.         a->val.i %= b->val.i;
  697.         freeexpr(b);
  698.         return a;
  699.     }
  700.     if (((b->kind == EK_CONST && (i = b->val.i)) ||
  701.          (b->kind == EK_VAR && (mp = (Meaning *)b->val.i)->kind == MK_CONST &&
  702.                                (i = mp->val.i) && foldconsts != 0)) && i > 0) {
  703.         if (i == 1)
  704.             return makeexpr_long(0);
  705.         if (mod_po2 != 0) {
  706.             while (!(i&1))
  707.                 i >>= 1;
  708.             if (i == 1) {
  709.         type = promote_type_bin(a->val.type, b->val.type);
  710.                 return makeexpr_bin(EK_BAND, type, a,
  711.                                     makeexpr_minus(b, makeexpr_long(1)));
  712.             }
  713.         }
  714.     }
  715.     if (checkconst(b, 0))
  716.         warning("Division by zero [163]");
  717.     return dodivmod(modname, EK_MOD, a, b);
  718. }
  719.  
  720.  
  721.  
  722. Expr *makeexpr_rem(a, b)
  723. Expr *a, *b;
  724. {
  725.     if (!(possiblesigns(a) & 1) && !(possiblesigns(b) & 1))
  726.     return makeexpr_mod(a, b);
  727.     if (checkconst(b, 0))
  728.         warning("Division by zero [163]");
  729.     if (!*remname)
  730.     note("Translating REM same as MOD [141]");
  731.     return dodivmod(*remname ? remname : modname, EK_MOD, a, b);
  732. }
  733.  
  734.  
  735.  
  736.  
  737.  
  738. int expr_not_cost(a)
  739. Expr *a;
  740. {
  741.     int i, c;
  742.  
  743.     switch (a->kind) {
  744.  
  745.         case EK_CONST:
  746.             return 0;
  747.  
  748.         case EK_NOT:
  749.             return -1;
  750.  
  751.         case EK_EQ:
  752.         case EK_NE:
  753.         case EK_LT:
  754.         case EK_GT:
  755.         case EK_LE:
  756.         case EK_GE:
  757.             return 0;
  758.  
  759.         case EK_AND:
  760.         case EK_OR:
  761.             c = 0;
  762.             for (i = 0; i < a->nargs; i++)
  763.                 c += expr_not_cost(a->args[i]);
  764.             return (c > 1) ? 1 : c;
  765.  
  766.         case EK_BICALL:
  767.             if (!strcmp(a->val.s, oddname) ||
  768.                 !strcmp(a->val.s, evenname))
  769.                 return 0;
  770.             return 1;
  771.  
  772.         default:
  773.             return 1;
  774.     }
  775. }
  776.  
  777.  
  778.  
  779. Expr *makeexpr_not(a)
  780. Expr *a;
  781. {
  782.     Expr *ex;
  783.     int i;
  784.  
  785.     if (debug>2) { fprintf(outf,"makeexpr_not("); dumpexpr(a); fprintf(outf,")\n"); }
  786.     switch (a->kind) {
  787.  
  788.         case EK_CONST:
  789.             if (a->val.type == tp_boolean) {
  790.                 a->val.i = !a->val.i;
  791.                 return a;
  792.             }
  793.             break;
  794.  
  795.         case EK_EQ:
  796.             a->kind = EK_NE;
  797.             return a;
  798.  
  799.         case EK_NE:
  800.             a->kind = EK_EQ;
  801.             return a;
  802.  
  803.         case EK_LT:
  804.             a->kind = EK_GE;
  805.             return a;
  806.  
  807.         case EK_GT:
  808.             a->kind = EK_LE;
  809.             return a;
  810.  
  811.         case EK_LE:
  812.             a->kind = EK_GT;
  813.             return a;
  814.  
  815.         case EK_GE:
  816.             a->kind = EK_LT;
  817.             return a;
  818.  
  819.         case EK_AND:
  820.         case EK_OR:
  821.             if (expr_not_cost(a) > 0)
  822.                 break;
  823.             a->kind = (a->kind == EK_OR) ? EK_AND : EK_OR;
  824.             for (i = 0; i < a->nargs; i++)
  825.                 a->args[i] = makeexpr_not(a->args[i]);
  826.             return a;
  827.  
  828.         case EK_NOT:
  829.             ex = a->args[0];
  830.             FREE(a);
  831.             ex->val.type = tp_boolean;
  832.             return ex;
  833.  
  834.         case EK_BICALL:
  835.             if (!strcmp(a->val.s, oddname) && *evenname) {
  836.                 strchange(&a->val.s, evenname);
  837.                 return a;
  838.             } else if (!strcmp(a->val.s, evenname)) {
  839.                 strchange(&a->val.s, oddname);
  840.                 return a;
  841.             }
  842.             break;
  843.  
  844.     default:
  845.         break;
  846.     }
  847.     return makeexpr_un(EK_NOT, tp_boolean, a);
  848. }
  849.  
  850.  
  851.  
  852.  
  853. Type *mixsets(ep1, ep2)
  854. Expr **ep1, **ep2;
  855. {
  856.     Expr *ex1 = *ep1, *ex2 = *ep2;
  857.     Meaning *tvar;
  858.     long min1, max1, min2, max2;
  859.     Type *type;
  860.  
  861.     if (ex1->val.type->kind == TK_SMALLSET &&
  862.         ex2->val.type->kind == TK_SMALLSET)
  863.         return ex1->val.type;
  864.     if (ex1->val.type->kind == TK_SMALLSET) {
  865.         tvar = makestmttempvar(ex2->val.type, name_SET);
  866.         ex1 = makeexpr_bicall_2(setexpandname, ex2->val.type,
  867.                                 makeexpr_var(tvar),
  868.                                 makeexpr_arglong(ex1, 1));
  869.     }
  870.     if (ex2->val.type->kind == TK_SMALLSET) {
  871.         tvar = makestmttempvar(ex1->val.type, name_SET);
  872.         ex2 = makeexpr_bicall_2(setexpandname, ex1->val.type,
  873.                                 makeexpr_var(tvar),
  874.                                 makeexpr_arglong(ex2, 1));
  875.     }
  876.     if (ord_range(ex1->val.type->indextype, &min1, &max1) &&
  877.         ord_range(ex2->val.type->indextype, &min2, &max2)) {
  878.         if (min1 <= min2 && max1 >= max2)
  879.             type = ex1->val.type;
  880.         else if (min2 <= min1 && max2 >= max1)
  881.             type = ex2->val.type;
  882.         else {
  883.             if (min2 < min1) min1 = min2;
  884.             if (max2 > max1) max1 = max2;
  885.             type = maketype(TK_SET);
  886.             type->basetype = tp_integer;
  887.             type->indextype = maketype(TK_SUBR);
  888.             type->indextype->basetype = ord_type(ex1->val.type->indextype);
  889.             type->indextype->smin = makeexpr_long(min1);
  890.             type->indextype->smax = makeexpr_long(max1);
  891.         }
  892.     } else
  893.     type = ex1->val.type;
  894.     *ep1 = ex1, *ep2 = ex2;
  895.     return type;
  896. }
  897.  
  898.  
  899.  
  900. Meaning *istempprocptr(ex)
  901. Expr *ex;
  902. {
  903.     Meaning *mp;
  904.  
  905.     if (debug>2) { fprintf(outf,"istempprocptr("); dumpexpr(ex); fprintf(outf,")\n"); }
  906.     if (ex->kind == EK_COMMA && ex->nargs == 3) {
  907.         if ((mp = istempvar(ex->args[2])) != NULL &&
  908.         mp->type->kind == TK_PROCPTR &&
  909.         ex->args[0]->kind == EK_ASSIGN &&
  910.         ex->args[0]->args[0]->kind == EK_DOT &&
  911.         exprsame(ex->args[0]->args[0]->args[0], ex->args[2], 1) &&
  912.         ex->args[1]->kind == EK_ASSIGN &&
  913.         ex->args[1]->args[0]->kind == EK_DOT &&
  914.         exprsame(ex->args[1]->args[0]->args[0], ex->args[2], 1))
  915.         return mp;
  916.     }
  917.     if (ex->kind == EK_COMMA && ex->nargs == 2) {
  918.         if ((mp = istempvar(ex->args[1])) != NULL &&
  919.         mp->type->kind == TK_CPROCPTR &&
  920.         ex->args[0]->kind == EK_ASSIGN &&
  921.         exprsame(ex->args[0]->args[0], ex->args[1], 1))
  922.         return mp;
  923.     }
  924.     return NULL;
  925. }
  926.  
  927.  
  928.  
  929.  
  930. Expr *makeexpr_stringify(ex)
  931. Expr *ex;
  932. {
  933.     ex = makeexpr_stringcast(ex);
  934.     if (ex->val.type->kind == TK_STRING)
  935.         return ex;
  936.     return makeexpr_sprintfify(ex);
  937. }
  938.  
  939.  
  940.  
  941. Expr *makeexpr_rel(rel, a, b)
  942. enum exprkind rel;
  943. Expr *a, *b;
  944. {
  945.     int i, sign;
  946.     Expr *ex, *ex2;
  947.     Meaning *mp;
  948.     char *name;
  949.  
  950.     if (debug>2) { fprintf(outf,"makeexpr_rel(%s,", exprkindname(rel)); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  951.  
  952.     a = makeexpr_unlongcast(a);
  953.     b = makeexpr_unlongcast(b);
  954.     if ((compenums == 0 || (compenums < 0 && ansiC <= 0)) &&
  955.     (rel != EK_EQ && rel != EK_NE)){
  956.     a = enum_to_int(a);
  957.     b = enum_to_int(b);
  958.     }
  959.     if (a->val.type != b->val.type) {
  960.         if (a->val.type->kind == TK_STRING &&
  961.             a->kind != EK_CONST) {
  962.             b = makeexpr_stringify(b);
  963.         } else if (b->val.type->kind == TK_STRING &&
  964.                    b->kind != EK_CONST) {
  965.             a = makeexpr_stringify(a);
  966.         } else if (ord_type(a->val.type)->kind == TK_CHAR ||
  967.                    a->val.type->kind == TK_ARRAY) {
  968.             b = gentle_cast(b, ord_type(a->val.type));
  969.         } else if (ord_type(b->val.type)->kind == TK_CHAR ||
  970.                    b->val.type->kind == TK_ARRAY) {
  971.             a = gentle_cast(a, ord_type(b->val.type));
  972.         } else if (a->val.type == tp_anyptr && !voidstar) {
  973.             a = gentle_cast(a, b->val.type);
  974.         } else if (b->val.type == tp_anyptr && !voidstar) {
  975.             b = gentle_cast(b, a->val.type);
  976.         }
  977.     }
  978.     if (useisspace && b->val.type->kind == TK_CHAR && checkconst(b, ' ')) {
  979.         if (rel == EK_EQ) {
  980.             freeexpr(b);
  981.             return makeexpr_bicall_1("isspace", tp_boolean, a);
  982.         } else if (rel == EK_NE) {
  983.             freeexpr(b);
  984.             return makeexpr_not(makeexpr_bicall_1("isspace", tp_boolean, a));
  985.         }
  986.     }
  987.     if (rel == EK_LT || rel == EK_GE)
  988.         sign = 1;
  989.     else if (rel == EK_GT || rel == EK_LE)
  990.         sign = -1;
  991.     else
  992.         sign = 0;
  993.     if (ord_type(b->val.type)->kind == TK_INTEGER ||
  994.     ord_type(b->val.type)->kind == TK_CHAR) {
  995.         for (;;) {
  996.             if (a->kind == EK_PLUS && ISCONST(a->args[a->nargs-1]->kind) &&
  997.                  a->args[a->nargs-1]->val.i &&
  998.                  (ISCONST(b->kind) ||
  999.                   (b->kind == EK_PLUS && ISCONST(b->args[b->nargs-1]->kind)))) {
  1000.                 b = makeexpr_minus(b, copyexpr(a->args[a->nargs-1]));
  1001.                 a = makeexpr_minus(a, copyexpr(a->args[a->nargs-1]));
  1002.                 continue;
  1003.             }
  1004.             if (b->kind == EK_PLUS && ISCONST(b->args[b->nargs-1]->kind) &&
  1005.                  b->args[b->nargs-1]->val.i &&
  1006.                  ISCONST(a->kind)) {
  1007.                 a = makeexpr_minus(a, copyexpr(b->args[b->nargs-1]));
  1008.                 b = makeexpr_minus(b, copyexpr(b->args[b->nargs-1]));
  1009.                 continue;
  1010.             }
  1011.             if (b->kind == EK_PLUS && sign &&
  1012.                  checkconst(b->args[b->nargs-1], sign)) {
  1013.                 b = makeexpr_plus(b, makeexpr_long(-sign));
  1014.                 switch (rel) {
  1015.                     case EK_LT:
  1016.                         rel = EK_LE;
  1017.                         break;
  1018.                     case EK_GT:
  1019.                         rel = EK_GE;
  1020.                         break;
  1021.                     case EK_LE:
  1022.                         rel = EK_LT;
  1023.                         break;
  1024.                     case EK_GE:
  1025.                         rel = EK_GT;
  1026.                         break;
  1027.             default:
  1028.             break;
  1029.                 }
  1030.                 sign = -sign;
  1031.                 continue;
  1032.             }
  1033.             if (a->kind == EK_TIMES && checkconst(b, 0) && !sign) {
  1034.                 for (i = 0; i < a->nargs; i++) {
  1035.                     if (ISCONST(a->args[i]->kind) && a->args[i]->val.i)
  1036.                         break;
  1037.                     if (a->args[i]->kind == EK_SIZEOF)
  1038.                         break;
  1039.                 }
  1040.                 if (i < a->nargs) {
  1041.                     delfreearg(&a, i);
  1042.                     continue;
  1043.                 }
  1044.             }
  1045.             break;
  1046.         }
  1047.         if (a->kind == EK_BICALL && !strcmp(a->val.s, "strlen") &&
  1048.             checkconst(b, 0)) {
  1049.             if (rel == EK_LT || rel == EK_GE) {
  1050.                 note("Unusual use of STRLEN encountered [142]");
  1051.             } else {
  1052.                 freeexpr(b);
  1053.                 a = makeexpr_hat(grabarg(a, 0), 0);
  1054.                 b = makeexpr_char(0);      /* "strlen(a) = 0" => "*a == 0" */
  1055.                 if (rel == EK_EQ || rel == EK_LE)
  1056.                     return makeexpr_rel(EK_EQ, a, b);
  1057.                 else
  1058.                     return makeexpr_rel(EK_NE, a, b);
  1059.             }
  1060.         }
  1061.         if (ISCONST(a->kind) && ISCONST(b->kind)) {
  1062.             if ((a->val.i == b->val.i && (rel == EK_EQ || rel == EK_GE || rel == EK_LE)) ||
  1063.                 (a->val.i <  b->val.i && (rel == EK_NE || rel == EK_LE || rel == EK_LT)) ||
  1064.                 (a->val.i >  b->val.i && (rel == EK_NE || rel == EK_GE || rel == EK_GT)))
  1065.                 return makeexpr_val(make_ord(tp_boolean, 1));
  1066.             else
  1067.                 return makeexpr_val(make_ord(tp_boolean, 0));
  1068.         }
  1069.     if ((a->val.type == tp_char || true_type(a) == tp_char) &&
  1070.         ISCONST(b->kind) && signedchars != 0) {
  1071.         i = (b->val.i == 128 && sign == 1) ||
  1072.         (b->val.i == 127 && sign == -1);
  1073.         if (highcharbits && (highcharbits > 0 || signedchars < 0) && i) {
  1074.         if (highcharbits == 2)
  1075.             b = makeexpr_long(128);
  1076.         else
  1077.             b = makeexpr_un(EK_BNOT, tp_integer, makeexpr_long(127));
  1078.         return makeexpr_rel((rel == EK_GE || rel == EK_GT)
  1079.                     ? EK_NE : EK_EQ,
  1080.                     makeexpr_bin(EK_BAND, tp_integer,
  1081.                          eatcasts(a), b),
  1082.                     makeexpr_long(0));
  1083.         } else if (signedchars == 1 && i) {
  1084.         return makeexpr_rel((rel == EK_GE || rel == EK_GT)
  1085.                     ? EK_LT : EK_GE,
  1086.                     eatcasts(a), makeexpr_long(0));
  1087.         } else if (signedchars == 1 && b->val.i >= 128 && sign == 0) {
  1088.         b->val.i -= 256;
  1089.         } else if (b->val.i >= 128 ||
  1090.                (b->val.i == 127 && sign != 0)) {
  1091.         if (highcharbits && (highcharbits > 0 || signedchars < 0))
  1092.             a = makeexpr_bin(EK_BAND, a->val.type, eatcasts(a),
  1093.                      makeexpr_long(255));
  1094.         else
  1095.             a = force_unsigned(a);
  1096.         }
  1097.     }
  1098.     } else if (a->val.type->kind == TK_STRING &&
  1099.                b->val.type->kind == TK_STRING) {
  1100.         if (b->kind == EK_CONST && b->val.i == 0 && !sign) {
  1101.             a = makeexpr_hat(a, 0);
  1102.             b = makeexpr_char(0);      /* "a = ''" => "*a == 0" */
  1103.         } else {
  1104.             a = makeexpr_bicall_2("strcmp", tp_int, a, b);
  1105.             b = makeexpr_long(0);
  1106.         }
  1107.     } else if ((a->val.type->kind == TK_ARRAY ||
  1108.         a->val.type->kind == TK_STRING ||
  1109.         a->val.type->kind == TK_RECORD) &&
  1110.            (b->val.type->kind == TK_ARRAY ||
  1111.         b->val.type->kind == TK_STRING ||
  1112.         b->val.type->kind == TK_RECORD)) {
  1113.         if (a->val.type->kind == TK_ARRAY) {
  1114.             if (b->val.type->kind == TK_ARRAY) {
  1115.                 ex = makeexpr_sizeof(copyexpr(a), 0);
  1116.                 ex2 = makeexpr_sizeof(copyexpr(b), 0);
  1117.                 if (!exprsame(ex, ex2, 1))
  1118.                     warning("Incompatible array sizes [164]");
  1119.                 freeexpr(ex2);
  1120.             } else {
  1121.                 ex = makeexpr_sizeof(copyexpr(a), 0);
  1122.             }
  1123.         } else
  1124.             ex = makeexpr_sizeof(copyexpr(b), 0);
  1125.     name = (usestrncmp &&
  1126.         a->val.type->kind == TK_ARRAY &&
  1127.         a->val.type->basetype->kind == TK_CHAR) ? "strncmp" : "memcmp";
  1128.         a = makeexpr_bicall_3(name, tp_int,
  1129.                   makeexpr_addr(a), 
  1130.                   makeexpr_addr(b), ex);
  1131.         b = makeexpr_long(0);
  1132.     } else if (a->val.type->kind == TK_SET ||
  1133.                a->val.type->kind == TK_SMALLSET) {
  1134.         if (rel == EK_GE) {
  1135.             swapexprs(a, b);
  1136.             rel = EK_LE;
  1137.         }
  1138.         if (mixsets(&a, &b)->kind == TK_SMALLSET) {
  1139.             if (rel == EK_LE) {
  1140.                 a = makeexpr_bin(EK_BAND, tp_integer,
  1141.                                  a, makeexpr_un(EK_BNOT, tp_integer, b));
  1142.                 b = makeexpr_long(0);
  1143.                 rel = EK_EQ;
  1144.             }
  1145.         } else if (b->kind == EK_BICALL &&
  1146.                    !strcmp(b->val.s, setexpandname) &&
  1147.                    (mp = istempvar(b->args[0])) != NULL &&
  1148.                    checkconst(b->args[1], 0)) {
  1149.             canceltempvar(mp);
  1150.             a = makeexpr_hat(a, 0);
  1151.             b = grabarg(b, 1);
  1152.             if (rel == EK_LE)
  1153.                 rel = EK_EQ;
  1154.         } else {
  1155.             ex = makeexpr_bicall_2((rel == EK_LE) ? subsetname : setequalname,
  1156.                                    tp_boolean, a, b);
  1157.             return (rel == EK_NE) ? makeexpr_not(ex) : ex;
  1158.         }
  1159.     } else if (a->val.type->kind == TK_PROCPTR ||
  1160.            a->val.type->kind == TK_CPROCPTR) {
  1161.         /* we compare proc only (not link) -- same as Pascal compiler! */
  1162.     if (a->val.type->kind == TK_PROCPTR)
  1163.         a = makeexpr_dotq(a, "proc", tp_anyptr);
  1164.         if ((mp = istempprocptr(b)) != NULL) {
  1165.             canceltempvar(mp);
  1166.         b = grabarg(grabarg(b, 0), 1);
  1167.             if (!voidstar)
  1168.                 b = makeexpr_cast(b, tp_anyptr);
  1169.         } else if (b->val.type->kind == TK_PROCPTR)
  1170.             b = makeexpr_dotq(b, "proc", tp_anyptr);
  1171.     }
  1172.     return makeexpr_bin(rel, tp_boolean, a, b);
  1173. }
  1174.  
  1175.