home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / prgramer / pascal2c / expr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-03  |  145.4 KB  |  5,575 lines
  1. /* "p2c", a Pascal to C translator.
  2.    Copyright (C) 1989, 1990, 1991 Free Software Foundation.
  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.  
  19.  
  20. #define PROTO_EXPR_C
  21. #include "trans.h"
  22.  
  23.  
  24.  
  25.  
  26.  
  27. void free_value(val)
  28. Value *val;
  29. {
  30.     if (!val || !val->type)
  31.     return;
  32.     switch (val->type->kind) {
  33.  
  34.         case TK_STRING:
  35.         case TK_REAL:
  36.         case TK_ARRAY:
  37.         case TK_RECORD:
  38.         case TK_SET:
  39.             if (val->s)
  40.                 FREE(val->s);
  41.             break;
  42.  
  43.     default:
  44.         break;
  45.     }
  46. }
  47.  
  48.  
  49. Value copyvalue(val)
  50. Value val;
  51. {
  52.     char *cp;
  53.  
  54.     switch (val.type->kind) {
  55.  
  56.         case TK_STRING:
  57.         case TK_SET:
  58.             if (val.s) {
  59.                 cp = ALLOC(val.i+1, char, literals);
  60.                 memcpy(cp, val.s, val.i);
  61.         cp[val.i] = 0;
  62.                 val.s = cp;
  63.             }
  64.             break;
  65.  
  66.         case TK_REAL:
  67.         case TK_ARRAY:
  68.         case TK_RECORD:
  69.             if (val.s)
  70.                 val.s = stralloc(val.s);
  71.             break;
  72.  
  73.     default:
  74.         break;
  75.     }
  76.     return val;
  77. }
  78.  
  79.  
  80. int valuesame(a, b)
  81. Value a, b;
  82. {
  83.     if (a.type != b.type)
  84.         return 0;
  85.     switch (a.type->kind) {
  86.  
  87.         case TK_INTEGER:
  88.         case TK_CHAR:
  89.         case TK_BOOLEAN:
  90.         case TK_ENUM:
  91.         case TK_SMALLSET:
  92.         case TK_SMALLARRAY:
  93.             return (a.i == b.i);
  94.  
  95.         case TK_STRING:
  96.         case TK_SET:
  97.             return (a.i == b.i && !memcmp(a.s, b.s, a.i));
  98.  
  99.         case TK_REAL:
  100.         case TK_ARRAY:
  101.         case TK_RECORD:
  102.             return (!strcmp(a.s, b.s));
  103.  
  104.         default:
  105.             return 1;
  106.     }
  107. }
  108.  
  109.  
  110.  
  111. char *value_name(val, intfmt, islong)
  112. Value val;
  113. char *intfmt;
  114. int islong;
  115. {
  116.     Meaning *mp;
  117.     Type *type = val.type;
  118.  
  119.     if (type->kind == TK_SUBR)
  120.     type = type->basetype;
  121.     switch (type->kind) {
  122.  
  123.         case TK_INTEGER:
  124.         case TK_SMALLSET:
  125.         case TK_SMALLARRAY:
  126.             if (!intfmt)
  127.         intfmt = "%ld";
  128.         if (*intfmt == '\'') {
  129.         if (val.i >= -'~' && val.i <= -' ') {
  130.             intfmt = format_s("-%s", intfmt);
  131.             val.i = -val.i;
  132.         }
  133.         if (val.i < ' ' || val.i > '~' || islong)
  134.             intfmt = "%ld";
  135.         }
  136.             if (islong)
  137.                 intfmt = format_s("%sL", intfmt);
  138.             return format_d(intfmt, val.i);
  139.  
  140.         case TK_REAL:
  141.             return val.s;
  142.  
  143.         case TK_ARRAY:    /* obsolete */
  144.         case TK_RECORD:   /* obsolete */
  145.             return val.s;
  146.  
  147.         case TK_STRING:
  148.             return makeCstring(val.s, val.i);
  149.  
  150.         case TK_BOOLEAN:
  151.             if (!intfmt)
  152.                 if (val.i == 1 && *name_TRUE &&
  153.             strcmp(name_TRUE, "1") && !islong)
  154.                     intfmt = name_TRUE;
  155.                 else if (val.i == 0 && *name_FALSE &&
  156.              strcmp(name_FALSE, "0") && !islong)
  157.                     intfmt = name_FALSE;
  158.                 else
  159.                     intfmt = "%ld";
  160.             if (islong)
  161.                 intfmt = format_s("%sL", intfmt);
  162.             return format_d(intfmt, val.i);
  163.  
  164.         case TK_CHAR:
  165.             if (islong)
  166.                 return format_d("%ldL", val.i);
  167.         else if ((val.i < 0 || val.i > 127) && highcharints)
  168.         return format_d("%ld", val.i);
  169.             else
  170.                 return makeCchar(val.i);
  171.  
  172.         case TK_POINTER:
  173.             return (*name_NULL) ? name_NULL : "NULL";
  174.  
  175.         case TK_ENUM:
  176.             mp = val.type->fbase;
  177.             while (mp && mp->val.i != val.i)
  178.                 mp = mp->xnext;
  179.             if (!mp) {
  180.                 intwarning("value_name", "bad enum value [152]");
  181.                 return format_d("%ld", val.i);
  182.             }
  183.             return mp->name;
  184.  
  185.         default:
  186.             intwarning("value_name", format_s("bad type for constant: %s [153]",
  187.                                               typekindname(type->kind)));
  188.             return "<spam>";
  189.     }
  190. }
  191.  
  192.  
  193.  
  194.  
  195. Value value_cast(val, type)
  196. Value val;
  197. Type *type;
  198. {
  199.     char buf[20];
  200.  
  201.     if (type->kind == TK_SUBR)
  202.         type = type->basetype;
  203.     if (val.type == type)
  204.         return val;
  205.     if (type && val.type) {
  206.         switch (type->kind) {
  207.  
  208.             case TK_REAL:
  209.                 if (ord_type(val.type)->kind == TK_INTEGER) {
  210.                     sprintf(buf, "%d.0", val.i);
  211.                     val.s = stralloc(buf);
  212.                     val.type = tp_real;
  213.                     return val;
  214.                 }
  215.                 break;
  216.  
  217.             case TK_CHAR:
  218.                 if (val.type->kind == TK_STRING) {
  219.                     if (val.i != 1)
  220.                         if (val.i > 0)
  221.                             warning("Char constant with more than one character [154]");
  222.                         else
  223.                             warning("Empty char constant [155]");
  224.                     val.i = val.s[0] & 0xff;
  225.                     val.s = NULL;
  226.                     val.type = tp_char;
  227.                     return val;
  228.                 }
  229.  
  230.             case TK_POINTER:
  231.                 if (val.type == tp_anyptr && castnull != 1) {
  232.                     val.type = type;
  233.                     return val;
  234.                 }
  235.  
  236.         default:
  237.         break;
  238.         }
  239.     }
  240.     val.type = NULL;
  241.     return val;
  242. }
  243.  
  244.  
  245.  
  246. Type *ord_type(tp)
  247. Type *tp;
  248. {
  249.     if (!tp) {
  250.         warning("Expected a constant [127]");
  251.         return tp_integer;
  252.     }
  253.     switch (tp->kind) {
  254.  
  255.         case TK_SUBR:
  256.             tp = tp->basetype;
  257.             break;
  258.  
  259.         case TK_STRING:
  260.             if (!CHECKORDEXPR(tp->indextype->smax, 1))
  261.                 tp = tp_char;
  262.             break;
  263.  
  264.     default:
  265.         break;
  266.  
  267.     }
  268.     return tp;
  269. }
  270.  
  271.  
  272.  
  273. int long_type(tp)
  274. Type *tp;
  275. {
  276.     switch (tp->kind) {
  277.  
  278.         case TK_INTEGER:
  279.             return (tp != tp_int && tp != tp_uint && tp != tp_sint);
  280.  
  281.         case TK_SUBR:
  282.             return (findbasetype(tp, ODECL_NOPRES) == tp_integer);
  283.  
  284.         default:
  285.             return 0;
  286.     }
  287. }
  288.  
  289.  
  290.  
  291. Value make_ord(type, i)
  292. Type *type;
  293. long i;
  294. {
  295.     Value val;
  296.  
  297.     if (type->kind == TK_ENUM)
  298.         type = findbasetype(type, ODECL_NOPRES);
  299.     if (type->kind == TK_SUBR)
  300.         type = type->basetype;
  301.     val.type = type;
  302.     val.i = i;
  303.     val.s = NULL;
  304.     return val;
  305. }
  306.  
  307.  
  308.  
  309. long ord_value(val)
  310. Value val;
  311. {
  312.     switch (val.type->kind) {
  313.  
  314.         case TK_INTEGER:
  315.         case TK_ENUM:
  316.         case TK_CHAR:
  317.         case TK_BOOLEAN:
  318.             return val.i;
  319.  
  320.         case TK_STRING:
  321.             if (val.i == 1)
  322.                 return val.s[0] & 0xff;
  323.  
  324.         /* fall through */
  325.         default:
  326.             warning("Expected an ordinal type [156]");
  327.             return 0;
  328.     }
  329. }
  330.  
  331.  
  332.  
  333. void ord_range_expr(type, smin, smax)
  334. Type *type;
  335. Expr **smin, **smax;
  336. {
  337.     if (!type) {
  338.         warning("Expected a constant [127]");
  339.         type = tp_integer;
  340.     }
  341.     if (type->kind == TK_STRING)
  342.         type = tp_char;
  343.     switch (type->kind) {
  344.  
  345.         case TK_SUBR:
  346.         case TK_INTEGER:
  347.         case TK_ENUM:
  348.         case TK_CHAR:
  349.         case TK_BOOLEAN:
  350.             if (smin) *smin = type->smin;
  351.             if (smax) *smax = type->smax;
  352.             break;
  353.  
  354.         default:
  355.             warning("Expected an ordinal type [156]");
  356.             if (smin) *smin = makeexpr_long(0);
  357.             if (smax) *smax = makeexpr_long(1);
  358.             break;
  359.     }
  360. }
  361.  
  362.  
  363. int ord_range(type, smin, smax)
  364. Type *type;
  365. long *smin, *smax;
  366. {
  367.     Expr *emin, *emax;
  368.     Value vmin, vmax;
  369.  
  370.     ord_range_expr(type, &emin, &emax);
  371.     if (smin) {
  372.         vmin = eval_expr(emin);
  373.         if (!vmin.type)
  374.             return 0;
  375.     }
  376.     if (smax) {
  377.         vmax = eval_expr(emax);
  378.         if (!vmax.type)
  379.             return 0;
  380.     }
  381.     if (smin) *smin = ord_value(vmin);
  382.     if (smax) *smax = ord_value(vmax);
  383.     return 1;
  384. }
  385.  
  386.  
  387.  
  388.  
  389.  
  390.  
  391.  
  392. void freeexpr(ex)
  393. register Expr *ex;
  394. {
  395.     register int i;
  396.  
  397.     if (ex) {
  398.         for (i = 0; i < ex->nargs; i++)
  399.             freeexpr(ex->args[i]);
  400.         switch (ex->kind) {
  401.  
  402.             case EK_CONST:
  403.             case EK_LONGCONST:
  404.                 free_value(&ex->val);
  405.                 break;
  406.  
  407.             case EK_DOT:
  408.             case EK_NAME:
  409.             case EK_BICALL:
  410.                 if (ex->val.s)
  411.                     FREE(ex->val.s);
  412.                 break;
  413.  
  414.         default:
  415.         break;
  416.         }
  417.         FREE(ex);
  418.     }
  419. }
  420.  
  421.  
  422.  
  423.  
  424. Expr *makeexpr(kind, n)
  425. enum exprkind kind;
  426. int n;
  427. {
  428.     Expr *ex;
  429.  
  430.     ex = ALLOCV(sizeof(Expr) + (n-1)*sizeof(Expr *), Expr, exprs);
  431.     ex->val.i = 0;
  432.     ex->val.s = NULL;
  433.     ex->kind = kind;
  434.     ex->nargs = n;
  435.     return ex;
  436. }
  437.  
  438.  
  439. Expr *makeexpr_un(kind, type, arg1)
  440. enum exprkind kind;
  441. Type *type;
  442. Expr *arg1;
  443. {
  444.     Expr *ex;
  445.  
  446.     ex = makeexpr(kind, 1);
  447.     ex->val.type = type;
  448.     ex->args[0] = arg1;
  449.     if (debug>2) { fprintf(outf,"makeexpr_un returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  450.     return ex;
  451. }
  452.  
  453.  
  454. Expr *makeexpr_bin(kind, type, arg1, arg2)
  455. enum exprkind kind;
  456. Type *type;
  457. Expr *arg1, *arg2;
  458. {
  459.     Expr *ex;
  460.  
  461.     ex = makeexpr(kind, 2);
  462.     ex->val.type = type;
  463.     ex->args[0] = arg1;
  464.     ex->args[1] = arg2;
  465.     if (debug>2) { fprintf(outf,"makeexpr_bin returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  466.     return ex;
  467. }
  468.  
  469.  
  470.  
  471. Expr *makeexpr_val(val)
  472. Value val;
  473. {
  474.     Expr *ex;
  475.  
  476.     if (val.type->kind == TK_INTEGER &&
  477.         (val.i < -32767 || val.i > 32767) &&
  478.         sizeof_int < 32)
  479.         ex = makeexpr(EK_LONGCONST, 0);
  480.     else
  481.         ex = makeexpr(EK_CONST, 0);
  482.     ex->val = val;
  483.     if (debug>2) { fprintf(outf,"makeexpr_val returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  484.     return ex;
  485. }
  486.  
  487.  
  488.  
  489. Expr *makeexpr_char(c)
  490. int c;
  491. {
  492.     return makeexpr_val(make_ord(tp_char, c));
  493. }
  494.  
  495.  
  496. Expr *makeexpr_long(i)
  497. long i;
  498. {
  499.     return makeexpr_val(make_ord(tp_integer, i));
  500. }
  501.  
  502.  
  503. Expr *makeexpr_real(r)
  504. char *r;
  505. {
  506.     Value val;
  507.  
  508.     val.type = tp_real;
  509.     val.i = 0;
  510.     val.s = stralloc(r);
  511.     return makeexpr_val(val);
  512. }
  513.  
  514.  
  515. Expr *makeexpr_lstring(msg, len)
  516. char *msg;
  517. int len;
  518. {
  519.     Value val;
  520.  
  521.     val.type = tp_str255;
  522.     val.i = len;
  523.     val.s = ALLOC(len+1, char, literals);
  524.     memcpy(val.s, msg, len);
  525.     val.s[len] = 0;
  526.     return makeexpr_val(val);
  527. }
  528.  
  529.  
  530. Expr *makeexpr_string(msg)
  531. char *msg;
  532. {
  533.     Value val;
  534.  
  535.     val.type = tp_str255;
  536.     val.i = strlen(msg);
  537.     val.s = stralloc(msg);
  538.     return makeexpr_val(val);
  539. }
  540.  
  541.  
  542. int checkstring(ex, msg)
  543. Expr *ex;
  544. char *msg;
  545. {
  546.     if (!ex || ex->val.type->kind != TK_STRING || ex->kind != EK_CONST)
  547.         return 0;
  548.     if (ex->val.i != strlen(msg))
  549.         return 0;
  550.     return memcmp(ex->val.s, msg, ex->val.i) == 0;
  551. }
  552.  
  553.  
  554.  
  555. Expr *makeexpr_var(mp)
  556. Meaning *mp;
  557. {
  558.     Expr *ex;
  559.  
  560.     ex = makeexpr(EK_VAR, 0);
  561.     ex->val.i = (long) mp;
  562.     ex->val.type = mp->type;
  563.     if (debug>2) { fprintf(outf,"makeexpr_var returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  564.     return ex;
  565. }
  566.  
  567.  
  568.  
  569. Expr *makeexpr_name(name, type)
  570. char *name;
  571. Type *type;
  572. {
  573.     Expr *ex;
  574.  
  575.     ex = makeexpr(EK_NAME, 0);
  576.     ex->val.s = stralloc(name);
  577.     ex->val.type = type;
  578.     if (debug>2) { fprintf(outf,"makeexpr_name returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  579.     return ex;
  580. }
  581.  
  582.  
  583.  
  584. Expr *makeexpr_setbits()
  585. {
  586.     if (*name_SETBITS)
  587.         return makeexpr_name(name_SETBITS, tp_integer);
  588.     else
  589.         return makeexpr_long(setbits);
  590. }
  591.  
  592.  
  593.  
  594. /* Note: BICALL's to the following functions should obey the ANSI standard. */
  595. /*       Non-ANSI transformations occur while writing the expression. */
  596. /*              char *sprintf(buf, fmt, ...)   [returns buf]  */
  597. /*              void *memcpy(dest, src, size)  [returns dest] */
  598.  
  599. Expr *makeexpr_bicall_0(name, type)
  600. char *name;
  601. Type *type;
  602. {
  603.     Expr *ex;
  604.  
  605.     if (!name || !*name) {
  606.         intwarning("makeexpr_bicall_0", "Required name of built-in procedure is missing [157]");
  607.         name = "MissingProc";
  608.     }
  609.     ex = makeexpr(EK_BICALL, 0);
  610.     ex->val.s = stralloc(name);
  611.     ex->val.type = type;
  612.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  613.     return ex;
  614. }
  615.  
  616.  
  617. Expr *makeexpr_bicall_1(name, type, arg1)
  618. char *name;
  619. Type *type;
  620. Expr *arg1;
  621. {
  622.     Expr *ex;
  623.  
  624.     if (!name || !*name) {
  625.         intwarning("makeexpr_bicall_1", "Required name of built-in procedure is missing [157]");
  626.         name = "MissingProc";
  627.     }
  628.     ex = makeexpr(EK_BICALL, 1);
  629.     ex->val.s = stralloc(name);
  630.     ex->val.type = type;
  631.     ex->args[0] = arg1;
  632.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  633.     return ex;
  634. }
  635.  
  636.  
  637. Expr *makeexpr_bicall_2(name, type, arg1, arg2)
  638. char *name;
  639. Type *type;
  640. Expr *arg1, *arg2;
  641. {
  642.     Expr *ex;
  643.  
  644.     if (!name || !*name) {
  645.         intwarning("makeexpr_bicall_2", "Required name of built-in procedure is missing [157]");
  646.         name = "MissingProc";
  647.     }
  648.     ex = makeexpr(EK_BICALL, 2);
  649.     if (!strcmp(name, "~SETIO"))
  650.         name = (iocheck_flag) ? "~~SETIO" : name_SETIO;
  651.     ex->val.s = stralloc(name);
  652.     ex->val.type = type;
  653.     ex->args[0] = arg1;
  654.     ex->args[1] = arg2;
  655.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  656.     return ex;
  657. }
  658.  
  659.  
  660. Expr *makeexpr_bicall_3(name, type, arg1, arg2, arg3)
  661. char *name;
  662. Type *type;
  663. Expr *arg1, *arg2, *arg3;
  664. {
  665.     Expr *ex;
  666.  
  667.     if (!name || !*name) {
  668.         intwarning("makeexpr_bicall_3", "Required name of built-in procedure is missing [157]");
  669.         name = "MissingProc";
  670.     }
  671.     ex = makeexpr(EK_BICALL, 3);
  672.     ex->val.s = stralloc(name);
  673.     ex->val.type = type;
  674.     ex->args[0] = arg1;
  675.     ex->args[1] = arg2;
  676.     ex->args[2] = arg3;
  677.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  678.     return ex;
  679. }
  680.  
  681.  
  682. Expr *makeexpr_bicall_4(name, type, arg1, arg2, arg3, arg4)
  683. char *name;
  684. Type *type;
  685. Expr *arg1, *arg2, *arg3, *arg4;
  686. {
  687.     Expr *ex;
  688.  
  689.     if (!name || !*name) {
  690.         intwarning("makeexpr_bicall_4", "Required name of built-in procedure is missing [157]");
  691.         name = "MissingProc";
  692.     }
  693.     ex = makeexpr(EK_BICALL, 4);
  694.     if (!strcmp(name, "~CHKIO"))
  695.         name = (iocheck_flag) ? "~~CHKIO" : name_CHKIO;
  696.     ex->val.s = stralloc(name);
  697.     ex->val.type = type;
  698.     ex->args[0] = arg1;
  699.     ex->args[1] = arg2;
  700.     ex->args[2] = arg3;
  701.     ex->args[3] = arg4;
  702.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  703.     return ex;
  704. }
  705.  
  706.  
  707. Expr *makeexpr_bicall_5(name, type, arg1, arg2, arg3, arg4, arg5)
  708. char *name;
  709. Type *type;
  710. Expr *arg1, *arg2, *arg3, *arg4, *arg5;
  711. {
  712.     Expr *ex;
  713.  
  714.     if (!name || !*name) {
  715.         intwarning("makeexpr_bicall_5", "Required name of built-in procedure is missing [157]");
  716.         name = "MissingProc";
  717.     }
  718.     ex = makeexpr(EK_BICALL, 5);
  719.     ex->val.s = stralloc(name);
  720.     ex->val.type = type;
  721.     ex->args[0] = arg1;
  722.     ex->args[1] = arg2;
  723.     ex->args[2] = arg3;
  724.     ex->args[3] = arg4;
  725.     ex->args[4] = arg5;
  726.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  727.     return ex;
  728. }
  729.  
  730.  
  731.  
  732.  
  733. Expr *copyexpr(ex)
  734. register Expr *ex;
  735. {
  736.     register int i;
  737.     register Expr *ex2;
  738.  
  739.     if (ex) {
  740.         ex2 = makeexpr(ex->kind, ex->nargs);
  741.         for (i = 0; i < ex->nargs; i++)
  742.             ex2->args[i] = copyexpr(ex->args[i]);
  743.         switch (ex->kind) {
  744.  
  745.             case EK_CONST:
  746.             case EK_LONGCONST:
  747.                 ex2->val = copyvalue(ex->val);
  748.                 break;
  749.  
  750.             case EK_DOT:
  751.             case EK_NAME:
  752.             case EK_BICALL:
  753.                 ex2->val.type = ex->val.type;
  754.                 ex2->val.i = ex->val.i;
  755.                 if (ex->val.s)
  756.                     ex2->val.s = stralloc(ex->val.s);
  757.                 break;
  758.  
  759.             default:
  760.                 ex2->val = ex->val;
  761.                 break;
  762.         }
  763.         return ex2;
  764.     } else
  765.         return NULL;
  766. }
  767.  
  768.  
  769.  
  770. int exprsame(a, b, strict)
  771. register Expr *a, *b;
  772. int strict;
  773. {
  774.     register int i;
  775.  
  776.     if (!a)
  777.         return (!b);
  778.     if (!b)
  779.         return 0;
  780.     if (a->val.type != b->val.type && strict != 2) {
  781.         if (strict ||
  782.         !((a->val.type->kind == TK_POINTER &&
  783.            a->val.type->basetype == b->val.type) ||
  784.           (b->val.type->kind == TK_POINTER &&
  785.            b->val.type->basetype == a->val.type)))
  786.         return 0;
  787.     }
  788.     if (a->kind != b->kind || a->nargs != b->nargs)
  789.         return 0;
  790.     switch (a->kind) {
  791.  
  792.         case EK_CONST:
  793.         case EK_LONGCONST:
  794.             if (!valuesame(a->val, b->val))
  795.                 return 0;
  796.             break;
  797.  
  798.         case EK_BICALL:
  799.         case EK_NAME:
  800.             if (strcmp(a->val.s, b->val.s))
  801.                 return 0;
  802.             break;
  803.  
  804.         case EK_VAR:
  805.         case EK_FUNCTION:
  806.         case EK_CTX:
  807.         case EK_MACARG:
  808.             if (a->val.i != b->val.i)
  809.                 return 0;
  810.             break;
  811.  
  812.         case EK_DOT:
  813.             if (a->val.i != b->val.i ||
  814.                 (!a->val.i && strcmp(a->val.s, b->val.s)))
  815.                 return 0;
  816.             break;
  817.  
  818.     default:
  819.         break;
  820.     }
  821.     i = a->nargs;
  822.     while (--i >= 0)
  823.         if (!exprsame(a->args[i], b->args[i], (strict == 2) ? 1 : strict))
  824.             return 0;
  825.     return 1;
  826. }
  827.  
  828.  
  829.  
  830. int exprequiv(a, b)
  831. register Expr *a, *b;
  832. {
  833.     register int i, j, k;
  834.     enum exprkind kind2;
  835.  
  836.     if (!a)
  837.         return (!b);
  838.     if (!b)
  839.         return 0;
  840.     switch (a->kind) {
  841.  
  842.         case EK_PLUS:
  843.         case EK_TIMES:
  844.         case EK_BAND:
  845.         case EK_BOR:
  846.         case EK_BXOR:
  847.         case EK_EQ:
  848.         case EK_NE:
  849.             if (b->kind != a->kind || b->nargs != a->nargs ||
  850.                 b->val.type != a->val.type)
  851.                 return 0;
  852.             if (a->nargs > 3)
  853.                 break;
  854.             for (i = 0; i < b->nargs; i++) {
  855.                 if (exprequiv(a->args[0], b->args[i])) {
  856.                     for (j = 0; j < b->nargs; j++) {
  857.                         if (j != i &&
  858.                             exprequiv(a->args[1], b->args[i])) {
  859.                             if (a->nargs == 2)
  860.                                 return 1;
  861.                             for (k = 0; k < b->nargs; k++) {
  862.                                 if (k != i && k != j &&
  863.                                     exprequiv(a->args[2], b->args[k]))
  864.                                     return 1;
  865.                             }
  866.                         }
  867.                     }
  868.                 }
  869.             }
  870.             break;
  871.  
  872.         case EK_LT:
  873.         case EK_GT:
  874.         case EK_LE:
  875.         case EK_GE:
  876.             switch (a->kind) {
  877.                 case EK_LT:  kind2 = EK_GT; break;
  878.                 case EK_GT:  kind2 = EK_LT; break;
  879.                 case EK_LE:  kind2 = EK_GE; break;
  880.                 default:     kind2 = EK_LE; break;
  881.             }
  882.             if (b->kind != kind2 || b->val.type != a->val.type)
  883.                 break;
  884.             if (exprequiv(a->args[0], b->args[1]) &&
  885.                 exprequiv(a->args[1], b->args[0])) {
  886.                 return 1;
  887.             }
  888.             break;
  889.  
  890.         case EK_CONST:
  891.         case EK_LONGCONST:
  892.         case EK_BICALL:
  893.         case EK_NAME:
  894.         case EK_VAR:
  895.         case EK_FUNCTION:
  896.         case EK_CTX:
  897.         case EK_DOT:
  898.             return exprsame(a, b, 0);
  899.  
  900.     default:
  901.         break;
  902.     }
  903.     if (b->kind != a->kind || b->nargs != a->nargs ||
  904.         b->val.type != a->val.type)
  905.         return 0;
  906.     i = a->nargs;
  907.     while (--i >= 0)
  908.         if (!exprequiv(a->args[i], b->args[i]))
  909.             return 0;
  910.     return 1;
  911. }
  912.  
  913.  
  914.  
  915. void deletearg(ex, n)
  916. Expr **ex;
  917. register int n;
  918. {
  919.     register Expr *ex1 = *ex, *ex2;
  920.     register int i;
  921.  
  922.     if (debug>2) { fprintf(outf,"deletearg("); dumpexpr(*ex); fprintf(outf,", %d)\n", n); }
  923.     if (n < 0 || n >= (*ex)->nargs) {
  924.         intwarning("deletearg", "argument number out of range [158]");
  925.         return;
  926.     }
  927.     ex2 = makeexpr(ex1->kind, ex1->nargs-1);
  928.     ex2->val = ex1->val;
  929.     for (i = 0; i < n; i++)
  930.         ex2->args[i] = ex1->args[i];
  931.     for (; i < ex2->nargs; i++)
  932.         ex2->args[i] = ex1->args[i+1];
  933.     *ex = ex2;
  934.     FREE(ex1);
  935.     if (debug>2) { fprintf(outf,"deletearg returns "); dumpexpr(*ex); fprintf(outf,"\n"); }
  936. }
  937.  
  938.  
  939.  
  940. void insertarg(ex, n, arg)
  941. Expr **ex;
  942. Expr *arg;
  943. register int n;
  944. {
  945.     register Expr *ex1 = *ex, *ex2;
  946.     register int i;
  947.  
  948.     if (debug>2) { fprintf(outf,"insertarg("); dumpexpr(*ex); fprintf(outf,", %d)\n", n); }
  949.     if (n < 0 || n > (*ex)->nargs) {
  950.         intwarning("insertarg", "argument number out of range [159]");
  951.         return;
  952.     }
  953.     ex2 = makeexpr(ex1->kind, ex1->nargs+1);
  954.     ex2->val = ex1->val;
  955.     for (i = 0; i < n; i++)
  956.         ex2->args[i] = ex1->args[i];
  957.     ex2->args[n] = arg;
  958.     for (; i < ex1->nargs; i++)
  959.         ex2->args[i+1] = ex1->args[i];
  960.     *ex = ex2;
  961.     FREE(ex1);
  962.     if (debug>2) { fprintf(outf,"insertarg returns "); dumpexpr(*ex); fprintf(outf,"\n"); }
  963. }
  964.  
  965.  
  966.  
  967. Expr *grabarg(ex, n)
  968. Expr *ex;
  969. int n;
  970. {
  971.     Expr *ex2;
  972.  
  973.     if (n < 0 || n >= ex->nargs) {
  974.         intwarning("grabarg", "argument number out of range [160]");
  975.         return ex;
  976.     }
  977.     ex2 = ex->args[n];
  978.     ex->args[n] = makeexpr_long(0);   /* placeholder */
  979.     freeexpr(ex);
  980.     return ex2;
  981. }
  982.  
  983.  
  984.  
  985. void delsimparg(ep, n)
  986. Expr **ep;
  987. int n;
  988. {
  989.     if (n < 0 || n >= (*ep)->nargs) {
  990.         intwarning("delsimparg", "argument number out of range [161]");
  991.         return;
  992.     }
  993.     deletearg(ep, n);
  994.     switch ((*ep)->kind) {
  995.  
  996.         case EK_PLUS:
  997.         case EK_TIMES:
  998.         case EK_COMMA:
  999.             if ((*ep)->nargs == 1)
  1000.                 *ep = grabarg(*ep, 0);
  1001.             break;
  1002.  
  1003.     default:
  1004.         break;
  1005.  
  1006.     }
  1007. }
  1008.  
  1009.  
  1010.  
  1011.  
  1012. Expr *resimplify(ex)
  1013. Expr *ex;
  1014. {
  1015.     Expr *ex2;
  1016.     Type *type;
  1017.     int i;
  1018.  
  1019.     if (debug>2) { fprintf(outf,"resimplify("); dumpexpr(ex); fprintf(outf,")\n"); }
  1020.     if (!ex)
  1021.         return NULL;
  1022.     type = ex->val.type;
  1023.     switch (ex->kind) {
  1024.  
  1025.         case EK_PLUS:
  1026.             ex2 = ex->args[0];
  1027.             for (i = 1; i < ex->nargs; i++)
  1028.                 ex2 = makeexpr_plus(ex2, ex->args[i]);
  1029.             FREE(ex);
  1030.             return ex2;
  1031.  
  1032.         case EK_TIMES:
  1033.             ex2 = ex->args[0];
  1034.             for (i = 1; i < ex->nargs; i++)
  1035.                 ex2 = makeexpr_times(ex2, ex->args[i]);
  1036.             FREE(ex);
  1037.             return ex2;
  1038.  
  1039.         case EK_NEG:
  1040.             ex = makeexpr_neg(grabarg(ex, 0));
  1041.             ex->val.type = type;
  1042.             return ex;
  1043.  
  1044.         case EK_NOT:
  1045.             ex = makeexpr_not(grabarg(ex, 0));
  1046.             ex->val.type = type;
  1047.             return ex;
  1048.  
  1049.         case EK_HAT:
  1050.             ex = makeexpr_hat(grabarg(ex, 0), 0);
  1051.         if (ex->kind == EK_HAT)
  1052.         ex->val.type = type;
  1053.             return ex;
  1054.  
  1055.         case EK_ADDR:
  1056.             ex = makeexpr_addr(grabarg(ex, 0));
  1057.             ex->val.type = type;
  1058.             return ex;
  1059.  
  1060.     case EK_ASSIGN:
  1061.         ex2 = makeexpr_assign(ex->args[0], ex->args[1]);
  1062.         FREE(ex);
  1063.         return ex2;
  1064.  
  1065.     default:
  1066.         break;
  1067.     }
  1068.     return ex;
  1069. }
  1070.  
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076. int realzero(s)
  1077. register char *s;
  1078. {
  1079.     if (*s == '-') s++;
  1080.     while (*s == '0' || *s == '.') s++;
  1081.     return (!isdigit(*s));
  1082. }
  1083.  
  1084. int realint(s, i)
  1085. register char *s;
  1086. int i;
  1087. {
  1088.     if (i == 0)
  1089.     return realzero(s);
  1090.     if (*s == '-') {
  1091.     s++;
  1092.     i = -i;
  1093.     }
  1094.     if (i < 0 || i > 9) return 0;   /* we don't care about large values here */
  1095.     while (*s == '0') s++;
  1096.     if (*s++ != i + '0') return 0;
  1097.     if (*s == '.')
  1098.     while (*++s == '0') ;
  1099.     return (!isdigit(*s));
  1100. }
  1101.  
  1102.  
  1103. int checkconst(ex, val)
  1104. Expr *ex;
  1105. long val;
  1106. {
  1107.     Meaning *mp;
  1108.     Value exval;
  1109.  
  1110.     if (!ex)
  1111.         return 0;
  1112.     if (ex->kind == EK_CAST || ex->kind == EK_ACTCAST)
  1113.         ex = ex->args[0];
  1114.     if (ex->kind == EK_CONST || ex->kind == EK_LONGCONST)
  1115.         exval = ex->val;
  1116.     else if (ex->kind == EK_VAR &&
  1117.              (mp = (Meaning *)ex->val.i)->kind == MK_CONST &&
  1118.          mp->val.type &&
  1119.              foldconsts != 0)
  1120.         exval = mp->val;
  1121.     else
  1122.         return 0;
  1123.     switch (exval.type->kind) {
  1124.  
  1125.         case TK_BOOLEAN:
  1126.         case TK_INTEGER:
  1127.         case TK_CHAR:
  1128.         case TK_ENUM:
  1129.         case TK_SUBR:
  1130.         case TK_SMALLSET:
  1131.         case TK_SMALLARRAY:
  1132.             return exval.i == val;
  1133.  
  1134.         case TK_POINTER:
  1135.         case TK_STRING:
  1136.             return (val == 0 && exval.i == 0);
  1137.  
  1138.         case TK_REAL:
  1139.             return realint(exval.s, val);
  1140.  
  1141.     default:
  1142.         return 0;
  1143.     }
  1144. }
  1145.  
  1146.  
  1147.  
  1148. int isliteralconst(ex, valp)
  1149. Expr *ex;
  1150. Value *valp;
  1151. {
  1152.     Meaning *mp;
  1153.  
  1154.     if (ex) {
  1155.         switch (ex->kind) {
  1156.  
  1157.             case EK_CONST:
  1158.             case EK_LONGCONST:
  1159.                 if (valp)
  1160.                     *valp = ex->val;
  1161.                 return 2;
  1162.  
  1163.             case EK_VAR:
  1164.                 mp = (Meaning *)ex->val.i;
  1165.                 if (mp->kind == MK_CONST) {
  1166.                     if (valp) {
  1167.                         if (foldconsts == 0)
  1168.                             valp->type = NULL;
  1169.                         else
  1170.                             *valp = mp->val;
  1171.                     }
  1172.                     return 1;
  1173.                 }
  1174.                 break;
  1175.  
  1176.         default:
  1177.         break;
  1178.         }
  1179.     }
  1180.     if (valp)
  1181.         valp->type = NULL;
  1182.     return 0;
  1183. }
  1184.  
  1185.  
  1186.  
  1187. int isconstexpr(ex, valp)
  1188. Expr *ex;
  1189. long *valp;
  1190. {
  1191.     Value exval;
  1192.  
  1193.     if (debug>2) { fprintf(outf,"isconstexpr("); dumpexpr(ex); fprintf(outf,")\n"); }
  1194.     exval = eval_expr(ex);
  1195.     if (exval.type) {
  1196.         if (valp)
  1197.             *valp = exval.i;
  1198.         return 1;
  1199.     } else
  1200.         return 0;
  1201. }
  1202.  
  1203.  
  1204.  
  1205. int isconstantexpr(ex)
  1206. Expr *ex;
  1207. {
  1208.     Meaning *mp;
  1209.     int i;
  1210.  
  1211.     switch (ex->kind) {
  1212.  
  1213.         case EK_CONST:
  1214.         case EK_LONGCONST:
  1215.         case EK_SIZEOF:
  1216.             return 1;
  1217.  
  1218.         case EK_ADDR:
  1219.             if (ex->args[0]->kind == EK_VAR) {
  1220.                 mp = (Meaning *)ex->val.i;
  1221.                 return (!mp->ctx || mp->ctx->kind == MK_MODULE);
  1222.             }
  1223.             return 0;
  1224.  
  1225.         case EK_VAR:
  1226.             mp = (Meaning *)ex->val.i;
  1227.             return (mp->kind == MK_CONST);
  1228.  
  1229.         case EK_BICALL:
  1230.         case EK_FUNCTION:
  1231.             if (!deterministic_func(ex))
  1232.                 return 0;
  1233.  
  1234.         /* fall through */
  1235.         case EK_EQ:
  1236.         case EK_NE:
  1237.         case EK_LT:
  1238.         case EK_GT:
  1239.         case EK_LE:
  1240.         case EK_GE:
  1241.         case EK_PLUS:
  1242.         case EK_NEG:
  1243.         case EK_TIMES:
  1244.         case EK_DIVIDE:
  1245.         case EK_DIV:
  1246.         case EK_MOD:
  1247.         case EK_AND:
  1248.         case EK_OR:
  1249.         case EK_NOT:
  1250.         case EK_BAND:
  1251.         case EK_BOR:
  1252.         case EK_BXOR:
  1253.         case EK_BNOT:
  1254.         case EK_LSH:
  1255.         case EK_RSH:
  1256.         case EK_CAST:
  1257.         case EK_ACTCAST:
  1258.         case EK_COND:
  1259.             for (i = 0; i < ex->nargs; i++) {
  1260.                 if (!isconstantexpr(ex->args[i]))
  1261.                     return 0;
  1262.             }
  1263.             return 1;
  1264.  
  1265.         case EK_COMMA:
  1266.             return isconstantexpr(ex->args[ex->nargs-1]);
  1267.  
  1268.     default:
  1269.         return 0;
  1270.     }
  1271. }
  1272.  
  1273.  
  1274.  
  1275.  
  1276.  
  1277. Static Expr *docast(a, type)
  1278. Expr *a;
  1279. Type *type;
  1280. {
  1281.     Value val;
  1282.     Meaning *mp;
  1283.     int i;
  1284.     Expr *ex;
  1285.  
  1286.     if (a->val.type->kind == TK_SMALLSET && type->kind == TK_SET) {
  1287.         mp = makestmttempvar(type, name_SET);
  1288.         return makeexpr_bicall_2(setexpandname, type,
  1289.                                  makeexpr_var(mp),
  1290.                                  makeexpr_arglong(a, 1));
  1291.     } else if (a->val.type->kind == TK_SET && type->kind == TK_SMALLSET) {
  1292.         return packset(a, type);
  1293.     }
  1294.     switch (a->kind) {
  1295.  
  1296.         case EK_VAR:
  1297.             mp = (Meaning *) a->val.i;
  1298.             if (mp->kind == MK_CONST) {
  1299.                 if (mp->val.type && mp->val.type->kind == TK_STRING &&
  1300.             type->kind == TK_CHAR) {
  1301.                     val = value_cast(mp->val, type);
  1302.                     a->kind = EK_CONST;
  1303.                     a->val = val;
  1304.                     return a;
  1305.                 }
  1306.             }
  1307.             break;
  1308.  
  1309.         case EK_CONST:
  1310.         case EK_LONGCONST:
  1311.             val = value_cast(a->val, type);
  1312.             if (val.type) {
  1313.                 a->val = val;
  1314.                 return a;
  1315.             }
  1316.             break;
  1317.  
  1318.         case EK_PLUS:
  1319.         case EK_NEG:
  1320.         case EK_TIMES:
  1321.             if (type->kind == TK_REAL) {
  1322.                 for (i = 0; i < a->nargs; i++) {
  1323.                     ex = docast(a->args[i], type);
  1324.                     if (ex) {
  1325.                         a->args[i] = ex;
  1326.                         a->val.type = type;
  1327.                         return a;
  1328.                     }
  1329.                 }
  1330.             }
  1331.             break;
  1332.  
  1333.     default:
  1334.         break;
  1335.     }
  1336.     return NULL;
  1337. }
  1338.  
  1339.  
  1340.  
  1341. /* Make an "active" cast, i.e., one that performs an explicit operation */
  1342. Expr *makeexpr_actcast(a, type)
  1343. Expr *a;
  1344. Type *type;
  1345. {
  1346.     if (debug>2) { fprintf(outf,"makeexpr_actcast("); dumpexpr(a); fprintf(outf,", "); dumptypename(type, 1); fprintf(outf,")\n"); }
  1347.  
  1348.     if (similartypes(a->val.type, type)) {
  1349.         a->val.type = type;
  1350.         return a;
  1351.     }
  1352.     return makeexpr_un(EK_ACTCAST, type, a);
  1353. }
  1354.  
  1355.  
  1356.  
  1357. Expr *makeexpr_cast(a, type)
  1358. Expr *a;
  1359. Type *type;
  1360. {
  1361.     Expr *ex;
  1362.  
  1363.     if (debug>2) { fprintf(outf,"makeexpr_cast("); dumpexpr(a); fprintf(outf,", "); dumptypename(type, 1); fprintf(outf,")\n"); }
  1364.     if (a->val.type == type)
  1365.         return a;
  1366.     ex = docast(a, type);
  1367.     if (ex)
  1368.         return ex;
  1369.     if (a->kind == EK_CAST &&
  1370.         a->args[0]->val.type->kind == TK_POINTER &&
  1371.         similartypes(type, a->args[0]->val.type)) {
  1372.         a = grabarg(a, 0);
  1373.         a->val.type = type;
  1374.         return a;
  1375.     }
  1376.     if ((a->kind == EK_CAST &&
  1377.          ((a->val.type->kind == TK_POINTER && type->kind == TK_POINTER) ||
  1378.           (ord_type(a->val.type)->kind == TK_INTEGER && ord_type(type)->kind == TK_INTEGER))) ||
  1379.         similartypes(type, a->val.type)) {
  1380.         a->val.type = type;
  1381.         return a;
  1382.     }
  1383.     return makeexpr_un(EK_CAST, type, a);
  1384. }
  1385.  
  1386.  
  1387.  
  1388. Expr *gentle_cast(a, type)
  1389. Expr *a;
  1390. Type *type;
  1391. {
  1392.     Expr *ex;
  1393.     Type *btype;
  1394.     long smin, smax;
  1395.     Value val;
  1396.     char c;
  1397.  
  1398.     if (debug>2) { fprintf(outf,"gentle_cast("); dumpexpr(a); fprintf(outf,", "); dumptypename(type, 1); fprintf(outf,")\n"); }
  1399.     if (!type) {
  1400.     intwarning("gentle_cast", "type == NULL");
  1401.     return a;
  1402.     }
  1403.     if (a->val.type->kind == TK_POINTER && type->kind == TK_POINTER) {
  1404.         if (voidstar && (type == tp_anyptr || a->val.type == tp_anyptr)) {
  1405.             if (type == tp_anyptr && a->kind == EK_CAST &&
  1406.                 a->args[0]->val.type->kind == TK_POINTER)
  1407.                 return a->args[0];    /* remove explicit cast since casting implicitly */
  1408.             return a;                 /* casting to/from "void *" */
  1409.         }
  1410.         return makeexpr_cast(a, type);
  1411.     }
  1412.     if (type->kind == TK_STRING)
  1413.         return makeexpr_stringify(a);
  1414.     if (type->kind == TK_ARRAY &&
  1415.     (a->val.type->kind == TK_STRING ||
  1416.      a->val.type->kind == TK_CHAR) &&
  1417.         isliteralconst(a, &val) && val.type &&
  1418.     ord_range(type->indextype, &smin, &smax)) {
  1419.     smax = smax - smin + 1;
  1420.     if (a->val.type->kind == TK_CHAR) {
  1421.         val.s = &c;
  1422.         c = val.i;
  1423.         val.i = 1;
  1424.     }
  1425.     if (val.i > smax) {
  1426.         warning("Too many characters for packed array of char [162]");
  1427.     } else if (val.i < smax || a->val.type->kind == TK_CHAR) {
  1428.         ex = makeexpr_lstring(val.s, smax);
  1429.         while (smax > val.i)
  1430.         ex->val.s[--smax] = ' ';
  1431.         freeexpr(a);
  1432.         return ex;
  1433.     }
  1434.     }
  1435.     btype = (type->kind == TK_SUBR) ? type->basetype : type;
  1436.     if ((a->kind == EK_CAST || a->kind == EK_ACTCAST) &&
  1437.         btype->kind == TK_INTEGER &&
  1438.         ord_type(a->val.type)->kind == TK_INTEGER)
  1439.         return makeexpr_longcast(a, long_type(type));
  1440.     if (a->val.type == btype)
  1441.         return a;
  1442.     ex = docast(a, btype);
  1443.     if (ex)
  1444.         return ex;
  1445.     if (btype->kind == TK_CHAR && a->val.type->kind == TK_STRING)
  1446.         return makeexpr_hat(a, 0);
  1447.     return a;
  1448. }
  1449.  
  1450.  
  1451.  
  1452. Expr *makeexpr_charcast(ex)
  1453. Expr *ex;
  1454. {
  1455.     Meaning *mp;
  1456.  
  1457.     if (ex->kind == EK_CONST && ex->val.type->kind == TK_STRING &&
  1458.         ex->val.i == 1) {
  1459.         ex->val.type = tp_char;
  1460.         ex->val.i = ex->val.s[0] & 0xff;
  1461.         ex->val.s = NULL;
  1462.     }
  1463.     if (ex->kind == EK_VAR &&
  1464.     (mp = (Meaning *)ex->val.i)->kind == MK_CONST &&
  1465.     mp->val.type &&
  1466.     mp->val.type->kind == TK_STRING &&
  1467.     mp->val.i == 1) {
  1468.       ex->kind = EK_CONST;
  1469.       ex->val.type = tp_char;
  1470.       ex->val.i = mp->val.s[0] & 0xff;
  1471.       ex->val.s = NULL;
  1472.     }
  1473.     return ex;
  1474. }
  1475.  
  1476.  
  1477.  
  1478. Expr *makeexpr_stringcast(ex)
  1479. Expr *ex;
  1480. {
  1481.     char ch;
  1482.  
  1483.     if (ex->kind == EK_CONST && ord_type(ex->val.type)->kind == TK_CHAR) {
  1484.         ch = ex->val.i;
  1485.         freeexpr(ex);
  1486.         ex = makeexpr_lstring(&ch, 1);
  1487.     }
  1488.     return ex;
  1489. }
  1490.  
  1491.  
  1492.  
  1493.  
  1494.  
  1495. /* 0/1 = force to int/long, 2/3 = check if int/long */
  1496.  
  1497. Static Expr *dolongcast(a, tolong)
  1498. Expr *a;
  1499. int tolong;
  1500. {
  1501.     Meaning *mp;
  1502.     Expr *ex;
  1503.     Type *type;
  1504.     int i;
  1505.  
  1506.     switch (a->kind) {
  1507.  
  1508.         case EK_DOT:
  1509.             if (!a->val.i) {
  1510.                 if (long_type(a->val.type) == (tolong&1))
  1511.                     return a;
  1512.                 break;
  1513.             }
  1514.  
  1515.         /* fall through */
  1516.         case EK_VAR:
  1517.             mp = (Meaning *)a->val.i;
  1518.             if (mp->kind == MK_FIELD && mp->val.i) {
  1519.                 if (mp->val.i <= ((sizeof_int > 0) ? sizeof_int : 16) &&
  1520.                     !(tolong&1))
  1521.                     return a;
  1522.             } else if (mp->kind == MK_VAR ||
  1523.                        mp->kind == MK_VARREF ||
  1524.                        mp->kind == MK_PARAM ||
  1525.                        mp->kind == MK_VARPARAM ||
  1526.                        mp->kind == MK_FIELD) {
  1527.                 if (long_type(mp->type) == (tolong&1))
  1528.                     return a;
  1529.             }
  1530.             break;
  1531.  
  1532.         case EK_FUNCTION:
  1533.             mp = (Meaning *)a->val.i;
  1534.             if (long_type(mp->type->basetype) == (tolong&1))
  1535.                 return a;
  1536.             break;
  1537.  
  1538.         case EK_BICALL:
  1539.             if (!strcmp(a->val.s, signextname) && *signextname) {
  1540.                 i = 0;
  1541.                 goto unary;
  1542.             }
  1543.         if (!strcmp(a->val.s, "strlen"))
  1544.         goto size_t_case;
  1545.             /* fall through */
  1546.  
  1547.         case EK_HAT:      /* get true type from a->val.type */
  1548.         case EK_INDEX:
  1549.         case EK_SPCALL:
  1550.         case EK_NAME:
  1551.             if (long_type(a->val.type) == (tolong&1))
  1552.                 return a;
  1553.             break;
  1554.  
  1555.         case EK_ASSIGN:   /* destination determines type, */
  1556.         case EK_POSTINC:  /*  but must not be changed */
  1557.         case EK_POSTDEC:
  1558.             return dolongcast(a->args[0], tolong|2);
  1559.  
  1560.         case EK_CAST:
  1561.             if (ord_type(a->val.type)->kind == TK_INTEGER &&
  1562.                  long_type(a->val.type) == (tolong&1))
  1563.                 return a;
  1564.             if (tolong == 0) {
  1565.                 a->val.type = tp_int;
  1566.                 return a;
  1567.             } else if (tolong == 1) {
  1568.                 a->val.type = tp_integer;
  1569.                 return a;
  1570.             }
  1571.             break;
  1572.  
  1573.         case EK_ACTCAST:
  1574.             if (ord_type(a->val.type)->kind == TK_INTEGER &&
  1575.                  long_type(a->val.type) == (tolong&1))
  1576.                 return a;
  1577.             break;
  1578.  
  1579.         case EK_CONST:
  1580.             type = ord_type(a->val.type);
  1581.             if (type->kind == TK_INTEGER || type->kind == TK_SMALLSET) {
  1582.                 if (tolong == 1)
  1583.                     a->kind = EK_LONGCONST;
  1584.                 if (tolong != 3)
  1585.                     return a;
  1586.             }
  1587.             break;
  1588.  
  1589.         case EK_LONGCONST:
  1590.             if (tolong == 0) {
  1591.                 if (a->val.i >= -32767 && a->val.i <= 32767)
  1592.                     a->kind = EK_CONST;
  1593.                 else
  1594.                     return NULL;
  1595.             }
  1596.             if (tolong != 2)
  1597.                 return a;
  1598.             break;
  1599.  
  1600.         case EK_SIZEOF:
  1601.     size_t_case:
  1602.             if (size_t_long > 0 && tolong&1)
  1603.                 return a;
  1604.             if (size_t_long == 0 && !(tolong&1))
  1605.                 return a;
  1606.             break;
  1607.  
  1608.         case EK_PLUS:     /* usual arithmetic conversions apply */
  1609.         case EK_TIMES:
  1610.         case EK_DIV:
  1611.         case EK_MOD:
  1612.         case EK_BAND:
  1613.         case EK_BOR:
  1614.         case EK_BXOR:
  1615.         case EK_COND:
  1616.             i = (a->kind == EK_COND) ? 1 : 0;
  1617.             if (tolong&1) {
  1618.                 for (; i < a->nargs; i++) {
  1619.                     ex = dolongcast(a->args[i], tolong);
  1620.                     if (ex) {
  1621.                         a->args[i] = ex;
  1622.                         return a;
  1623.                     }
  1624.                 }
  1625.             } else {
  1626.                 for (; i < a->nargs; i++) {
  1627.                     if (!dolongcast(a->args[i], tolong))
  1628.                         return NULL;
  1629.                 }
  1630.                 return a;
  1631.             }
  1632.             break;
  1633.  
  1634.         case EK_BNOT:     /* single argument defines result type */
  1635.         case EK_NEG:
  1636.         case EK_LSH:
  1637.         case EK_RSH:
  1638.         case EK_COMMA:
  1639.             i = (a->kind == EK_COMMA) ? a->nargs-1 : 0;
  1640. unary:
  1641.             if (tolong&1) {
  1642.                 ex = dolongcast(a->args[i], tolong);
  1643.                 if (ex) {
  1644.                     a->args[i] = ex;
  1645.                     return a;
  1646.                 }
  1647.             } else {
  1648.                 if (dolongcast(a->args[i], tolong))
  1649.                     return a;
  1650.             }
  1651.             break;
  1652.  
  1653.         case EK_AND:  /* operators which always return int */
  1654.         case EK_OR:
  1655.         case EK_EQ:
  1656.         case EK_NE:
  1657.         case EK_LT:
  1658.         case EK_GT:
  1659.         case EK_LE:
  1660.         case EK_GE:
  1661.             if (tolong&1)
  1662.                 break;
  1663.             return a;
  1664.  
  1665.     default:
  1666.         break;
  1667.     }
  1668.     return NULL;
  1669. }
  1670.  
  1671.  
  1672. /* Return -1 if short int or plain int, 1 if long, 0 if can't tell */
  1673. int exprlongness(ex)
  1674. Expr *ex;
  1675. {
  1676.     if (sizeof_int >= 32)
  1677.         return -1;
  1678.     return (dolongcast(ex, 3) != NULL) -
  1679.            (dolongcast(ex, 2) != NULL);
  1680. }
  1681.  
  1682.  
  1683. Expr *makeexpr_longcast(a, tolong)
  1684. Expr *a;
  1685. int tolong;
  1686. {
  1687.     Expr *ex;
  1688.     Type *type;
  1689.  
  1690.     if (sizeof_int >= 32)
  1691.         return a;
  1692.     type = ord_type(a->val.type);
  1693.     if (type->kind != TK_INTEGER && type->kind != TK_SMALLSET)
  1694.         return a;
  1695.     a = makeexpr_unlongcast(a);
  1696.     if (tolong) {
  1697.         ex = dolongcast(a, 1);
  1698.     } else {
  1699.         ex = dolongcast(copyexpr(a), 0);
  1700.         if (ex) {
  1701.             if (!dolongcast(ex, 2)) {
  1702.                 freeexpr(ex);
  1703.                 ex = NULL;
  1704.             }
  1705.         }
  1706.     }
  1707.     if (ex)
  1708.         return ex;
  1709.     return makeexpr_un(EK_CAST, (tolong) ? tp_integer : tp_int, a);
  1710. }
  1711.  
  1712.  
  1713. Expr *makeexpr_arglong(a, tolong)
  1714. Expr *a;
  1715. int tolong;
  1716. {
  1717.     int cast = castlongargs;
  1718.     if (cast < 0)
  1719.     cast = castargs;
  1720.     if (cast > 0 || (cast < 0 && prototypes == 0)) {
  1721.     return makeexpr_longcast(a, tolong);
  1722.     }
  1723.     return a;
  1724. }
  1725.  
  1726.  
  1727.  
  1728. Expr *makeexpr_unlongcast(a)
  1729. Expr *a;
  1730. {
  1731.     switch (a->kind) {
  1732.  
  1733.         case EK_LONGCONST:
  1734.             if (a->val.i >= -32767 && a->val.i <= 32767)
  1735.                 a->kind = EK_CONST;
  1736.             break;
  1737.  
  1738.         case EK_CAST:
  1739.             if ((a->val.type == tp_integer ||
  1740.                  a->val.type == tp_int) &&
  1741.                 ord_type(a->args[0]->val.type)->kind == TK_INTEGER) {
  1742.                 a = grabarg(a, 0);
  1743.             }
  1744.             break;
  1745.  
  1746.         default:
  1747.         break;
  1748.  
  1749.     }
  1750.     return a;
  1751. }
  1752.  
  1753.  
  1754.  
  1755. Expr *makeexpr_forcelongness(a)    /* force a to have a definite longness */
  1756. Expr *a;
  1757. {
  1758.     Expr *ex;
  1759.  
  1760.     ex = makeexpr_unlongcast(copyexpr(a));
  1761.     if (exprlongness(ex)) {
  1762.         freeexpr(a);
  1763.         return ex;
  1764.     }
  1765.     freeexpr(ex);
  1766.     if (exprlongness(a) == 0)
  1767.         return makeexpr_longcast(a, 1);
  1768.     else
  1769.         return a;
  1770. }
  1771.  
  1772.  
  1773.  
  1774. Expr *makeexpr_ord(ex)
  1775. Expr *ex;
  1776. {
  1777.     ex = makeexpr_charcast(ex);
  1778.     switch (ord_type(ex->val.type)->kind) {
  1779.  
  1780.         case TK_ENUM:
  1781.             return makeexpr_cast(ex, tp_int);
  1782.  
  1783.         case TK_CHAR:
  1784.             if (ex->kind == EK_CONST &&
  1785.                 (ex->val.i >= 32 && ex->val.i < 127)) {
  1786.                 insertarg(&ex, 0, makeexpr_name("'%lc'", tp_integer));
  1787.             }
  1788.             ex->val.type = tp_int;
  1789.             return ex;
  1790.  
  1791.         case TK_BOOLEAN:
  1792.             ex->val.type = tp_int;
  1793.             return ex;
  1794.  
  1795.         case TK_POINTER:
  1796.             return makeexpr_cast(ex, tp_integer);
  1797.  
  1798.         default:
  1799.             return ex;
  1800.     }
  1801. }
  1802.  
  1803.  
  1804.  
  1805.  
  1806. /* Tell whether an expression "looks" negative */
  1807. int expr_looks_neg(ex)
  1808. Expr *ex;
  1809. {
  1810.     int i;
  1811.  
  1812.     switch (ex->kind) {
  1813.  
  1814.         case EK_NEG:
  1815.             return 1;
  1816.  
  1817.         case EK_CONST:
  1818.         case EK_LONGCONST:
  1819.             switch (ord_type(ex->val.type)->kind) {
  1820.                 case TK_INTEGER:
  1821.                 case TK_CHAR:
  1822.                     return (ex->val.i < 0);
  1823.                 case TK_REAL:
  1824.                     return (ex->val.s && ex->val.s[0] == '-');
  1825.                 default:
  1826.                     return 0;
  1827.             }
  1828.  
  1829.         case EK_TIMES:
  1830.         case EK_DIVIDE:
  1831.             for (i = 0; i < ex->nargs; i++) {
  1832.                 if (expr_looks_neg(ex->args[i]))
  1833.                     return 1;
  1834.             }
  1835.             return 0;
  1836.  
  1837.         case EK_CAST:
  1838.             return expr_looks_neg(ex->args[0]);
  1839.  
  1840.         default:
  1841.             return 0;
  1842.     }
  1843. }
  1844.  
  1845.  
  1846.  
  1847. /* Tell whether an expression is probably negative */
  1848. int expr_is_neg(ex)
  1849. Expr *ex;
  1850. {
  1851.     int i;
  1852.  
  1853.     i = possiblesigns(ex) & (1|4);
  1854.     if (i == 1)
  1855.     return 1;    /* if expression really is negative! */
  1856.     if (i == 4)
  1857.     return 0;    /* if expression is definitely positive. */
  1858.     return expr_looks_neg(ex);
  1859. }
  1860.  
  1861.  
  1862.  
  1863. int expr_neg_cost(a)
  1864. Expr *a;
  1865. {
  1866.     int i, c;
  1867.  
  1868.     switch (a->kind) {
  1869.  
  1870.         case EK_CONST:
  1871.         case EK_LONGCONST:
  1872.             switch (ord_type(a->val.type)->kind) {
  1873.                 case TK_INTEGER:
  1874.                 case TK_CHAR:
  1875.                 case TK_REAL:
  1876.                     return 0;
  1877.         default:
  1878.             return 1;
  1879.             }
  1880.  
  1881.         case EK_NEG:
  1882.             return -1;
  1883.  
  1884.         case EK_TIMES:
  1885.         case EK_DIVIDE:
  1886.             for (i = 0; i < a->nargs; i++) {
  1887.                 c = expr_neg_cost(a->args[i]);
  1888.                 if (c <= 0)
  1889.                     return c;
  1890.             }
  1891.             return 1;
  1892.  
  1893.         case EK_PLUS:
  1894.             for (i = 0; i < a->nargs; i++) {
  1895.                 if (expr_looks_neg(a->args[i]))
  1896.                     return 0;
  1897.             }
  1898.             return 1;
  1899.  
  1900.         default:
  1901.             return 1;
  1902.     }
  1903. }
  1904.  
  1905.  
  1906.  
  1907. Expr *enum_to_int(a)
  1908. Expr *a;
  1909. {
  1910.     if (ord_type(a->val.type)->kind == TK_ENUM) {
  1911.         if (a->kind == EK_CAST &&
  1912.              ord_type(a->args[0]->val.type)->kind == TK_INTEGER)
  1913.             return grabarg(a, 0);
  1914.         else
  1915.             return makeexpr_cast(a, tp_integer);
  1916.     } else
  1917.         return a;
  1918. }
  1919.  
  1920.  
  1921.  
  1922. Expr *neg_inside_sum(a)
  1923. Expr *a;
  1924. {
  1925.     int i;
  1926.  
  1927.     for (i = 0; i < a->nargs; i++)
  1928.         a->args[i] = makeexpr_neg(a->args[i]);
  1929.     return a;
  1930. }
  1931.  
  1932.  
  1933.  
  1934. Expr *makeexpr_neg(a)
  1935. Expr *a;
  1936. {
  1937.     int i;
  1938.  
  1939.     if (debug>2) { fprintf(outf,"makeexpr_neg("); dumpexpr(a); fprintf(outf,")\n"); }
  1940.     a = enum_to_int(a);
  1941.     switch (a->kind) {
  1942.  
  1943.         case EK_CONST:
  1944.         case EK_LONGCONST:
  1945.             switch (ord_type(a->val.type)->kind) {
  1946.  
  1947.                 case TK_INTEGER:
  1948.                 case TK_CHAR:
  1949.                     if (a->val.i == MININT)
  1950.                         valrange();
  1951.                     else
  1952.                         a->val.i = - a->val.i;
  1953.                     return a;
  1954.  
  1955.                 case TK_REAL:
  1956.                     if (!realzero(a->val.s)) {
  1957.                         if (a->val.s[0] == '-')
  1958.                             strchange(&a->val.s, a->val.s+1);
  1959.                         else
  1960.                             strchange(&a->val.s, format_s("-%s", a->val.s));
  1961.                     }
  1962.                     return a;
  1963.  
  1964.         default:
  1965.             break;
  1966.             }
  1967.             break;
  1968.  
  1969.         case EK_PLUS:
  1970.             if (expr_neg_cost(a) <= 0)
  1971.                 return neg_inside_sum(a);
  1972.             break;
  1973.  
  1974.         case EK_TIMES:
  1975.         case EK_DIVIDE:
  1976.             for (i = 0; i < a->nargs; i++) {
  1977.                 if (expr_neg_cost(a->args[i]) <= 0) {
  1978.                     a->args[i] = makeexpr_neg(a->args[i]);
  1979.                     return a;
  1980.                 }
  1981.             }
  1982.             break;
  1983.  
  1984.         case EK_CAST:
  1985.             if (a->val.type != tp_unsigned &&
  1986.                  a->val.type != tp_uint &&
  1987.                  a->val.type != tp_ushort &&
  1988.                  a->val.type != tp_ubyte &&
  1989.                  a->args[0]->val.type != tp_unsigned &&
  1990.                  a->args[0]->val.type != tp_uint &&
  1991.                  a->args[0]->val.type != tp_ushort &&
  1992.                  a->args[0]->val.type != tp_ubyte &&
  1993.                  expr_looks_neg(a->args[0])) {
  1994.                 a->args[0] = makeexpr_neg(a->args[0]);
  1995.                 return a;
  1996.             }
  1997.             break;
  1998.  
  1999.         case EK_NEG:
  2000.             return grabarg(a, 0);
  2001.  
  2002.     default:
  2003.         break;
  2004.     }
  2005.     return makeexpr_un(EK_NEG, promote_type(a->val.type), a);
  2006. }
  2007.  
  2008.  
  2009.  
  2010.  
  2011. #define ISCONST(kind) ((kind)==EK_CONST || (kind)==EK_LONGCONST)
  2012. #define MOVCONST(ex) (ISCONST((ex)->kind) && (ex)->val.type->kind != TK_STRING)
  2013. #define COMMUTATIVE (kind != EK_COMMA && type->kind != TK_REAL)
  2014.  
  2015. Type *true_type(ex)
  2016. Expr *ex;
  2017. {
  2018.     Meaning *mp;
  2019.     Type *type, *tp;
  2020.  
  2021.     while (ex->kind == EK_CAST)
  2022.     ex = ex->args[0];
  2023.     type = ex->val.type;
  2024.     if (ex->kind == EK_VAR || ex->kind == EK_FUNCTION || ex->kind == EK_DOT) {
  2025.     mp = (Meaning *)ex->val.i;
  2026.     if (mp && mp->type && mp->type->kind != TK_VOID)
  2027.         type = mp->type;
  2028.     }
  2029.     if (ex->kind == EK_INDEX) {
  2030.     tp = true_type(ex->args[0]);
  2031.     if ((tp->kind == TK_ARRAY || tp->kind == TK_SMALLARRAY ||
  2032.          tp->kind == TK_STRING) &&
  2033.         tp->basetype && tp->basetype->kind != TK_VOID)
  2034.         type = tp->basetype;
  2035.     }
  2036.     if (type->kind == TK_SUBR)
  2037.     type = findbasetype(type, ODECL_NOPRES);
  2038.     return type;
  2039. }
  2040.  
  2041. int ischartype(ex)
  2042. Expr *ex;
  2043. {
  2044.     if (ord_type(ex->val.type)->kind == TK_CHAR)
  2045.     return 1;
  2046.     if (true_type(ex)->kind == TK_CHAR)
  2047.     return 1;
  2048.     if (ISCONST(ex->kind) && ex->nargs > 0 &&
  2049.     ex->args[0]->kind == EK_NAME &&
  2050.     ex->args[0]->val.s[0] == '\'')
  2051.     return 1;
  2052.     return 0;
  2053. }
  2054.  
  2055. Static Expr *commute(a, b, kind)
  2056. Expr *a, *b;
  2057. enum exprkind kind;
  2058. {
  2059.     int i, di;
  2060.     Type *type;
  2061.  
  2062.     if (debug>2) { fprintf(outf,"commute("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  2063. #if 1
  2064.     type = promote_type_bin(a->val.type, b->val.type);
  2065. #else
  2066.     type = a->val.type;
  2067.     if (b->val.type->kind == TK_REAL)
  2068.         type = b->val.type;
  2069. #endif
  2070.     if (MOVCONST(a) && !MOVCONST(b) && COMMUTATIVE)
  2071.         swapexprs(a, b);                /* put constant last */
  2072.     if (a->kind == kind) {
  2073.         di = (MOVCONST(a->args[a->nargs-1]) && COMMUTATIVE) ? -1 : 0;
  2074.         if (b->kind == kind) {
  2075.             for (i = 0; i < b->nargs; i++)
  2076.                 insertarg(&a, a->nargs + di, b->args[i]);
  2077.             FREE(b);
  2078.         } else
  2079.             insertarg(&a, a->nargs + di, b);
  2080.         a->val.type = type;
  2081.     } else if (b->kind == kind) {
  2082.         if (MOVCONST(a) && COMMUTATIVE)
  2083.             insertarg(&b, b->nargs, a);
  2084.         else
  2085.             insertarg(&b, 0, a);
  2086.         a = b;
  2087.         a->val.type = type;
  2088.     } else {
  2089.         a = makeexpr_bin(kind, type, a, b);
  2090.     }
  2091.     if (debug>2) { fprintf(outf,"commute returns "); dumpexpr(a); fprintf(outf,"\n"); }
  2092.     return a;
  2093. }
  2094.  
  2095.  
  2096. Expr *makeexpr_plus(a, b)
  2097. Expr *a, *b;
  2098. {
  2099.     int i, j, k, castdouble = 0;
  2100.     Type *type;
  2101.  
  2102.     if (debug>2) { fprintf(outf,"makeexpr_plus("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  2103.     if (!a)
  2104.         return b;
  2105.     if (!b)
  2106.         return a;
  2107.     if (a->kind == EK_NEG && a->args[0]->kind == EK_PLUS)
  2108.         a = neg_inside_sum(grabarg(a, 0));
  2109.     if (b->kind == EK_NEG && b->args[0]->kind == EK_PLUS)
  2110.         b = neg_inside_sum(grabarg(b, 0));
  2111.     a = commute(enum_to_int(a), enum_to_int(b), EK_PLUS);
  2112.     type = NULL;
  2113.     for (i = 0; i < a->nargs; i++) {
  2114.         if (ord_type(a->args[i]->val.type)->kind == TK_CHAR ||
  2115.             a->args[i]->val.type->kind == TK_POINTER ||
  2116.             a->args[i]->val.type->kind == TK_STRING) {   /* for string literals */
  2117.             if (type == ord_type(a->args[i]->val.type))
  2118.                 type = tp_integer;   /* 'z'-'a' and p1-p2 are integers */
  2119.             else
  2120.                 type = ord_type(a->args[i]->val.type);
  2121.         }
  2122.     }
  2123.     if (type)
  2124.         a->val.type = type;
  2125.     for (i = 0; i < a->nargs && !ISCONST(a->args[i]->kind); i++) ;
  2126.     if (i < a->nargs-1) {
  2127.         for (j = i+1; j < a->nargs; j++) {
  2128.             if (ISCONST(a->args[j]->kind)) {
  2129.                 if ((ord_type(a->args[i]->val.type) == ord_type(a->args[j]->val.type) ||
  2130.              ord_type(a->args[i]->val.type)->kind == TK_INTEGER ||
  2131.              ord_type(a->args[j]->val.type)->kind == TK_INTEGER) &&
  2132.             (!(ischartype(a->args[i]) || ischartype(a->args[j])) ||
  2133.              a->args[i]->val.i == - a->args[j]->val.i ||
  2134.              a->args[i]->val.i == 0 || a->args[j]->val.i == 0) &&
  2135.                     (a->args[i]->val.type->kind != TK_REAL &&
  2136.                      a->args[i]->val.type->kind != TK_STRING &&
  2137.                      a->args[j]->val.type->kind != TK_REAL &&
  2138.                      a->args[j]->val.type->kind != TK_STRING)) {
  2139.                     a->args[i]->val.i += a->args[j]->val.i;
  2140.                     delfreearg(&a, j);
  2141.                     j--;
  2142.                 } else if (a->args[i]->val.type->kind == TK_STRING &&
  2143.                            ord_type(a->args[j]->val.type)->kind == TK_INTEGER &&
  2144.                            a->args[j]->val.i < 0 &&
  2145.                            a->args[j]->val.i >= -stringleaders) {
  2146.                     /* strictly speaking, the following is illegal pointer arithmetic */
  2147.                     a->args[i] = makeexpr_lstring(a->args[i]->val.s + a->args[j]->val.i,
  2148.                                                   a->args[i]->val.i - a->args[j]->val.i);
  2149.                     for (k = 0; k < - a->args[j]->val.i; k++)
  2150.                         a->args[i]->val.s[k] = '>';
  2151.                     delfreearg(&a, j);
  2152.                     j--;
  2153.                 }
  2154.             }
  2155.         }
  2156.     }
  2157.     if (checkconst(a->args[a->nargs-1], 0)) {
  2158.     if (a->args[a->nargs-1]->val.type->kind == TK_REAL &&
  2159.         a->args[0]->val.type->kind != TK_REAL)
  2160.         castdouble = 1;
  2161.         delfreearg(&a, a->nargs-1);
  2162.     }
  2163.     for (i = 0; i < a->nargs; i++) {
  2164.         if (a->args[i]->kind == EK_NEG && nosideeffects(a->args[i], 1)) {
  2165.             for (j = 0; j < a->nargs; j++) {
  2166.                 if (exprsame(a->args[j], a->args[i]->args[0], 1)) {
  2167.                     delfreearg(&a, i);
  2168.                     if (i < j) j--; else i--;
  2169.                     delfreearg(&a, j);
  2170.                     i--;
  2171.                     break;
  2172.                 }
  2173.             }
  2174.         }
  2175.     }
  2176.     if (a->nargs == 0) {
  2177.     type = a->val.type;
  2178.     FREE(a);
  2179.     a = gentle_cast(makeexpr_long(0), type);
  2180.     a->val.type = type;
  2181.     return a;
  2182.     } else if (a->nargs == 1) {
  2183.     b = a->args[0];
  2184.     FREE(a);
  2185.     a = b;
  2186.     } else {
  2187.     if (a->nargs == 2 && ISCONST(a->args[1]->kind) &&
  2188.         a->args[1]->val.i <= -127 &&
  2189.         true_type(a->args[0]) == tp_char && signedchars != 0) {
  2190.         a->args[0] = force_unsigned(a->args[0]);
  2191.     }
  2192.     if (a->nargs > 2 &&
  2193.         ISCONST(a->args[a->nargs-1]->kind) &&
  2194.         ISCONST(a->args[a->nargs-2]->kind) &&
  2195.         ischartype(a->args[a->nargs-1]) &&
  2196.         ischartype(a->args[a->nargs-2])) {
  2197.         i = a->args[a->nargs-1]->val.i;
  2198.         j = a->args[a->nargs-2]->val.i;
  2199.         if ((i == 'a' || i == 'A' || i == -'a' || i == -'A') &&
  2200.         (j == 'a' || j == 'A' || j == -'a' || j == -'A')) {
  2201.         if (abs(i+j) == 32) {
  2202.             delfreearg(&a, a->nargs-1);
  2203.             delsimpfreearg(&a, a->nargs-1);
  2204.             a = makeexpr_bicall_1((i+j > 0) ? "_tolower" : "_toupper",
  2205.                       tp_char, a);
  2206.         }
  2207.         }
  2208.     }
  2209.     }
  2210.     if (castdouble)
  2211.     a = makeexpr_cast(a, tp_real);
  2212.     return a;
  2213. }
  2214.  
  2215.  
  2216. Expr *makeexpr_minus(a, b)
  2217. Expr *a, *b;
  2218. {
  2219.     int okneg;
  2220.  
  2221.     if (debug>2) { fprintf(outf,"makeexpr_minus("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  2222.     if (ISCONST(b->kind) && b->val.i == 0 &&       /* kludge for array indexing */
  2223.         ord_type(b->val.type)->kind == TK_ENUM) {
  2224.         b->val.type = tp_integer;
  2225.     }
  2226.     okneg = (a->kind != EK_PLUS && b->kind != EK_PLUS);
  2227.     a = makeexpr_plus(a, makeexpr_neg(b));
  2228.     if (okneg && a->kind == EK_PLUS)
  2229.         a->val.i = 1;   /* this flag says to write as "a-b" if possible */
  2230.     return a;
  2231. }
  2232.  
  2233.  
  2234. Expr *makeexpr_inc(a, b)
  2235. Expr *a, *b;
  2236. {
  2237.     Type *type;
  2238.  
  2239.     type = a->val.type;
  2240.     a = makeexpr_plus(makeexpr_charcast(a), b);
  2241.     if (ord_type(type)->kind != TK_INTEGER &&
  2242.     ord_type(type)->kind != TK_CHAR)
  2243.     a = makeexpr_cast(a, type);
  2244.     return a;
  2245. }
  2246.  
  2247.  
  2248.  
  2249. /* Apply the distributive law for a sum of products */
  2250. Expr *distribute_plus(ex)
  2251. Expr *ex;
  2252. {
  2253.     int i, j, icom;
  2254.     Expr *common, *outer, *ex2, **exp;
  2255.  
  2256.     if (debug>2) { fprintf(outf,"distribute_plus("); dumpexpr(ex); fprintf(outf,")\n"); }
  2257.     if (ex->kind != EK_PLUS)
  2258.         return ex;
  2259.     for (i = 0; i < ex->nargs; i++)
  2260.         if (ex->args[i]->kind == EK_TIMES)
  2261.             break;
  2262.     if (i == ex->nargs)
  2263.         return ex;
  2264.     outer = NULL;
  2265.     icom = 0;
  2266.     for (;;) {
  2267.     ex2 = ex->args[0];
  2268.     if (ex2->kind == EK_NEG)
  2269.         ex2 = ex2->args[0];
  2270.         if (ex2->kind == EK_TIMES) {
  2271.         if (icom >= ex2->nargs)
  2272.         break;
  2273.             common = ex2->args[icom];
  2274.         if (common->kind == EK_NEG)
  2275.         common = common->args[0];
  2276.         } else {
  2277.         if (icom > 0)
  2278.         break;
  2279.             common = ex2;
  2280.         icom++;
  2281.     }
  2282.         for (i = 1; i < ex->nargs; i++) {
  2283.         ex2 = ex->args[i];
  2284.         if (ex2->kind == EK_NEG)
  2285.         ex2 = ex2->args[i];
  2286.             if (ex2->kind == EK_TIMES) {
  2287.                 for (j = ex2->nargs; --j >= 0; ) {
  2288.                     if (exprsame(ex2->args[j], common, 1) ||
  2289.             (ex2->args[j]->kind == EK_NEG &&
  2290.              exprsame(ex2->args[j]->args[0], common, 1)))
  2291.                         break;
  2292.                 }
  2293.                 if (j < 0)
  2294.                     break;
  2295.             } else {
  2296.                 if (!exprsame(ex2, common, 1))
  2297.                     break;
  2298.             }
  2299.         }
  2300.         if (i == ex->nargs) {
  2301.             if (debug>2) { fprintf(outf,"distribute_plus does "); dumpexpr(common); fprintf(outf,"\n"); }
  2302.         common = copyexpr(common);
  2303.             for (i = 0; i < ex->nargs; i++) {
  2304.         if (ex->args[i]->kind == EK_NEG)
  2305.             ex2 = *(exp = &ex->args[i]->args[0]);
  2306.         else
  2307.             ex2 = *(exp = &ex->args[i]);
  2308.         if (ex2->kind == EK_TIMES) {
  2309.                     for (j = ex2->nargs; --j >= 0; ) {
  2310.                         if (exprsame(ex2->args[j], common, 1)) {
  2311.                             delsimpfreearg(exp, j);
  2312.                             break;
  2313.                         } else if (ex2->args[j]->kind == EK_NEG &&
  2314.                    exprsame(ex2->args[j]->args[0], common,1)) {
  2315.                 freeexpr(ex2->args[j]);
  2316.                 ex2->args[j] = makeexpr_long(-1);
  2317.                 break;
  2318.             }
  2319.                     }
  2320.         } else {
  2321.             freeexpr(ex2);
  2322.             *exp = makeexpr_long(1);
  2323.                 }
  2324.         ex->args[i] = resimplify(ex->args[i]);
  2325.             }
  2326.             outer = makeexpr_times(common, outer);
  2327.         } else
  2328.         icom++;
  2329.     }
  2330.     return makeexpr_times(resimplify(ex), outer);
  2331. }
  2332.  
  2333.  
  2334.  
  2335.  
  2336.  
  2337. Expr *makeexpr_times(a, b)
  2338. Expr *a, *b;
  2339. {
  2340.     int i, n, castdouble = 0;
  2341.     Type *type;
  2342.  
  2343.     if (debug>2) { fprintf(outf,"makeexpr_times("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  2344.     if (!a)
  2345.         return b;
  2346.     if (!b)
  2347.         return a;
  2348.     a = commute(a, b, EK_TIMES);
  2349.     if (a->val.type->kind == TK_INTEGER) {
  2350.         i = a->nargs-1;
  2351.         if (i > 0 && ISCONST(a->args[i-1]->kind)) {
  2352.             a->args[i-1]->val.i *= a->args[i]->val.i;
  2353.             delfreearg(&a, i);
  2354.         }
  2355.     }
  2356.     for (i = n = 0; i < a->nargs; i++) {
  2357.         if (expr_neg_cost(a->args[i]) < 0)
  2358.             n++;
  2359.     }
  2360.     if (n & 1) {
  2361.         for (i = 0; i < a->nargs; i++) {
  2362.             if (ISCONST(a->args[i]->kind) &&
  2363.                 expr_neg_cost(a->args[i]) >= 0) {
  2364.                 a->args[i] = makeexpr_neg(a->args[i]);
  2365.                 n++;
  2366.                 break;
  2367.             }
  2368.         }
  2369.     } else
  2370.         n++;
  2371.     for (i = 0; i < a->nargs && n >= 2; i++) {
  2372.         if (expr_neg_cost(a->args[i]) < 0) {
  2373.             a->args[i] = makeexpr_neg(a->args[i]);
  2374.             n--;
  2375.         }
  2376.     }
  2377.     if (checkconst(a->args[a->nargs-1], 1)) {
  2378.     if (a->args[a->nargs-1]->val.type->kind == TK_REAL &&
  2379.         a->args[0]->val.type->kind != TK_REAL)
  2380.         castdouble = 1;
  2381.         delfreearg(&a, a->nargs-1);
  2382.     } else if (checkconst(a->args[a->nargs-1], -1)) {
  2383.     if (a->args[a->nargs-1]->val.type->kind == TK_REAL &&
  2384.         a->args[0]->val.type->kind != TK_REAL)
  2385.         castdouble = 1;
  2386.         delfreearg(&a, a->nargs-1);
  2387.     a->args[0] = makeexpr_neg(a->args[0]);
  2388.     } else if (checkconst(a->args[a->nargs-1], 0) && nosideeffects(a, 1)) {
  2389.     if (a->args[a->nargs-1]->val.type->kind == TK_REAL)
  2390.         type = a->args[a->nargs-1]->val.type;
  2391.     else
  2392.         type = a->val.type;
  2393.         return makeexpr_cast(grabarg(a, a->nargs-1), type);
  2394.     }
  2395.     if (a->nargs < 2) {
  2396.         if (a->nargs < 1) {
  2397.             FREE(a);
  2398.             a = makeexpr_long(1);
  2399.         } else {
  2400.             b = a->args[0];
  2401.             FREE(a);
  2402.             a = b;
  2403.         }
  2404.     }
  2405.     if (castdouble)
  2406.     a = makeexpr_cast(a, tp_real);
  2407.     return a;
  2408. }
  2409.  
  2410.  
  2411.  
  2412. Expr *makeexpr_sqr(ex, cube)
  2413. Expr *ex;
  2414. int cube;
  2415. {
  2416.     Expr *ex2;
  2417.     Meaning *tvar;
  2418.     Type *type;
  2419.  
  2420.     if (exprspeed(ex) <= 2 && nosideeffects(ex, 0)) {
  2421.     ex2 = NULL;
  2422.     } else {
  2423.     type = (ex->val.type->kind == TK_REAL) ? tp_longreal : tp_integer;
  2424.     tvar = makestmttempvar(type, name_TEMP);
  2425.     ex2 = makeexpr_assign(makeexpr_var(tvar), ex);
  2426.     ex = makeexpr_var(tvar);
  2427.     }
  2428.     if (cube)
  2429.     ex = makeexpr_times(ex, makeexpr_times(copyexpr(ex), copyexpr(ex)));
  2430.     else
  2431.     ex = makeexpr_times(ex, copyexpr(ex));
  2432.     return makeexpr_comma(ex2, ex);
  2433. }
  2434.  
  2435.  
  2436.  
  2437. Expr *makeexpr_divide(a, b)
  2438. Expr *a, *b;
  2439. {
  2440.     Expr *ex;
  2441.     int p;
  2442.  
  2443.     if (debug>2) { fprintf(outf,"makeexpr_divide("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  2444.     if (a->val.type->kind != TK_REAL &&
  2445.     b->val.type->kind != TK_REAL) {     /* must do a real division */
  2446.         ex = docast(a, tp_longreal);
  2447.         if (ex)
  2448.             a = ex;
  2449.         else {
  2450.             ex = docast(b, tp_longreal);
  2451.             if (ex)
  2452.                 b = ex;
  2453.             else
  2454.                 a = makeexpr_cast(a, tp_longreal);
  2455.         }
  2456.     }
  2457.     if (a->kind == EK_TIMES) {
  2458.     for (p = 0; p < a->nargs; p++)
  2459.         if (exprsame(a->args[p], b, 1))
  2460.         break;
  2461.     if (p < a->nargs) {
  2462.         delfreearg(&a, p);
  2463.         freeexpr(b);
  2464.         if (a->nargs == 1)
  2465.         return grabarg(a, 0);
  2466.         else
  2467.         return a;
  2468.     }
  2469.     }
  2470.     if (expr_neg_cost(a) < 0 && expr_neg_cost(b) < 0) {
  2471.         a = makeexpr_neg(a);
  2472.         b = makeexpr_neg(b);
  2473.     }
  2474.     if (checkconst(b, 0))
  2475.         warning("Division by zero [163]");
  2476.     return makeexpr_bin(EK_DIVIDE, tp_longreal, a, b);
  2477. }
  2478.  
  2479.  
  2480.  
  2481.  
  2482. int gcd(a, b)
  2483. int a, b;
  2484. {
  2485.     if (a < 0) a = -a;
  2486.     if (b < 0) b = -b;
  2487.     while (a != 0) {
  2488.     b %= a;
  2489.     if (b != 0)
  2490.         a %= b;
  2491.     else
  2492.         return a;
  2493.     }
  2494.     return b;
  2495. }
  2496.  
  2497.  
  2498.  
  2499. /* possible signs of ex: 1=may be neg, 2=may be zero, 4=may be pos */
  2500.  
  2501. int negsigns(mask)
  2502. int mask;
  2503. {
  2504.     return (mask & 2) |
  2505.        ((mask & 1) << 2) |
  2506.        ((mask & 4) >> 2);
  2507. }
  2508.  
  2509.  
  2510. int possiblesigns(ex)
  2511. Expr *ex;
  2512. {
  2513.     Value val;
  2514.     Type *tp;
  2515.     char *cp;
  2516.     int i, mask, mask2;
  2517.  
  2518.     if (isliteralconst(ex, &val) && val.type) {
  2519.     if (val.type == tp_real || val.type == tp_longreal) {
  2520.         if (realzero(val.s))
  2521.         return 2;
  2522.         if (*val.s == '-')
  2523.         return 1;
  2524.         return 4;
  2525.     } else
  2526.         return (val.i < 0) ? 1 : (val.i == 0) ? 2 : 4;
  2527.     }
  2528.     if (ex->kind == EK_CAST &&
  2529.     similartypes(ex->val.type, ex->args[0]->val.type))
  2530.     return possiblesigns(ex->args[0]);
  2531.     if (ex->kind == EK_NEG)
  2532.     return negsigns(possiblesigns(ex->args[0]));
  2533.     if (ex->kind == EK_TIMES || ex->kind == EK_DIVIDE) {
  2534.     mask = possiblesigns(ex->args[0]);
  2535.     for (i = 1; i < ex->nargs; i++) {
  2536.         mask2 = possiblesigns(ex->args[i]);
  2537.         if (mask2 & 2)
  2538.         mask |= 2;
  2539.         if ((mask2 & (1|4)) == 1)
  2540.         mask = negsigns(mask);
  2541.         else if ((mask2 & (1|4)) != 4)
  2542.         mask = 1|2|4;
  2543.     }
  2544.     return mask;
  2545.     }
  2546.     if (ex->kind == EK_DIV || ex->kind == EK_MOD) {
  2547.     mask = possiblesigns(ex->args[0]);
  2548.     mask2 = possiblesigns(ex->args[1]);
  2549.     if (!((mask | mask2) & 1))
  2550.         return 2|4;
  2551.     }
  2552.     if (ex->kind == EK_PLUS) {
  2553.     mask = 0;
  2554.     for (i = 0; i < ex->nargs; i++) {
  2555.         mask2 = possiblesigns(ex->args[i]);
  2556.         if ((mask & negsigns(mask2)) & (1|4))
  2557.         mask |= (1|2|4);
  2558.         else
  2559.         mask |= mask2;
  2560.     }
  2561.     return mask;
  2562.     }
  2563.     if (ex->kind == EK_COND) {
  2564.     return possiblesigns(ex->args[1]) | possiblesigns(ex->args[2]);
  2565.     }
  2566.     if (ex->kind == EK_EQ || ex->kind == EK_LT || ex->kind == EK_GT ||
  2567.     ex->kind == EK_NE || ex->kind == EK_LE || ex->kind == EK_GE ||
  2568.     ex->kind == EK_AND || ex->kind == EK_OR || ex->kind == EK_NOT)
  2569.     return 2|4;
  2570.     if (ex->kind == EK_BICALL) {
  2571.     cp = ex->val.s;
  2572.     if (!strcmp(cp, "strlen") ||
  2573.         !strcmp(cp, "abs") ||
  2574.         !strcmp(cp, "labs") ||
  2575.         !strcmp(cp, "fabs"))
  2576.         return 2|4;
  2577.     }
  2578.     tp = (ex->kind == EK_VAR) ? ((Meaning *)ex->val.i)->type : ex->val.type;
  2579.     if (ord_range(ex->val.type, &val.i, NULL)) {
  2580.     if (val.i > 0)
  2581.         return 4;
  2582.     if (val.i >= 0)
  2583.         return 2|4;
  2584.     }
  2585.     if (ord_range(ex->val.type, NULL, &val.i)) {
  2586.     if (val.i < 0)
  2587.         return 1;
  2588.     if (val.i <= 0)
  2589.         return 1|2;
  2590.     }
  2591.     return 1|2|4;
  2592. }
  2593.  
  2594.  
  2595.  
  2596.  
  2597.  
  2598. Expr *dodivmod(funcname, ekind, a, b)
  2599. char *funcname;
  2600. enum exprkind ekind;
  2601. Expr *a, *b;
  2602. {
  2603.     Meaning *tvar;
  2604.     Type *type;
  2605.     Expr *asn;
  2606.     int sa, sb;
  2607.  
  2608.     type = promote_type_bin(a->val.type, b->val.type);
  2609.     tvar = NULL;
  2610.     sa = possiblesigns(a);
  2611.     sb = possiblesigns(b);
  2612.     if ((sa & 1) || (sb & 1)) {
  2613.     if (*funcname) {
  2614.         asn = NULL;
  2615.         if (*funcname == '*') {
  2616.         if (exprspeed(a) >= 5 || !nosideeffects(a, 0)) {
  2617.             tvar = makestmttempvar(a->val.type, name_TEMP);
  2618.             asn = makeexpr_assign(makeexpr_var(tvar), a);
  2619.             a = makeexpr_var(tvar);
  2620.         }
  2621.         if (exprspeed(b) >= 5 || !nosideeffects(b, 0)) {
  2622.             tvar = makestmttempvar(b->val.type, name_TEMP);
  2623.             asn = makeexpr_comma(asn,
  2624.                      makeexpr_assign(makeexpr_var(tvar),
  2625.                              b));
  2626.             b = makeexpr_var(tvar);
  2627.         }
  2628.         }
  2629.         return makeexpr_comma(asn,
  2630.                   makeexpr_bicall_2(funcname, type, a, b));
  2631.     } else {
  2632.         if ((sa & 1) && (ekind == EK_MOD))
  2633.         note("Using % for possibly-negative arguments [317]");
  2634.         return makeexpr_bin(ekind, type, a, b);
  2635.     }
  2636.     } else
  2637.     return makeexpr_bin(ekind, type, a, b);
  2638. }
  2639.  
  2640.  
  2641.  
  2642. Expr *makeexpr_div(a, b)
  2643. Expr *a, *b;
  2644. {
  2645.     Meaning *mp;
  2646.     Type *type;
  2647.     long i;
  2648.     int p;
  2649.  
  2650.     if (ISCONST(a->kind) && ISCONST(b->kind)) {
  2651.         if (a->val.i >= 0 && b->val.i > 0) {
  2652.         a->val.i /= b->val.i;
  2653.         freeexpr(b);
  2654.         return a;
  2655.     }
  2656.     i = gcd(a->val.i, b->val.i);
  2657.     if (i >= 0) {
  2658.         a->val.i /= i;
  2659.         b->val.i /= i;
  2660.     }
  2661.     }
  2662.     if (((b->kind == EK_CONST && (i = b->val.i)) ||
  2663.          (b->kind == EK_VAR && (mp = (Meaning *)b->val.i)->kind == MK_CONST &&
  2664.       mp->val.type && (i = mp->val.i) && foldconsts != 0)) && i > 0) {
  2665.         if (i == 1)
  2666.             return a;
  2667.         if (div_po2 > 0) {
  2668.             p = 0;
  2669.             while (!(i&1))
  2670.                 p++, i >>= 1;
  2671.             if (i == 1) {
  2672.         type = promote_type_bin(a->val.type, b->val.type);
  2673.                 return makeexpr_bin(EK_RSH, type, a, makeexpr_long(p));
  2674.             }
  2675.         }
  2676.     }
  2677.     if (a->kind == EK_TIMES) {
  2678.     for (p = 0; p < a->nargs; p++) {
  2679.         if (exprsame(a->args[p], b, 1)) {
  2680.         delfreearg(&a, p);
  2681.         freeexpr(b);
  2682.         if (a->nargs == 1)
  2683.             return grabarg(a, 0);
  2684.         else
  2685.             return a;
  2686.         } else if (ISCONST(a->args[p]->kind) && ISCONST(b->kind)) {
  2687.         i = gcd(a->args[p]->val.i, b->val.i);
  2688.         if (i > 1) {
  2689.             a->args[p]->val.i /= i;
  2690.             b->val.i /= i;
  2691.             i = a->args[p]->val.i;
  2692.             delfreearg(&a, p);
  2693.             a = makeexpr_times(a, makeexpr_long(i));   /* resimplify */
  2694.             p = -1;   /* start the loop over */
  2695.         }
  2696.         }
  2697.     }
  2698.     }
  2699.     if (checkconst(b, 1)) {
  2700.         freeexpr(b);
  2701.         return a;
  2702.     } else if (checkconst(b, -1)) {
  2703.         freeexpr(b);
  2704.         return makeexpr_neg(a);
  2705.     } else {
  2706.         if (checkconst(b, 0))
  2707.             warning("Division by zero [163]");
  2708.         return dodivmod(divname, EK_DIV, a, b);
  2709.     }
  2710. }
  2711.  
  2712.  
  2713.  
  2714. Expr *makeexpr_mod(a, b)
  2715. Expr *a, *b;
  2716. {
  2717.     Meaning *mp;
  2718.     Type *type;
  2719.     long i;
  2720.  
  2721.     if (a->kind == EK_CONST && b->kind == EK_CONST &&
  2722.         a->val.i >= 0 && b->val.i > 0) {
  2723.         a->val.i %= b->val.i;
  2724.         freeexpr(b);
  2725.         return a;
  2726.     }
  2727.     if (((b->kind == EK_CONST && (i = b->val.i)) ||
  2728.          (b->kind == EK_VAR && (mp = (Meaning *)b->val.i)->kind == MK_CONST &&
  2729.       mp->val.type && (i = mp->val.i) && foldconsts != 0)) && i > 0) {
  2730.         if (i == 1)
  2731.             return makeexpr_long(0);
  2732.         if (mod_po2 != 0) {
  2733.             while (!(i&1))
  2734.                 i >>= 1;
  2735.             if (i == 1) {
  2736.         type = promote_type_bin(a->val.type, b->val.type);
  2737.                 return makeexpr_bin(EK_BAND, type, a,
  2738.                                     makeexpr_minus(b, makeexpr_long(1)));
  2739.             }
  2740.         }
  2741.     }
  2742.     if (checkconst(b, 0))
  2743.         warning("Division by zero [163]");
  2744.     return dodivmod(modname, EK_MOD, a, b);
  2745. }
  2746.  
  2747.  
  2748.  
  2749. Expr *makeexpr_rem(a, b)
  2750. Expr *a, *b;
  2751. {
  2752.     if (!(possiblesigns(a) & 1) && !(possiblesigns(b) & 1))
  2753.     return makeexpr_mod(a, b);
  2754.     if (checkconst(b, 0))
  2755.         warning("Division by zero [163]");
  2756.     if (!*remname)
  2757.     note("Translating REM same as MOD [141]");
  2758.     return dodivmod(*remname ? remname : modname, EK_MOD, a, b);
  2759. }
  2760.  
  2761.  
  2762.  
  2763.  
  2764.  
  2765. int expr_not_cost(a)
  2766. Expr *a;
  2767. {
  2768.     int i, c;
  2769.  
  2770.     switch (a->kind) {
  2771.  
  2772.         case EK_CONST:
  2773.             return 0;
  2774.  
  2775.         case EK_NOT:
  2776.             return -1;
  2777.  
  2778.         case EK_EQ:
  2779.         case EK_NE:
  2780.         case EK_LT:
  2781.         case EK_GT:
  2782.         case EK_LE:
  2783.         case EK_GE:
  2784.             return 0;
  2785.  
  2786.         case EK_AND:
  2787.         case EK_OR:
  2788.             c = 0;
  2789.             for (i = 0; i < a->nargs; i++)
  2790.                 c += expr_not_cost(a->args[i]);
  2791.             return (c > 1) ? 1 : c;
  2792.  
  2793.         case EK_BICALL:
  2794.             if (!strcmp(a->val.s, oddname) ||
  2795.                 !strcmp(a->val.s, evenname))
  2796.                 return 0;
  2797.             return 1;
  2798.  
  2799.         default:
  2800.             return 1;
  2801.     }
  2802. }
  2803.  
  2804.  
  2805.  
  2806. Expr *makeexpr_not(a)
  2807. Expr *a;
  2808. {
  2809.     Expr *ex;
  2810.     int i;
  2811.  
  2812.     if (debug>2) { fprintf(outf,"makeexpr_not("); dumpexpr(a); fprintf(outf,")\n"); }
  2813.     switch (a->kind) {
  2814.  
  2815.         case EK_CONST:
  2816.             if (a->val.type == tp_boolean) {
  2817.                 a->val.i = !a->val.i;
  2818.                 return a;
  2819.             }
  2820.             break;
  2821.  
  2822.         case EK_EQ:
  2823.             a->kind = EK_NE;
  2824.             return a;
  2825.  
  2826.         case EK_NE:
  2827.             a->kind = EK_EQ;
  2828.             return a;
  2829.  
  2830.         case EK_LT:
  2831.             a->kind = EK_GE;
  2832.             return a;
  2833.  
  2834.         case EK_GT:
  2835.             a->kind = EK_LE;
  2836.             return a;
  2837.  
  2838.         case EK_LE:
  2839.             a->kind = EK_GT;
  2840.             return a;
  2841.  
  2842.         case EK_GE:
  2843.             a->kind = EK_LT;
  2844.             return a;
  2845.  
  2846.         case EK_AND:
  2847.         case EK_OR:
  2848.             if (expr_not_cost(a) > 0)
  2849.                 break;
  2850.             a->kind = (a->kind == EK_OR) ? EK_AND : EK_OR;
  2851.             for (i = 0; i < a->nargs; i++)
  2852.                 a->args[i] = makeexpr_not(a->args[i]);
  2853.             return a;
  2854.  
  2855.         case EK_NOT:
  2856.             ex = a->args[0];
  2857.             FREE(a);
  2858.             ex->val.type = tp_boolean;
  2859.             return ex;
  2860.  
  2861.         case EK_BICALL:
  2862.             if (!strcmp(a->val.s, oddname) && *evenname) {
  2863.                 strchange(&a->val.s, evenname);
  2864.                 return a;
  2865.             } else if (!strcmp(a->val.s, evenname)) {
  2866.                 strchange(&a->val.s, oddname);
  2867.                 return a;
  2868.             }
  2869.             break;
  2870.  
  2871.     default:
  2872.         break;
  2873.     }
  2874.     return makeexpr_un(EK_NOT, tp_boolean, a);
  2875. }
  2876.  
  2877.  
  2878.  
  2879.  
  2880. Type *mixsets(ep1, ep2)
  2881. Expr **ep1, **ep2;
  2882. {
  2883.     Expr *ex1 = *ep1, *ex2 = *ep2;
  2884.     Meaning *tvar;
  2885.     long min1, max1, min2, max2;
  2886.     Type *type;
  2887.  
  2888.     if (ex1->val.type->kind == TK_SMALLSET &&
  2889.         ex2->val.type->kind == TK_SMALLSET)
  2890.         return ex1->val.type;
  2891.     if (ex1->val.type->kind == TK_SMALLSET) {
  2892.         tvar = makestmttempvar(ex2->val.type, name_SET);
  2893.         ex1 = makeexpr_bicall_2(setexpandname, ex2->val.type,
  2894.                                 makeexpr_var(tvar),
  2895.                                 makeexpr_arglong(ex1, 1));
  2896.     }
  2897.     if (ex2->val.type->kind == TK_SMALLSET) {
  2898.         tvar = makestmttempvar(ex1->val.type, name_SET);
  2899.         ex2 = makeexpr_bicall_2(setexpandname, ex1->val.type,
  2900.                                 makeexpr_var(tvar),
  2901.                                 makeexpr_arglong(ex2, 1));
  2902.     }
  2903.     if (ord_range(ex1->val.type->indextype, &min1, &max1) &&
  2904.         ord_range(ex2->val.type->indextype, &min2, &max2)) {
  2905.         if (min1 <= min2 && max1 >= max2)
  2906.             type = ex1->val.type;
  2907.         else if (min2 <= min1 && max2 >= max1)
  2908.             type = ex2->val.type;
  2909.         else {
  2910.             if (min2 < min1) min1 = min2;
  2911.             if (max2 > max1) max1 = max2;
  2912.             type = maketype(TK_SET);
  2913.             type->basetype = tp_integer;
  2914.             type->indextype = maketype(TK_SUBR);
  2915.             type->indextype->basetype = ord_type(ex1->val.type->indextype);
  2916.             type->indextype->smin = makeexpr_long(min1);
  2917.             type->indextype->smax = makeexpr_long(max1);
  2918.         }
  2919.     } else
  2920.     type = ex1->val.type;
  2921.     *ep1 = ex1, *ep2 = ex2;
  2922.     return type;
  2923. }
  2924.  
  2925.  
  2926.  
  2927. Meaning *istempprocptr(ex)
  2928. Expr *ex;
  2929. {
  2930.     Meaning *mp;
  2931.  
  2932.     if (debug>2) { fprintf(outf,"istempprocptr("); dumpexpr(ex); fprintf(outf,")\n"); }
  2933.     if (ex->kind == EK_COMMA && ex->nargs == 3) {
  2934.         if ((mp = istempvar(ex->args[2])) != NULL &&
  2935.         mp->type->kind == TK_PROCPTR &&
  2936.         ex->args[0]->kind == EK_ASSIGN &&
  2937.         ex->args[0]->args[0]->kind == EK_DOT &&
  2938.         exprsame(ex->args[0]->args[0]->args[0], ex->args[2], 1) &&
  2939.         ex->args[1]->kind == EK_ASSIGN &&
  2940.         ex->args[1]->args[0]->kind == EK_DOT &&
  2941.         exprsame(ex->args[1]->args[0]->args[0], ex->args[2], 1))
  2942.         return mp;
  2943.     }
  2944.     if (ex->kind == EK_COMMA && ex->nargs == 2) {
  2945.         if ((mp = istempvar(ex->args[1])) != NULL &&
  2946.         mp->type->kind == TK_CPROCPTR &&
  2947.         ex->args[0]->kind == EK_ASSIGN &&
  2948.         exprsame(ex->args[0]->args[0], ex->args[1], 1))
  2949.         return mp;
  2950.     }
  2951.     return NULL;
  2952. }
  2953.  
  2954.  
  2955.  
  2956.  
  2957. Expr *makeexpr_stringify(ex)
  2958. Expr *ex;
  2959. {
  2960.     ex = makeexpr_stringcast(ex);
  2961.     if (ex->val.type->kind == TK_STRING)
  2962.         return ex;
  2963.     return makeexpr_sprintfify(ex);
  2964. }
  2965.  
  2966.  
  2967.  
  2968. Expr *makeexpr_rel(rel, a, b)
  2969. enum exprkind rel;
  2970. Expr *a, *b;
  2971. {
  2972.     int i, sign;
  2973.     Expr *ex, *ex2;
  2974.     Meaning *mp;
  2975.     char *name;
  2976.  
  2977.     if (debug>2) { fprintf(outf,"makeexpr_rel(%s,", exprkindname(rel)); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  2978.  
  2979.     a = makeexpr_unlongcast(a);
  2980.     b = makeexpr_unlongcast(b);
  2981.     if ((compenums == 0 || (compenums < 0 && ansiC <= 0)) &&
  2982.     (rel != EK_EQ && rel != EK_NE)){
  2983.     a = enum_to_int(a);
  2984.     b = enum_to_int(b);
  2985.     }
  2986.     if (a->val.type != b->val.type) {
  2987.         if (a->val.type->kind == TK_STRING &&
  2988.             a->kind != EK_CONST) {
  2989.             b = makeexpr_stringify(b);
  2990.         } else if (b->val.type->kind == TK_STRING &&
  2991.                    b->kind != EK_CONST) {
  2992.         a = makeexpr_stringify(a);
  2993.         } else if (ord_type(a->val.type)->kind == TK_CHAR ||
  2994.                    a->val.type->kind == TK_ARRAY) {
  2995.             b = gentle_cast(b, ord_type(a->val.type));
  2996.         } else if (ord_type(b->val.type)->kind == TK_CHAR ||
  2997.                    b->val.type->kind == TK_ARRAY) {
  2998.             a = gentle_cast(a, ord_type(b->val.type));
  2999.         } else if (a->val.type == tp_anyptr && !voidstar) {
  3000.             a = gentle_cast(a, b->val.type);
  3001.         } else if (b->val.type == tp_anyptr && !voidstar) {
  3002.             b = gentle_cast(b, a->val.type);
  3003.         }
  3004.     }
  3005.     if (useisspace && b->val.type->kind == TK_CHAR && checkconst(b, ' ')) {
  3006.         if (rel == EK_EQ) {
  3007.             freeexpr(b);
  3008.             return makeexpr_bicall_1("isspace", tp_boolean, a);
  3009.         } else if (rel == EK_NE) {
  3010.             freeexpr(b);
  3011.             return makeexpr_not(makeexpr_bicall_1("isspace", tp_boolean, a));
  3012.         }
  3013.     }
  3014.     if (rel == EK_LT || rel == EK_GE)
  3015.         sign = 1;
  3016.     else if (rel == EK_GT || rel == EK_LE)
  3017.         sign = -1;
  3018.     else
  3019.         sign = 0;
  3020.     if (ord_type(b->val.type)->kind == TK_INTEGER ||
  3021.     ord_type(b->val.type)->kind == TK_CHAR) {
  3022.         for (;;) {
  3023.             if (a->kind == EK_PLUS && ISCONST(a->args[a->nargs-1]->kind) &&
  3024.                  a->args[a->nargs-1]->val.i &&
  3025.                  (ISCONST(b->kind) ||
  3026.                   (b->kind == EK_PLUS && ISCONST(b->args[b->nargs-1]->kind)))) {
  3027.                 b = makeexpr_minus(b, copyexpr(a->args[a->nargs-1]));
  3028.                 a = makeexpr_minus(a, copyexpr(a->args[a->nargs-1]));
  3029.                 continue;
  3030.             }
  3031.             if (b->kind == EK_PLUS && ISCONST(b->args[b->nargs-1]->kind) &&
  3032.                  b->args[b->nargs-1]->val.i &&
  3033.                  ISCONST(a->kind)) {
  3034.                 a = makeexpr_minus(a, copyexpr(b->args[b->nargs-1]));
  3035.                 b = makeexpr_minus(b, copyexpr(b->args[b->nargs-1]));
  3036.                 continue;
  3037.             }
  3038.             if (b->kind == EK_PLUS && sign &&
  3039.              ISCONST(b->args[b->nargs-1]->kind) &&
  3040.                  checkconst(b->args[b->nargs-1], sign)) {
  3041.                 b = makeexpr_plus(b, makeexpr_long(-sign));
  3042.                 switch (rel) {
  3043.                     case EK_LT:
  3044.                         rel = EK_LE;
  3045.                         break;
  3046.                     case EK_GT:
  3047.                         rel = EK_GE;
  3048.                         break;
  3049.                     case EK_LE:
  3050.                         rel = EK_LT;
  3051.                         break;
  3052.                     case EK_GE:
  3053.                         rel = EK_GT;
  3054.                         break;
  3055.             default:
  3056.             break;
  3057.                 }
  3058.                 sign = -sign;
  3059.                 continue;
  3060.             }
  3061.             if (a->kind == EK_TIMES && checkconst(b, 0) && !sign) {
  3062.                 for (i = 0; i < a->nargs; i++) {
  3063.                     if (ISCONST(a->args[i]->kind) && a->args[i]->val.i)
  3064.                         break;
  3065.                     if (a->args[i]->kind == EK_SIZEOF)
  3066.                         break;
  3067.                 }
  3068.                 if (i < a->nargs) {
  3069.                     delfreearg(&a, i);
  3070.                     continue;
  3071.                 }
  3072.             }
  3073.             break;
  3074.         }
  3075.         if (a->kind == EK_BICALL && !strcmp(a->val.s, "strlen") &&
  3076.             checkconst(b, 0)) {
  3077.             if (rel == EK_LT || rel == EK_GE) {
  3078.                 note("Unusual use of STRLEN encountered [142]");
  3079.             } else {
  3080.                 freeexpr(b);
  3081.                 a = makeexpr_hat(grabarg(a, 0), 0);
  3082.                 b = makeexpr_char(0);      /* "strlen(a) = 0" => "*a == 0" */
  3083.                 if (rel == EK_EQ || rel == EK_LE)
  3084.                     return makeexpr_rel(EK_EQ, a, b);
  3085.                 else
  3086.                     return makeexpr_rel(EK_NE, a, b);
  3087.             }
  3088.         }
  3089.         if (ISCONST(a->kind) && ISCONST(b->kind)) {
  3090.             if ((a->val.i == b->val.i && (rel == EK_EQ || rel == EK_GE || rel == EK_LE)) ||
  3091.                 (a->val.i <  b->val.i && (rel == EK_NE || rel == EK_LE || rel == EK_LT)) ||
  3092.                 (a->val.i >  b->val.i && (rel == EK_NE || rel == EK_GE || rel == EK_GT)))
  3093.                 return makeexpr_val(make_ord(tp_boolean, 1));
  3094.             else
  3095.                 return makeexpr_val(make_ord(tp_boolean, 0));
  3096.         }
  3097.     if ((a->val.type == tp_char || true_type(a) == tp_char) &&
  3098.         ISCONST(b->kind) && signedchars != 0) {
  3099.         i = (b->val.i == 128 && sign == 1) ||
  3100.         (b->val.i == 127 && sign == -1);
  3101.         if (highcharbits && (highcharbits > 0 || signedchars < 0) && i) {
  3102.         if (highcharbits == 2)
  3103.             b = makeexpr_long(128);
  3104.         else
  3105.             b = makeexpr_un(EK_BNOT, tp_integer, makeexpr_long(127));
  3106.         return makeexpr_rel((rel == EK_GE || rel == EK_GT)
  3107.                     ? EK_NE : EK_EQ,
  3108.                     makeexpr_bin(EK_BAND, tp_integer,
  3109.                          eatcasts(a), b),
  3110.                     makeexpr_long(0));
  3111.         } else if (signedchars == 1 && i) {
  3112.         return makeexpr_rel((rel == EK_GE || rel == EK_GT)
  3113.                     ? EK_LT : EK_GE,
  3114.                     eatcasts(a), makeexpr_long(0));
  3115.         } else if (signedchars == 1 && b->val.i >= 128 && sign == 0) {
  3116.         b->val.i -= 256;
  3117.         } else if (b->val.i >= 128 ||
  3118.                (b->val.i == 127 && sign != 0)) {
  3119.         if (highcharbits && (highcharbits > 0 || signedchars < 0))
  3120.             a = makeexpr_bin(EK_BAND, a->val.type, eatcasts(a),
  3121.                      makeexpr_long(255));
  3122.         else
  3123.             a = force_unsigned(a);
  3124.         }
  3125.     }
  3126.     } else if (a->val.type->kind == TK_STRING &&
  3127.                b->val.type->kind == TK_STRING) {
  3128.         if (b->kind == EK_CONST && b->val.i == 0 && !sign) {
  3129.             a = makeexpr_hat(a, 0);
  3130.             b = makeexpr_char(0);      /* "a = ''" => "*a == 0" */
  3131.         } else {
  3132.             a = makeexpr_bicall_2("strcmp", tp_int, a, b);
  3133.             b = makeexpr_long(0);
  3134.         }
  3135.     } else if ((a->val.type->kind == TK_ARRAY ||
  3136.         a->val.type->kind == TK_STRING ||
  3137.         a->val.type->kind == TK_RECORD) &&
  3138.            (b->val.type->kind == TK_ARRAY ||
  3139.         b->val.type->kind == TK_STRING ||
  3140.         b->val.type->kind == TK_RECORD)) {
  3141.         if (a->val.type->kind == TK_ARRAY) {
  3142.             if (b->val.type->kind == TK_ARRAY) {
  3143.                 ex = makeexpr_sizeof(copyexpr(a), 0);
  3144.                 ex2 = makeexpr_sizeof(copyexpr(b), 0);
  3145.                 if (!exprsame(ex, ex2, 1))
  3146.                     warning("Incompatible array sizes [164]");
  3147.                 freeexpr(ex2);
  3148.             } else {
  3149.                 ex = makeexpr_sizeof(copyexpr(a), 0);
  3150.             }
  3151.         } else
  3152.             ex = makeexpr_sizeof(copyexpr(b), 0);
  3153.     name = (usestrncmp &&
  3154.         a->val.type->kind == TK_ARRAY &&
  3155.         a->val.type->basetype->kind == TK_CHAR) ? "strncmp" : "memcmp";
  3156.         a = makeexpr_bicall_3(name, tp_int,
  3157.                   makeexpr_addr(a),
  3158.                   makeexpr_addr(b), ex);
  3159.         b = makeexpr_long(0);
  3160.     } else if (a->val.type->kind == TK_SET ||
  3161.                a->val.type->kind == TK_SMALLSET) {
  3162.         if (rel == EK_GE) {
  3163.             swapexprs(a, b);
  3164.             rel = EK_LE;
  3165.         }
  3166.         if (mixsets(&a, &b)->kind == TK_SMALLSET) {
  3167.             if (rel == EK_LE) {
  3168.                 a = makeexpr_bin(EK_BAND, tp_integer,
  3169.                                  a, makeexpr_un(EK_BNOT, tp_integer, b));
  3170.                 b = makeexpr_long(0);
  3171.                 rel = EK_EQ;
  3172.             }
  3173.         } else if (b->kind == EK_BICALL &&
  3174.                    !strcmp(b->val.s, setexpandname) &&
  3175.                    (mp = istempvar(b->args[0])) != NULL &&
  3176.                    checkconst(b->args[1], 0)) {
  3177.             canceltempvar(mp);
  3178.             a = makeexpr_hat(a, 0);
  3179.             b = grabarg(b, 1);
  3180.             if (rel == EK_LE)
  3181.                 rel = EK_EQ;
  3182.         } else {
  3183.             ex = makeexpr_bicall_2((rel == EK_LE) ? subsetname : setequalname,
  3184.                                    tp_boolean, a, b);
  3185.             return (rel == EK_NE) ? makeexpr_not(ex) : ex;
  3186.         }
  3187.     } else if (a->val.type->kind == TK_PROCPTR ||
  3188.            a->val.type->kind == TK_CPROCPTR) {
  3189.         /* we compare proc only (not link) -- same as Pascal compiler! */
  3190.     if (a->val.type->kind == TK_PROCPTR)
  3191.         a = makeexpr_dotq(a, "proc", tp_anyptr);
  3192.         if ((mp = istempprocptr(b)) != NULL) {
  3193.             canceltempvar(mp);
  3194.         b = grabarg(grabarg(b, 0), 1);
  3195.             if (!voidstar)
  3196.                 b = makeexpr_cast(b, tp_anyptr);
  3197.         } else if (b->val.type->kind == TK_PROCPTR)
  3198.             b = makeexpr_dotq(b, "proc", tp_anyptr);
  3199.     }
  3200.     return makeexpr_bin(rel, tp_boolean, a, b);
  3201. }
  3202.  
  3203.  
  3204.  
  3205.  
  3206. Expr *makeexpr_and(a, b)
  3207. Expr *a, *b;
  3208. {
  3209.     Expr *ex, **exp, *low;
  3210.  
  3211.     if (!a)
  3212.         return b;
  3213.     if (!b)
  3214.         return a;
  3215.     for (exp = &a; (ex = *exp)->kind == EK_AND; exp = &ex->args[1]) ;
  3216.     if ((b->kind == EK_LT || b->kind == EK_LE) &&
  3217.         ((ex->kind == EK_LE && exprsame(ex->args[1], b->args[0], 1)) ||
  3218.          (ex->kind == EK_GE && exprsame(ex->args[0], b->args[0], 1)))) {
  3219.         low = (ex->kind == EK_LE) ? ex->args[0] : ex->args[1];
  3220.         if (unsignedtrick && checkconst(low, 0)) {
  3221.             freeexpr(ex);
  3222.             b->args[0] = force_unsigned(b->args[0]);
  3223.             *exp = b;
  3224.             return a;
  3225.         }
  3226.         if (b->args[1]->val.type->kind == TK_CHAR && useisalpha) {
  3227.             if (checkconst(low, 'A') && checkconst(b->args[1], 'Z')) {
  3228.                 freeexpr(ex);
  3229.                 *exp = makeexpr_bicall_1("isupper", tp_boolean, grabarg(b, 0));
  3230.                 return a;
  3231.             }
  3232.             if (checkconst(low, 'a') && checkconst(b->args[1], 'z')) {
  3233.                 freeexpr(ex);
  3234.                 *exp = makeexpr_bicall_1("islower", tp_boolean, grabarg(b, 0));
  3235.                 return a;
  3236.             }
  3237.             if (checkconst(low, '0') && checkconst(b->args[1], '9')) {
  3238.                 freeexpr(ex);
  3239.                 *exp = makeexpr_bicall_1("isdigit", tp_boolean, grabarg(b, 0));
  3240.                 return a;
  3241.             }
  3242.         }
  3243.     }
  3244.     return makeexpr_bin(EK_AND, tp_boolean, a, b);
  3245. }
  3246.  
  3247.  
  3248.  
  3249. Expr *makeexpr_or(a, b)
  3250. Expr *a, *b;
  3251. {
  3252.     Expr *ex, **exp, *low;
  3253.  
  3254.     if (!a)
  3255.         return b;
  3256.     if (!b)
  3257.         return a;
  3258.     for (exp = &a; (ex = *exp)->kind == EK_OR; exp = &ex->args[1]) ;
  3259.     if (((b->kind == EK_BICALL && !strcmp(b->val.s, "isdigit") &&
  3260.           ex->kind == EK_BICALL && !strcmp(ex->val.s, "isalpha")) ||
  3261.          (b->kind == EK_BICALL && !strcmp(b->val.s, "isalpha") &&
  3262.           ex->kind == EK_BICALL && !strcmp(ex->val.s, "isdigit"))) &&
  3263.         exprsame(ex->args[0], b->args[0], 1)) {
  3264.         strchange(&ex->val.s, "isalnum");
  3265.         freeexpr(b);
  3266.         return a;
  3267.     }
  3268.     if (((b->kind == EK_BICALL && !strcmp(b->val.s, "islower") &&
  3269.           ex->kind == EK_BICALL && !strcmp(ex->val.s, "isupper")) ||
  3270.          (b->kind == EK_BICALL && !strcmp(b->val.s, "isupper") &&
  3271.           ex->kind == EK_BICALL && !strcmp(ex->val.s, "islower"))) &&
  3272.         exprsame(ex->args[0], b->args[0], 1)) {
  3273.         strchange(&ex->val.s, "isalpha");
  3274.         freeexpr(b);
  3275.         return a;
  3276.     }
  3277.     if ((b->kind == EK_GT || b->kind == EK_GE) &&
  3278.         ((ex->kind == EK_GT && exprsame(ex->args[1], b->args[0], 1)) ||
  3279.          (ex->kind == EK_LT && exprsame(ex->args[0], b->args[0], 1)))) {
  3280.         low = (ex->kind == EK_GT) ? ex->args[0] : ex->args[1];
  3281.         if (unsignedtrick && checkconst(low, 0)) {
  3282.             freeexpr(ex);
  3283.             b->args[0] = force_unsigned(b->args[0]);
  3284.             *exp = b;
  3285.             return a;
  3286.         }
  3287.     }
  3288.     return makeexpr_bin(EK_OR, tp_boolean, a, b);
  3289. }
  3290.  
  3291.  
  3292.  
  3293. Expr *makeexpr_range(ex, exlow, exhigh, higheq)
  3294. Expr *ex, *exlow, *exhigh;
  3295. int higheq;
  3296. {
  3297.     Expr *ex2;
  3298.     enum exprkind rel = (higheq) ? EK_LE : EK_LT;
  3299.  
  3300.     if (exprsame(exlow, exhigh, 1) && higheq)
  3301.         return makeexpr_rel(EK_EQ, ex, exlow);
  3302.     ex2 = makeexpr_rel(rel, copyexpr(ex), exhigh);
  3303.     if (lelerange)
  3304.         return makeexpr_and(makeexpr_rel(EK_LE, exlow, ex), ex2);
  3305.     else
  3306.         return makeexpr_and(makeexpr_rel(EK_GE, ex, exlow), ex2);
  3307. }
  3308.  
  3309.  
  3310.  
  3311.  
  3312. Expr *makeexpr_cond(c, a, b)
  3313. Expr *c, *a, *b;
  3314. {
  3315.     Expr *ex;
  3316.  
  3317.     ex = makeexpr(EK_COND, 3);
  3318.     ex->val.type = a->val.type;
  3319.     ex->args[0] = c;
  3320.     ex->args[1] = a;
  3321.     ex->args[2] = b;
  3322.     if (debug>2) { fprintf(outf,"makeexpr_cond returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  3323.     return ex;
  3324. }
  3325.  
  3326.  
  3327.  
  3328.  
  3329. int expr_is_lvalue(ex)
  3330. Expr *ex;
  3331. {
  3332.     Meaning *mp;
  3333.  
  3334.     switch (ex->kind) {
  3335.  
  3336.         case EK_VAR:
  3337.             mp = (Meaning *)ex->val.i;
  3338.             return (mp->kind == MK_VAR || mp->kind == MK_PARAM ||
  3339.             mp->kind == MK_VARPARAM ||
  3340.                     (mp->kind == MK_CONST &&
  3341.                      (mp->type->kind == TK_ARRAY ||
  3342.                       mp->type->kind == TK_RECORD ||
  3343.                       mp->type->kind == TK_SET)));
  3344.  
  3345.         case EK_HAT:
  3346.         case EK_NAME:
  3347.             return 1;
  3348.  
  3349.         case EK_INDEX:
  3350.     case EK_DOT:
  3351.         return expr_is_lvalue(ex->args[0]);
  3352.  
  3353.     case EK_COMMA:
  3354.         return expr_is_lvalue(ex->args[ex->nargs-1]);
  3355.  
  3356.         default:
  3357.             return 0;
  3358.     }
  3359. }
  3360.  
  3361.  
  3362. int expr_has_address(ex)
  3363. Expr *ex;
  3364. {
  3365.     if (ex->kind == EK_DOT &&
  3366.     ((Meaning *)ex->val.i)->val.i)
  3367.     return 0;    /* bit fields do not have an address */
  3368.     return expr_is_lvalue(ex);
  3369. }
  3370.  
  3371.  
  3372.  
  3373. Expr *checknil(ex)
  3374. Expr *ex;
  3375. {
  3376.     if (nilcheck == 1) {
  3377.         if (singlevar(ex)) {
  3378.             ex = makeexpr_un(EK_CHECKNIL, ex->val.type, ex);
  3379.         } else {
  3380.             ex = makeexpr_bin(EK_CHECKNIL, ex->val.type, ex,
  3381.                               makeexpr_var(makestmttempvar(ex->val.type,
  3382.                                                            name_PTR)));
  3383.         }
  3384.     }
  3385.     return ex;
  3386. }
  3387.  
  3388.  
  3389. int checkvarinlists(yes, no, def, mp)
  3390. Strlist *yes, *no;
  3391. int def;
  3392. Meaning *mp;
  3393. {
  3394.     char *cp;
  3395.     Meaning *ctx;
  3396.  
  3397.     if (mp->kind == MK_FIELD)
  3398.     ctx = mp->rectype->meaning;
  3399.     else
  3400.     ctx = mp->ctx;
  3401.     if (ctx && ctx->name)
  3402.     cp = format_ss("%s.%s", ctx->name, mp->name);
  3403.     else
  3404.     cp = NULL;
  3405.     if (strlist_cifind(yes, cp))
  3406.     return 1;
  3407.     if (strlist_cifind(no, cp))
  3408.     return 0;
  3409.     if (strlist_cifind(yes, mp->name))
  3410.     return 1;
  3411.     if (strlist_cifind(no, mp->name))
  3412.     return 0;
  3413.     if (strlist_cifind(yes, "1"))
  3414.     return 1;
  3415.     if (strlist_cifind(no, "1"))
  3416.     return 0;
  3417.     return def;
  3418. }
  3419.  
  3420.  
  3421. void requirefilebuffer(ex)
  3422. Expr *ex;
  3423. {
  3424.     Meaning *mp;
  3425.  
  3426.     if (!isfiletype(ex->val.type, 0))
  3427.     return;
  3428.     mp = isfilevar(ex);
  3429.     if (!mp) {
  3430.     if (ex->kind == EK_HAT)
  3431.         ex = ex->args[0];
  3432.     if (ex->kind == EK_VAR) {
  3433.         mp = (Meaning *)ex->val.i;
  3434.         if (mp->kind == MK_PARAM || mp->kind == MK_VARPARAM)
  3435.         note(format_s("File parameter %s can't access buffers (try StructFiles = 1) [318]",
  3436.                   mp->name));
  3437.     }
  3438.     } else if (!mp->bufferedfile &&
  3439.            checkvarinlists(bufferedfiles, unbufferedfiles, 1, mp)) {
  3440.     if (mp->wasdeclared)
  3441.         note(format_s("Discovered too late that %s should be buffered [143]",
  3442.               mp->name));
  3443.     mp->bufferedfile = 1;
  3444.     }
  3445. }
  3446.  
  3447.  
  3448. Expr *makeexpr_hat(a, check)
  3449. Expr *a;
  3450. int check;
  3451. {
  3452.     Expr *ex;
  3453.  
  3454.     if (debug>2) { fprintf(outf,"makeexpr_hat("); dumpexpr(a); fprintf(outf,")\n"); }
  3455.     if (isfiletype(a->val.type, -1)) {
  3456.     requirefilebuffer(a);
  3457.     if (*chargetfbufname &&
  3458.         filebasetype(a->val.type)->kind == TK_CHAR)
  3459.         return makeexpr_bicall_1(chargetfbufname,
  3460.                      filebasetype(a->val.type),
  3461.                      filebasename(a));
  3462.     else if (*arraygetfbufname &&
  3463.          filebasetype(a->val.type)->kind == TK_ARRAY)
  3464.         return makeexpr_bicall_2(arraygetfbufname,
  3465.                      filebasetype(a->val.type),
  3466.                      filebasename(a),
  3467.                      makeexpr_type(filebasetype(a->val.type)));
  3468.     else
  3469.         return makeexpr_bicall_2(getfbufname,
  3470.                      filebasetype(a->val.type),
  3471.                      filebasename(a),
  3472.                      makeexpr_type(filebasetype(a->val.type)));
  3473.     }
  3474.     if (a->kind == EK_PLUS &&
  3475.                (ex = a->args[0])->val.type->kind == TK_POINTER &&
  3476.                (ex->val.type->basetype->kind == TK_ARRAY ||
  3477.                 ex->val.type->basetype->kind == TK_STRING ||
  3478.                 ex->val.type->basetype->kind == TK_SET)) {
  3479.         ex->val.type = ex->val.type->basetype;   /* convert *(a+n) to a[n] */
  3480.         deletearg(&a, 0);
  3481.         if (a->nargs == 1)
  3482.             a = grabarg(a, 0);
  3483.         return makeexpr_bin(EK_INDEX, ex->val.type->basetype, ex, a);
  3484.     }
  3485.     if (a->val.type->kind == TK_STRING ||
  3486.         a->val.type->kind == TK_ARRAY ||
  3487.         a->val.type->kind == TK_SET) {
  3488.         if (starindex == 0)
  3489.             return makeexpr_bin(EK_INDEX, a->val.type->basetype, a, makeexpr_long(0));
  3490.         else
  3491.             return makeexpr_un(EK_HAT, a->val.type->basetype, a);
  3492.     }
  3493.     if (a->val.type->kind != TK_POINTER || !a->val.type->basetype) {
  3494.         warning("bad pointer dereference [165]");
  3495.         return a;
  3496.     }
  3497.     if (a->kind == EK_CAST &&
  3498.     a->val.type->basetype->kind == TK_POINTER &&
  3499.     a->args[0]->val.type->kind == TK_POINTER &&
  3500.     a->args[0]->val.type->basetype->kind == TK_POINTER) {
  3501.     return makeexpr_cast(makeexpr_hat(a->args[0], 0),
  3502.                  a->val.type->basetype);
  3503.     }
  3504.     switch (a->val.type->basetype->kind) {
  3505.  
  3506.       case TK_ARRAY:
  3507.       case TK_STRING:
  3508.       case TK_SET:
  3509.     if (a->kind != EK_HAT || 1 ||
  3510.         a->val.type == a->args[0]->val.type->basetype) {
  3511.         a->val.type = a->val.type->basetype;
  3512.         return a;
  3513.     }
  3514.  
  3515.       default:
  3516.     if (a->kind == EK_ADDR) {
  3517.         ex = a->args[0];
  3518.         FREE(a);
  3519.         return ex;
  3520.     } else {
  3521.         if (check)
  3522.         ex = checknil(a);
  3523.         else
  3524.         ex = a;
  3525.         return makeexpr_un(EK_HAT, a->val.type->basetype, ex);
  3526.         }
  3527.     }
  3528. }
  3529.  
  3530.  
  3531.  
  3532. Expr *un_sign_extend(a)
  3533. Expr *a;
  3534. {
  3535.     if (a->kind == EK_BICALL &&
  3536.         !strcmp(a->val.s, signextname) && *signextname) {
  3537.         return grabarg(a, 0);
  3538.     }
  3539.     return a;
  3540. }
  3541.  
  3542.  
  3543.  
  3544. Expr *makeexpr_addr(a)
  3545. Expr *a;
  3546. {
  3547.     Expr *ex;
  3548.     Type *type;
  3549.     Meaning *mp;
  3550.  
  3551.     a = un_sign_extend(a);
  3552.     type = makepointertype(a->val.type);
  3553.     if (debug>2) { fprintf(outf,"makeexpr_addr("); dumpexpr(a); fprintf(outf,", "); dumptypename(type, 1); fprintf(outf,")\n"); }
  3554.     if (a->kind == EK_CONST && a->val.type->kind == TK_STRING) {
  3555.         return a;     /* kludge to help assignments */
  3556.     } else if (a->kind == EK_INDEX &&
  3557.            (a->val.type->kind != TK_ARRAY &&
  3558.         a->val.type->kind != TK_SET &&
  3559.         a->val.type->kind != TK_STRING) &&
  3560.            (addindex == 1 ||
  3561.         (addindex != 0 && checkconst(a->args[1], 0)))) {
  3562.         ex = makeexpr_plus(makeexpr_addr(a->args[0]), a->args[1]);
  3563.         FREE(a);
  3564.         ex->val.type = type;
  3565.         return ex;
  3566.     } else if (a->kind == EK_CAST) {
  3567.     return makeexpr_cast(makeexpr_addr(a->args[0]), type);
  3568.     } else if (a->kind == EK_ACTCAST) {
  3569.     return makeexpr_actcast(makeexpr_addr(a->args[0]), type);
  3570.     } else if (a->kind == EK_LITCAST) {
  3571.     if (a->args[0]->kind == EK_NAME) {
  3572.         if (my_strchr(a->args[0]->val.s, '(') ||
  3573.         my_strchr(a->args[0]->val.s, '['))
  3574.         note("Constructing pointer type by adding '*' may be incorrect [322]");
  3575.         return makeexpr_bin(EK_LITCAST, tp_integer,
  3576.                 makeexpr_name(format_s("%s*",
  3577.                                a->args[0]->val.s),
  3578.                           tp_integer),
  3579.                 makeexpr_addr(a->args[1]));
  3580.     } else
  3581.         return makeexpr_bin(EK_LITCAST, tp_integer, makeexpr_type(type),
  3582.                 makeexpr_addr(a->args[1]));
  3583.     } else {
  3584.         switch (a->val.type->kind) {
  3585.  
  3586.       case TK_ARRAY:
  3587.       case TK_STRING:
  3588.       case TK_SET:
  3589.         if (a->val.type->smin) {
  3590.         return makeexpr_un(EK_ADDR, type,
  3591.                    makeexpr_index(a,
  3592.                           copyexpr(a->val.type->smin),
  3593.                           NULL));
  3594.         }
  3595.         a->val.type = type;
  3596.         return a;
  3597.  
  3598.       default:
  3599.         if (a->kind == EK_HAT) {
  3600.         ex = a->args[0];
  3601.         FREE(a);
  3602.         return ex;
  3603.         } else if (a->kind == EK_ACTCAST)
  3604.         return makeexpr_actcast(makeexpr_addr(grabarg(a, 0)), type);
  3605.         else if (a->kind == EK_CAST)
  3606.         return makeexpr_cast(makeexpr_addr(grabarg(a, 0)), type);
  3607.         else {
  3608.         if (a->kind == EK_VAR &&
  3609.             (mp = (Meaning *)a->val.i)->kind == MK_PARAM &&
  3610.             mp->type != promote_type(mp->type) &&
  3611.             fixpromotedargs) {
  3612.             note(format_s("Taking & of possibly promoted param %s [324]",
  3613.                   mp->name));
  3614.             if (fixpromotedargs == 1) {
  3615.             mp->varstructflag = 1;
  3616.             mp->ctx->varstructflag = 1;
  3617.             }
  3618.         }
  3619.         return makeexpr_un(EK_ADDR, type, a);
  3620.         }
  3621.     }
  3622.     }
  3623. }
  3624.  
  3625.  
  3626.  
  3627. Expr *makeexpr_addrstr(a)
  3628. Expr *a;
  3629. {
  3630.     if (debug>2) { fprintf(outf,"makeexpr_addrstr("); dumpexpr(a); fprintf(outf,")\n"); }
  3631.     if (a->val.type->kind == TK_POINTER)
  3632.     return a;
  3633.     return makeexpr_addr(a);
  3634. }
  3635.  
  3636.  
  3637.  
  3638. Expr *makeexpr_addrf(a)
  3639. Expr *a;
  3640. {
  3641.     Meaning *mp, *tvar;
  3642.  
  3643.     mp = (Meaning *)a->val.i;
  3644.     if (is_std_file(a)) {
  3645.         if (addrstdfiles == 0) {
  3646.             note(format_s("Taking address of %s; consider setting VarFiles = 0 [144]",
  3647.                           (a->kind == EK_VAR) ? ((Meaning *)a->val.i)->name
  3648.                                               : a->val.s));
  3649.             tvar = makestmttempvar(tp_text, name_TEMP);
  3650.             return makeexpr_comma(makeexpr_assign(makeexpr_var(tvar), a),
  3651.                                   makeexpr_addr(makeexpr_var(tvar)));
  3652.         }
  3653.     }
  3654.     if ((a->kind == EK_VAR &&
  3655.          mp->kind == MK_FIELD && mp->val.i) ||
  3656.         (a->kind == EK_BICALL &&
  3657.          !strcmp(a->val.s, getbitsname))) {
  3658.         warning("Can't take the address of a bit-field [166]");
  3659.     }
  3660.     return makeexpr_addr(a);
  3661. }
  3662.  
  3663.  
  3664.  
  3665. Expr *makeexpr_index(a, b, offset)
  3666. Expr *a, *b, *offset;
  3667. {
  3668.     Type *indextype, *btype;
  3669.  
  3670.     if (debug>2) { fprintf(outf,"makeexpr_index("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b);
  3671.                                                                  fprintf(outf,", "); dumpexpr(offset); fprintf(outf,")\n"); }
  3672.     indextype = (a->val.type->kind == TK_ARRAY) ? a->val.type->indextype
  3673.                                                 : tp_integer;
  3674.     b = gentle_cast(b, indextype);
  3675.     if (!offset)
  3676.         offset = makeexpr_long(0);
  3677.     b = makeexpr_minus(b, gentle_cast(offset, indextype));
  3678.     btype = a->val.type;
  3679.     if (btype->basetype)
  3680.     btype = btype->basetype;
  3681.     if (checkconst(b, 0) && starindex == 1)
  3682.         return makeexpr_un(EK_HAT, btype, a);
  3683.     else
  3684.         return makeexpr_bin(EK_INDEX, btype, a,
  3685.                             gentle_cast(b, indextype));
  3686. }
  3687.  
  3688.  
  3689.  
  3690. Expr *makeexpr_type(type)
  3691. Type *type;
  3692. {
  3693.     Expr *ex;
  3694.  
  3695.     ex = makeexpr(EK_TYPENAME, 0);
  3696.     ex->val.type = type;
  3697.     return ex;
  3698. }
  3699.  
  3700.  
  3701. Expr *makeexpr_sizeof(ex, incskipped)
  3702. Expr *ex;
  3703. int incskipped;
  3704. {
  3705.     Expr *ex2, *ex3;
  3706.     Type *btype;
  3707.     char *name;
  3708.  
  3709.     if (ex->val.type->meaning) {
  3710.     name = find_special_variant(ex->val.type->meaning->name,
  3711.                     "SpecialSizeOf", specialsizeofs, 1);
  3712.     if (name) {
  3713.         freeexpr(ex);
  3714.         return pc_expr_str(name);
  3715.     }
  3716.     }
  3717.     switch (ex->val.type->kind) {
  3718.  
  3719.         case TK_CHAR:
  3720.         case TK_BOOLEAN:
  3721.             freeexpr(ex);
  3722.             return makeexpr_long(1);
  3723.  
  3724.         case TK_SUBR:
  3725.         btype = findbasetype(ex->val.type, ODECL_NOPRES);
  3726.         if (btype->kind == TK_CHAR || btype == tp_abyte) {
  3727.         freeexpr(ex);
  3728.         return makeexpr_long(1);
  3729.         }
  3730.         break;
  3731.  
  3732.         case TK_STRING:
  3733.         case TK_ARRAY:
  3734.             if (!ex->val.type->meaning || ex->val.type->kind == TK_STRING ||
  3735.         (!incskipped && ex->val.type->smin)) {
  3736.                 ex3 = arraysize(ex->val.type, incskipped);
  3737.                 return makeexpr_times(ex3,
  3738.                                       makeexpr_sizeof(makeexpr_type(
  3739.                                            ex->val.type->basetype), 1));
  3740.             }
  3741.             break;
  3742.  
  3743.         case TK_SET:
  3744.             ord_range_expr(ex->val.type->indextype, NULL, &ex2);
  3745.             freeexpr(ex);
  3746.             return makeexpr_times(makeexpr_plus(makeexpr_div(copyexpr(ex2),
  3747.                                                              makeexpr_setbits()),
  3748.                                                 makeexpr_long(2)),
  3749.                                   makeexpr_sizeof(makeexpr_type(tp_integer), 0));
  3750.  
  3751.     default:
  3752.         break;
  3753.     }
  3754.     if (ex->kind != EK_CONST &&
  3755.         (findbasetype(ex->val.type,0)->meaning || /* if type has a name... */
  3756.          ex->val.type->kind == TK_STRING ||       /* if C sizeof(expr) will give wrong answer */
  3757.          ex->val.type->kind == TK_ARRAY ||
  3758.          ex->val.type->kind == TK_SET)) {
  3759.         ex2 = makeexpr_type(ex->val.type);
  3760.         freeexpr(ex);
  3761.         ex = ex2;
  3762.     }
  3763.     return makeexpr_un(EK_SIZEOF, tp_integer, ex);
  3764. }
  3765.  
  3766.  
  3767.  
  3768.  
  3769. /* Compute a measure of how fast or slow the expression is likely to be.
  3770.    0 is a constant, 1 is a variable, extra points added per "operation". */
  3771.  
  3772. int exprspeed(ex)
  3773. Expr *ex;
  3774. {
  3775.     Meaning *mp, *mp2;
  3776.     int i, cost, speed;
  3777.  
  3778.     switch (ex->kind) {
  3779.  
  3780.         case EK_VAR:
  3781.             mp = (Meaning *)ex->val.i;
  3782.             if (mp->kind == MK_CONST)
  3783.                 return 0;
  3784.             if (!mp->ctx || mp->ctx->kind == MK_FUNCTION)
  3785.                 return 1;
  3786.             i = 1;
  3787.             for (mp2 = curctx; mp2 && mp2 != mp->ctx; mp2 = mp2->ctx)
  3788.                 i++;    /* cost of following static links */
  3789.             return (i);
  3790.  
  3791.         case EK_CONST:
  3792.         case EK_LONGCONST:
  3793.         case EK_SIZEOF:
  3794.             return 0;
  3795.  
  3796.         case EK_ADDR:
  3797.             speed = exprspeed(ex->args[0]);
  3798.             return (speed > 1) ? speed : 0;
  3799.  
  3800.         case EK_DOT:
  3801.             return exprspeed(ex->args[0]);
  3802.  
  3803.         case EK_NEG:
  3804.             return exprspeed(ex->args[0]) + 1;
  3805.  
  3806.         case EK_CAST:
  3807.         case EK_ACTCAST:
  3808.             i = (ord_type(ex->val.type)->kind == TK_REAL) !=
  3809.                 (ord_type(ex->args[0]->val.type)->kind == TK_REAL);
  3810.             return (i + exprspeed(ex->args[0]));
  3811.  
  3812.         case EK_COND:
  3813.             return 2 + exprspeed(ex->args[0]) +
  3814.                    MAX(exprspeed(ex->args[1]), exprspeed(ex->args[2]));
  3815.  
  3816.         case EK_AND:
  3817.         case EK_OR:
  3818.         case EK_COMMA:
  3819.             speed = 2;
  3820.             for (i = 0; i < ex->nargs; i++)
  3821.                 speed += exprspeed(ex->args[i]);
  3822.             return speed;
  3823.  
  3824.         case EK_FUNCTION:
  3825.         case EK_BICALL:
  3826.         case EK_SPCALL:
  3827.             return 1000;
  3828.  
  3829.         case EK_ASSIGN:
  3830.         case EK_POSTINC:
  3831.         case EK_POSTDEC:
  3832.             return 100 + exprspeed(ex->args[0]) + exprspeed(ex->args[1]);
  3833.  
  3834.         default:
  3835.             cost = (ex->kind == EK_PLUS) ? 1 : 2;
  3836.             if (ex->val.type->kind == TK_REAL)
  3837.                 cost *= 2;
  3838.             speed = -cost;
  3839.             for (i = 0; i < ex->nargs; i++) {
  3840.                 if (!isliteralconst(ex->args[i], NULL) ||
  3841.                     ex->val.type->kind == TK_REAL)
  3842.                     speed += exprspeed(ex->args[i]) + cost;
  3843.             }
  3844.             return MAX(speed, 0);
  3845.     }
  3846. }
  3847.  
  3848.  
  3849.  
  3850.  
  3851. int noargdependencies(ex, vars)
  3852. Expr *ex;
  3853. int vars;
  3854. {
  3855.     int i;
  3856.  
  3857.     for (i = 0; i < ex->nargs; i++) {
  3858.         if (!nodependencies(ex->args[i], vars))
  3859.             return 0;
  3860.     }
  3861.     return 1;
  3862. }
  3863.  
  3864.  
  3865. int nodependencies(ex, vars)
  3866. Expr *ex;
  3867. int vars;   /* 1 if explicit dependencies on vars count as dependencies */
  3868. {           /* 2 if global but not local vars count as dependencies */
  3869.     Meaning *mp;
  3870.  
  3871.     if (debug>2) { fprintf(outf,"nodependencies("); dumpexpr(ex); fprintf(outf,")\n"); }
  3872.     if (!noargdependencies(ex, vars))
  3873.         return 0;
  3874.     switch (ex->kind) {
  3875.  
  3876.         case EK_VAR:
  3877.             mp = (Meaning *)ex->val.i;
  3878.         if (mp->kind == MK_CONST)
  3879.         return 1;
  3880.         if (vars == 2 &&
  3881.         mp->ctx == curctx &&
  3882.         mp->ctx->kind == MK_FUNCTION &&
  3883.         !mp->varstructflag)
  3884.         return 1;
  3885.             return (mp->kind == MK_CONST ||
  3886.             (!vars &&
  3887.              (mp->kind == MK_VAR || mp->kind == MK_VARREF ||
  3888.               mp->kind == MK_PARAM || mp->kind == MK_VARPARAM)));
  3889.  
  3890.         case EK_BICALL:
  3891.             return nosideeffects_func(ex);
  3892.  
  3893.         case EK_FUNCTION:
  3894.         case EK_SPCALL:
  3895.         case EK_ASSIGN:
  3896.         case EK_POSTINC:
  3897.         case EK_POSTDEC:
  3898.         case EK_HAT:
  3899.         case EK_INDEX:
  3900.             return 0;
  3901.  
  3902.         default:
  3903.             return 1;
  3904.     }
  3905. }
  3906.  
  3907.  
  3908.  
  3909. int exprdependsvar(ex, mp)
  3910. Expr *ex;
  3911. Meaning *mp;
  3912. {
  3913.     int i;
  3914.  
  3915.     i = ex->nargs;
  3916.     while (--i >= 0)
  3917.     if (exprdependsvar(ex->args[i], mp))
  3918.         return 1;
  3919.     switch (ex->kind) {
  3920.  
  3921.         case EK_VAR:
  3922.         return ((Meaning *)ex->val.i == mp);
  3923.  
  3924.     case EK_BICALL:
  3925.         if (nodependencies(ex, 1))
  3926.         return 0;
  3927.  
  3928.     /* fall through */
  3929.     case EK_FUNCTION:
  3930.     case EK_SPCALL:
  3931.         return (mp->ctx != curctx ||
  3932.             mp->ctx->kind != MK_FUNCTION ||
  3933.             mp->varstructflag);
  3934.  
  3935.     case EK_HAT:
  3936.         return 1;
  3937.  
  3938.     default:
  3939.         return 0;
  3940.     }
  3941. }
  3942.  
  3943.  
  3944. int exprdepends(ex, ex2)
  3945. Expr *ex, *ex2;     /* Expression ex somehow depends on value of ex2 */
  3946. {
  3947.     switch (ex2->kind) {
  3948.  
  3949.         case EK_VAR:
  3950.         return exprdependsvar(ex, (Meaning *)ex2->val.i);
  3951.  
  3952.     case EK_CONST:
  3953.     case EK_LONGCONST:
  3954.         return 0;
  3955.  
  3956.     case EK_INDEX:
  3957.     case EK_DOT:
  3958.         return exprdepends(ex, ex2->args[0]);
  3959.  
  3960.     default:
  3961.         return !nodependencies(ex, 1);
  3962.     }
  3963. }
  3964.  
  3965.  
  3966. int nosideeffects_func(ex)
  3967. Expr *ex;
  3968. {
  3969.     Meaning *mp;
  3970.     Symbol *sp;
  3971.  
  3972.     switch (ex->kind) {
  3973.  
  3974.         case EK_FUNCTION:
  3975.             mp = (Meaning *)ex->val.i;
  3976.             sp = findsymbol_opt(mp->name);
  3977.             return sp && (sp->flags & (NOSIDEEFF|DETERMF));
  3978.  
  3979.         case EK_BICALL:
  3980.             sp = findsymbol_opt(ex->val.s);
  3981.             return sp && (sp->flags & (NOSIDEEFF|DETERMF));
  3982.  
  3983.         default:
  3984.             return 0;
  3985.     }
  3986. }
  3987.  
  3988.  
  3989.  
  3990. int deterministic_func(ex)
  3991. Expr *ex;
  3992. {
  3993.     Meaning *mp;
  3994.     Symbol *sp;
  3995.  
  3996.     switch (ex->kind) {
  3997.  
  3998.         case EK_FUNCTION:
  3999.             mp = (Meaning *)ex->val.i;
  4000.             sp = findsymbol_opt(mp->name);
  4001.             return sp && (sp->flags & DETERMF);
  4002.  
  4003.         case EK_BICALL:
  4004.             sp = findsymbol_opt(ex->val.s);
  4005.             return sp && (sp->flags & DETERMF);
  4006.  
  4007.         default:
  4008.             return 0;
  4009.     }
  4010. }
  4011.  
  4012.  
  4013.  
  4014.  
  4015. int noargsideeffects(ex, mode)
  4016. Expr *ex;
  4017. int mode;
  4018. {
  4019.     int i;
  4020.  
  4021.     for (i = 0; i < ex->nargs; i++) {
  4022.         if (!nosideeffects(ex->args[i], mode))
  4023.             return 0;
  4024.     }
  4025.     return 1;
  4026. }
  4027.  
  4028.  
  4029. /* mode=0: liberal about bicall's: safe unless sideeffects_bicall() */
  4030. /* mode=1: conservative about bicall's: must be explicitly NOSIDEEFF */
  4031.  
  4032. int nosideeffects(ex, mode)
  4033. Expr *ex;
  4034. int mode;
  4035. {
  4036.     if (debug>2) { fprintf(outf,"nosideeffects("); dumpexpr(ex); fprintf(outf,")\n"); }
  4037.     if (!noargsideeffects(ex, mode))
  4038.         return 0;
  4039.     switch (ex->kind) {
  4040.  
  4041.         case EK_BICALL:
  4042.             if (mode == 0)
  4043.                 return !sideeffects_bicall(ex->val.s);
  4044.  
  4045.         /* fall through */
  4046.         case EK_FUNCTION:
  4047.             return nosideeffects_func(ex);
  4048.  
  4049.         case EK_SPCALL:
  4050.         case EK_ASSIGN:
  4051.         case EK_POSTINC:
  4052.         case EK_POSTDEC:
  4053.             return 0;
  4054.  
  4055.         default:
  4056.             return 1;
  4057.     }
  4058. }
  4059.  
  4060.  
  4061.  
  4062. int exproccurs(ex, ex2)
  4063. Expr *ex, *ex2;
  4064. {
  4065.     int i, count = 0;
  4066.  
  4067.     if (debug>2) { fprintf(outf,"exproccurs("); dumpexpr(ex); fprintf(outf,", "); dumpexpr(ex2); fprintf(outf,")\n"); }
  4068.     for (i = 0; i < ex->nargs; i++)
  4069.         count += exproccurs(ex->args[i], ex2);
  4070.     if (exprsame(ex, ex2, 0))
  4071.         count++;
  4072.     return count;
  4073. }
  4074.  
  4075.  
  4076.  
  4077. Expr *singlevar(ex)
  4078. Expr *ex;
  4079. {
  4080.     if (debug>2) { fprintf(outf,"singlevar("); dumpexpr(ex); fprintf(outf,")\n"); }
  4081.     switch (ex->kind) {
  4082.  
  4083.         case EK_VAR:
  4084.         case EK_MACARG:
  4085.             return ex;
  4086.  
  4087.         case EK_HAT:
  4088.         case EK_ADDR:
  4089.         case EK_DOT:
  4090.             return singlevar(ex->args[0]);
  4091.  
  4092.         case EK_INDEX:
  4093. #if 0
  4094.             if (!nodependencies(ex->args[1], 1))
  4095.                 return NULL;
  4096. #endif
  4097.             return singlevar(ex->args[0]);
  4098.  
  4099.     default:
  4100.         return NULL;
  4101.     }
  4102. }
  4103.  
  4104.  
  4105.  
  4106. /* Is "ex" a function which takes a return buffer pointer as its
  4107.    first argument, and returns a copy of that pointer? */
  4108.  
  4109. int structuredfunc(ex)
  4110. Expr *ex;
  4111. {
  4112.     Meaning *mp;
  4113.     Symbol *sp;
  4114.  
  4115.     if (debug>2) { fprintf(outf,"structuredfunc("); dumpexpr(ex); fprintf(outf,")\n"); }
  4116.     switch (ex->kind) {
  4117.  
  4118.         case EK_FUNCTION:
  4119.             mp = (Meaning *)ex->val.i;
  4120.             if (mp->isfunction && mp->cbase && mp->cbase->kind == MK_VARPARAM)
  4121.                 return 1;
  4122.             sp = findsymbol_opt(mp->name);
  4123.             return sp && (sp->flags & (STRUCTF|STRLAPF));
  4124.  
  4125.         case EK_BICALL:
  4126.             sp = findsymbol_opt(ex->val.s);
  4127.             return sp && (sp->flags & (STRUCTF|STRLAPF));
  4128.  
  4129.     default:
  4130.         return 0;
  4131.     }
  4132. }
  4133.  
  4134.  
  4135.  
  4136. int strlapfunc(ex)
  4137. Expr *ex;
  4138. {
  4139.     Meaning *mp;
  4140.     Symbol *sp;
  4141.  
  4142.     switch (ex->kind) {
  4143.  
  4144.         case EK_FUNCTION:
  4145.             mp = (Meaning *)ex->val.i;
  4146.             sp = findsymbol_opt(mp->name);
  4147.             return sp && (sp->flags & STRLAPF);
  4148.  
  4149.         case EK_BICALL:
  4150.             sp = findsymbol_opt(ex->val.s);
  4151.             return sp && (sp->flags & STRLAPF);
  4152.  
  4153.         default:
  4154.             return 0;
  4155.     }
  4156. }
  4157.  
  4158.  
  4159.  
  4160. Meaning *istempvar(ex)
  4161. Expr *ex;
  4162. {
  4163.     Meaning *mp;
  4164.  
  4165.     if (debug>2) { fprintf(outf,"istempvar("); dumpexpr(ex); fprintf(outf,")\n"); }
  4166.     if (ex->kind == EK_VAR) {
  4167.         mp = (Meaning *)ex->val.i;
  4168.         if (mp->istemporary)
  4169.             return mp;
  4170.         else
  4171.             return NULL;
  4172.     }
  4173.     return NULL;
  4174. }
  4175.  
  4176.  
  4177. Meaning *totempvar(ex)
  4178. Expr *ex;
  4179. {
  4180.     while (structuredfunc(ex))
  4181.     ex = ex->args[0];
  4182.     return istempvar(ex);
  4183. }
  4184.  
  4185.  
  4186.  
  4187. Meaning *isretvar(ex)
  4188. Expr *ex;
  4189. {
  4190.     Meaning *mp;
  4191.  
  4192.     if (debug>2) { fprintf(outf,"isretvar("); dumpexpr(ex); fprintf(outf,")\n"); }
  4193.     if (ex->kind == EK_HAT)
  4194.         ex = ex->args[0];
  4195.     if (ex->kind == EK_VAR) {
  4196.         mp = (Meaning *)ex->val.i;
  4197.         if (mp->ctx && mp->ctx->kind == MK_FUNCTION &&
  4198.             mp->ctx->isfunction && mp == mp->ctx->cbase)
  4199.             return mp;
  4200.         else
  4201.             return NULL;
  4202.     }
  4203.     return NULL;
  4204. }
  4205.  
  4206.  
  4207.  
  4208. Expr *bumpstring(ex, index, offset)
  4209. Expr *ex, *index;
  4210. int offset;
  4211. {
  4212.     if (checkconst(index, offset)) {
  4213.         freeexpr(index);
  4214.         return ex;
  4215.     }
  4216.     if (addindex != 0)
  4217.         ex = makeexpr_plus(makeexpr_addrstr(ex),
  4218.                makeexpr_minus(index, makeexpr_long(offset)));
  4219.     else
  4220.         ex = makeexpr_addr(makeexpr_index(ex, index, makeexpr_long(offset)));
  4221.     ex->val.type = tp_str255;
  4222.     return ex;
  4223. }
  4224.  
  4225.  
  4226.  
  4227. long po2m1(n)
  4228. int n;
  4229. {
  4230.     if (n == 32)
  4231.         return -1;
  4232.     else if (n == 31)
  4233.         return 0x7fffffff;
  4234.     else
  4235.         return (1<<n) - 1;
  4236. }
  4237.  
  4238.  
  4239.  
  4240. int isarithkind(kind)
  4241. enum exprkind kind;
  4242. {
  4243.     return (kind == EK_EQ || kind == EK_LT || kind == EK_GT ||
  4244.         kind == EK_NE || kind == EK_LE || kind == EK_GE ||
  4245.         kind == EK_PLUS || kind == EK_TIMES || kind == EK_DIVIDE ||
  4246.         kind == EK_DIV || kind == EK_MOD || kind == EK_NEG ||
  4247.         kind == EK_AND || kind == EK_OR || kind == EK_NOT ||
  4248.         kind == EK_BAND || kind == EK_BOR || kind == EK_BXOR ||
  4249.         kind == EK_LSH || kind == EK_RSH || kind == EK_BNOT ||
  4250.         kind == EK_FUNCTION || kind == EK_BICALL);
  4251. }
  4252.  
  4253.  
  4254. Expr *makeexpr_assign(a, b)
  4255. Expr *a, *b;
  4256. {
  4257.     int i, j;
  4258.     Expr *ex, *ex2, *ex3, **ep;
  4259.     Meaning *mp;
  4260.     Type *tp;
  4261.  
  4262.     if (debug>2) { fprintf(outf,"makeexpr_assign("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  4263.     if (stringtrunclimit > 0 &&
  4264.     a->val.type->kind == TK_STRING &&
  4265.     (i = strmax(a)) <= stringtrunclimit &&
  4266.     strmax(b) > i) {
  4267.     note("Possible string truncation in assignment [145]");
  4268.     }
  4269.     a = un_sign_extend(a);
  4270.     b = gentle_cast(b, a->val.type);
  4271.     if (b->kind == EK_BICALL && !strcmp(b->val.s, "sprintf") &&
  4272.          (mp = istempvar(b->args[0])) != NULL &&
  4273.          b->nargs >= 2 &&
  4274.          b->args[1]->kind == EK_CONST &&              /* all this handles string appending */
  4275.          b->args[1]->val.i > 2 &&                     /*   of the form, "s := s + ..." */
  4276.          !strncmp(b->args[1]->val.s, "%s", 2) &&
  4277.          exprsame(a, b->args[2], 1) &&
  4278.          nosideeffects(a, 0) &&
  4279.          (ex = singlevar(a)) != NULL) {
  4280.         ex2 = copyexpr(b);
  4281.         delfreearg(&ex2, 2);
  4282.         freeexpr(ex2->args[1]);
  4283.         ex2->args[1] = makeexpr_lstring(b->args[1]->val.s+2,
  4284.                                         b->args[1]->val.i-2);
  4285.         if (/*(ex = singlevar(a)) != NULL && */
  4286.            /* noargdependencies(ex2) && */ !exproccurs(ex2, ex)) {
  4287.             freeexpr(b);
  4288.             if (ex2->args[1]->val.i == 2 &&     /* s := s + s2 */
  4289.                 !strncmp(ex2->args[1]->val.s, "%s", 2)) {
  4290.                 canceltempvar(mp);
  4291.         tp = ex2->val.type;
  4292.                 return makeexpr_bicall_2("strcat", tp,
  4293.                                          makeexpr_addrstr(a), grabarg(ex2, 2));
  4294.             } else if (sprintflength(ex2, 0) >= 0) {    /* s := s + 's2' */
  4295.         tp = ex2->val.type;
  4296.                 return makeexpr_bicall_2("strcat", tp,
  4297.                                          makeexpr_addrstr(a),
  4298.                                          makeexpr_unsprintfify(ex2));
  4299.             } else {                            /* general case */
  4300.                 canceltempvar(mp);
  4301.                 freeexpr(ex2->args[0]);
  4302.                 ex = makeexpr_bicall_1("strlen", tp_int, copyexpr(a));
  4303.                 ex2->args[0] = bumpstring(a, ex, 0);
  4304.                 return ex2;
  4305.             }
  4306.         } else
  4307.             freeexpr(ex2);
  4308.     }
  4309.     if (b->kind == EK_BICALL && !strcmp(b->val.s, "sprintf") &&
  4310.          istempvar(b->args[0]) &&
  4311.          (ex = singlevar(a)) != NULL) {
  4312.         j = -1;     /* does lhs var appear exactly once on rhs? */
  4313.         for (i = 2; i < b->nargs; i++) {
  4314.             if (exprsame(b->args[i], ex, 1) && j < 0)
  4315.                 j = i;
  4316.             else if (exproccurs(b->args[i], ex))
  4317.                 break;
  4318.         }
  4319.         if (i == b->nargs && j > 0) {
  4320.             b->args[j] = makeexpr_bicall_2("strcpy", tp_str255,
  4321.                                            makeexpr_addrstr(b->args[0]),
  4322.                                            makeexpr_addrstr(b->args[j]));
  4323.             b->args[0] = makeexpr_addrstr(a);
  4324.             return b;
  4325.         }
  4326.     }
  4327.     if (structuredfunc(b) && (ex2 = singlevar(a)) != NULL) {
  4328.     ep = &b->args[0];
  4329.     i = strlapfunc(b);
  4330.     while (structuredfunc((ex = *ep))) {
  4331.         i = i && strlapfunc(ex);
  4332.         ep = &ex->args[0];
  4333.     }
  4334.     if ((mp = istempvar(ex)) != NULL &&
  4335.         (i || !exproccurs(b, ex2))) {
  4336.         canceltempvar(mp);
  4337.         freeexpr(*ep);
  4338.         *ep = makeexpr_addrstr(a);
  4339.         return b;
  4340.     }
  4341.     }
  4342.     if (a->val.type->kind == TK_PROCPTR &&
  4343.         (mp = istempprocptr(b)) != NULL &&
  4344.         nosideeffects(a, 0)) {
  4345.         freeexpr(b->args[0]->args[0]->args[0]);
  4346.         b->args[0]->args[0]->args[0] = copyexpr(a);
  4347.     if (b->nargs == 3) {
  4348.         freeexpr(b->args[1]->args[0]->args[0]);
  4349.         b->args[1]->args[0]->args[0] = a;
  4350.         delfreearg(&b, 2);
  4351.     } else {
  4352.         freeexpr(b->args[1]);
  4353.         b->args[1] = makeexpr_assign(makeexpr_dotq(a, "link", tp_anyptr),
  4354.                      makeexpr_nil());
  4355.     }
  4356.         canceltempvar(mp);
  4357.         return b;
  4358.     }
  4359.     if (a->val.type->kind == TK_PROCPTR &&
  4360.     (b->val.type->kind == TK_CPROCPTR ||
  4361.      checkconst(b, 0))) {
  4362.     ex = makeexpr_dotq(copyexpr(a), "proc", tp_anyptr);
  4363.     b = makeexpr_comma(makeexpr_assign(ex, b),
  4364.                makeexpr_assign(makeexpr_dotq(a, "link", tp_anyptr),
  4365.                        makeexpr_nil()));
  4366.     return b;
  4367.     }
  4368.     if (a->val.type->kind == TK_CPROCPTR &&
  4369.     (mp = istempprocptr(b)) != NULL &&
  4370.     nosideeffects(a, 0)) {
  4371.     freeexpr(b->args[0]->args[0]);
  4372.     b->args[0]->args[0] = a;
  4373.     if (b->nargs == 3)
  4374.         delfreearg(&b, 1);
  4375.     delfreearg(&b, 1);
  4376.     canceltempvar(mp);
  4377.     return b;
  4378.     }
  4379.     if (a->val.type->kind == TK_CPROCPTR &&
  4380.     b->val.type->kind == TK_PROCPTR) {
  4381.     b = makeexpr_dotq(b, "proc", tp_anyptr);
  4382.     }
  4383.     if (a->val.type->kind == TK_STRING) {
  4384.         if (b->kind == EK_CONST && b->val.i == 0 && !isretvar(a)) {
  4385.                 /* optimizing retvar would mess up "return" optimization */
  4386.             return makeexpr_assign(makeexpr_hat(a, 0),
  4387.                                    makeexpr_char(0));
  4388.         }
  4389.         a = makeexpr_addrstr(a);
  4390.         b = makeexpr_addrstr(b);
  4391.         return makeexpr_bicall_2("strcpy", a->val.type, a, b);
  4392.     }
  4393.     if (a->kind == EK_BICALL && !strcmp(a->val.s, "strlen")) {
  4394.         if (b->kind == EK_CAST &&
  4395.              ord_type(b->args[0]->val.type)->kind == TK_INTEGER) {
  4396.             b = grabarg(b, 0);
  4397.         }
  4398.         j = (b->kind == EK_PLUS &&      /* handle "s[0] := xxx" */
  4399.              b->args[0]->kind == EK_BICALL &&
  4400.              !strcmp(b->args[0]->val.s, "strlen") &&
  4401.              exprsame(a->args[0], b->args[0]->args[0], 0) &&
  4402.              isliteralconst(b->args[1], NULL) == 2);
  4403.         if (j && b->args[1]->val.i > 0 &&
  4404.                  b->args[1]->val.i <= 5) {     /* lengthening the string */
  4405.             a = grabarg(a, 0);
  4406.             i = b->args[1]->val.i;
  4407.             freeexpr(b);
  4408.             if (i == 1)
  4409.                 b = makeexpr_string(" ");
  4410.             else
  4411.                 b = makeexpr_lstring("12345", i);
  4412.             return makeexpr_bicall_2("strcat", a->val.type, a, b);
  4413.         } else {      /* maybe shortening the string */
  4414.             if (!j && !isconstexpr(b, NULL))
  4415.                 note("Modification of string length may translate incorrectly [146]");
  4416.             a = grabarg(a, 0);
  4417.             b = makeexpr_ord(b);
  4418.             return makeexpr_assign(makeexpr_index(a, b, NULL),
  4419.                                    makeexpr_char(0));
  4420.         }
  4421.     }
  4422.     if (a->val.type->kind == TK_ARRAY ||
  4423.     (a->val.type->kind == TK_PROCPTR && copystructs < 1) ||
  4424.     (a->val.type->kind == TK_RECORD &&
  4425.      (copystructs < 1 || a->val.type != b->val.type))) {
  4426.         ex = makeexpr_sizeof(copyexpr(a), 0);
  4427.         ex2 = makeexpr_sizeof(copyexpr(b), 0);
  4428.         if (!exprsame(ex, ex2, 1)) {
  4429.         if (a->val.type->kind == TK_ARRAY &&
  4430.         b->val.type->kind == TK_ARRAY &&
  4431.         a->val.type->basetype->kind == TK_CHAR &&
  4432.         (!ISCONST(ex->kind) || !ISCONST(ex2->kind) ||
  4433.          ex->val.i > ex2->val.i)) {
  4434.         ex = makeexpr_arglong(ex, (size_t_long != 0));
  4435.         ex2 = makeexpr_arglong(ex2, (size_t_long != 0));
  4436.         a = makeexpr_addrstr(a);
  4437.         b = makeexpr_addrstr(b);
  4438.         b = makeexpr_bicall_3("memcpy", a->val.type,
  4439.                       copyexpr(a), b, copyexpr(ex2));
  4440.         ex3 = copyexpr(ex2);
  4441.         return makeexpr_comma(b,
  4442.                       makeexpr_bicall_3("memset", a->val.type,
  4443.                             makeexpr_plus(a, ex3),
  4444.                             makeexpr_char(' '),
  4445.                             makeexpr_minus(ex,
  4446.                                        ex2)));
  4447.         } else if (!(a->val.type->kind == TK_ARRAY &&
  4448.              b->val.type->kind != TK_ARRAY))
  4449.         warning("Incompatible types or sizes [167]");
  4450.     }
  4451.         freeexpr(ex2);
  4452.         ex = makeexpr_arglong(ex, (size_t_long != 0));
  4453.         a = makeexpr_addrstr(a);
  4454.         b = makeexpr_addrstr(b);
  4455.         return makeexpr_bicall_3("memcpy", a->val.type, a, b, ex);
  4456.     }
  4457.     if (a->val.type->kind == TK_SET) {
  4458.         a = makeexpr_addrstr(a);
  4459.         b = makeexpr_addrstr(b);
  4460.         return makeexpr_bicall_2(setcopyname, a->val.type, a, b);
  4461.     }
  4462.     for (ep = &a; (ex3 = *ep); ) {
  4463.         if (ex3->kind == EK_COMMA)
  4464.             ep = &ex3->args[ex3->nargs-1];
  4465.         else if (ex3->kind == EK_CAST || ex3->kind == EK_ACTCAST)
  4466.             ep = &ex3->args[0];
  4467.         else
  4468.             break;
  4469.     }
  4470.     if (ex3->kind == EK_BICALL) {
  4471.         if (!strcmp(ex3->val.s, getbitsname)) {
  4472.         tp = ex3->args[0]->val.type;
  4473.         if (tp->kind == TK_ARRAY)
  4474.         ex3->args[0] = makeexpr_addr(ex3->args[0]);
  4475.             ex3->val.type = tp_void;
  4476.             if (checkconst(b, 0) && *clrbitsname) {
  4477.                 strchange(&ex3->val.s, clrbitsname);
  4478.             } else if (*putbitsname &&
  4479.                        ((ISCONST(b->kind) &&
  4480.                          (b->val.i | ~((1 << (1 << tp->escale)) - 1)) == -1) ||
  4481.                         checkconst(b, (1 << (1 << tp->escale)) - 1))) {
  4482.                 strchange(&ex3->val.s, putbitsname);
  4483.                 insertarg(ep, 2, makeexpr_arglong(makeexpr_ord(b), 0));
  4484.             } else {
  4485.                 b = makeexpr_arglong(makeexpr_ord(b), 0);
  4486.                 if (*storebitsname) {
  4487.                     strchange(&ex3->val.s, storebitsname);
  4488.                     insertarg(ep, 2, b);
  4489.                 } else {
  4490.                     if (exproccurs(b, ex3->args[0])) {
  4491.                         mp = makestmttempvar(b->val.type, name_TEMP);
  4492.                         ex2 = makeexpr_assign(makeexpr_var(mp), b);
  4493.                         b = makeexpr_var(mp);
  4494.                     } else
  4495.                         ex2 = NULL;
  4496.                     ex = copyexpr(ex3);
  4497.                     strchange(&ex3->val.s, putbitsname);
  4498.                     insertarg(&ex3, 2, b);
  4499.                     strchange(&ex->val.s, clrbitsname);
  4500.                     *ep = makeexpr_comma(ex2, makeexpr_comma(ex, ex3));
  4501.                 }
  4502.             }
  4503.             return a;
  4504.         } else if (!strcmp(ex3->val.s, getfbufname)) {
  4505.         ex3->val.type = tp_void;
  4506.         strchange(&ex3->val.s, putfbufname);
  4507.         insertarg(ep, 2, b);
  4508.         return a;
  4509.         } else if (!strcmp(ex3->val.s, chargetfbufname)) {
  4510.         ex3->val.type = tp_void;
  4511.         if (*charputfbufname) {
  4512.         strchange(&ex3->val.s, charputfbufname);
  4513.         insertarg(ep, 1, b);
  4514.         } else {
  4515.         strchange(&ex3->val.s, putfbufname);
  4516.         insertarg(ep, 1, makeexpr_type(ex3->val.type->basetype->basetype));
  4517.         insertarg(ep, 2, b);
  4518.         }
  4519.         return a;
  4520.         } else if (!strcmp(ex3->val.s, arraygetfbufname)) {
  4521.         ex3->val.type = tp_void;
  4522.         if (*arrayputfbufname) {
  4523.         strchange(&ex3->val.s, arrayputfbufname);
  4524.         insertarg(ep, 1, b);
  4525.         } else {
  4526.         strchange(&ex3->val.s, putfbufname);
  4527.         insertarg(ep, 1, makeexpr_type(ex3->val.type->basetype->basetype));
  4528.         insertarg(ep, 2, b);
  4529.         }
  4530.         return a;
  4531.     }
  4532.     }
  4533.     while (a->kind == EK_CAST || a->kind == EK_ACTCAST ||
  4534.        a->kind == EK_LITCAST) {
  4535.     if (a->kind == EK_LITCAST) {
  4536.         b = makeexpr_cast(b, a->args[1]->val.type);
  4537.         a = grabarg(a, 1);
  4538.     } else if (ansiC < 2 ||    /* in GNU C, a cast is an lvalue */
  4539.            isarithkind(a->args[0]->kind) ||
  4540.            (a->val.type->kind == TK_POINTER &&
  4541.             a->args[0]->val.type->kind == TK_POINTER)) {
  4542.         if (a->kind == EK_CAST)
  4543.         b = makeexpr_cast(b, a->args[0]->val.type);
  4544.         else
  4545.         b = makeexpr_actcast(b, a->args[0]->val.type);
  4546.         a = grabarg(a, 0);
  4547.     } else
  4548.         break;
  4549.     }
  4550.     if (a->kind == EK_NEG)
  4551.     return makeexpr_assign(grabarg(a, 0), makeexpr_neg(b));
  4552.     if (a->kind == EK_NOT)
  4553.     return makeexpr_assign(grabarg(a, 0), makeexpr_not(b));
  4554.     if (a->kind == EK_BNOT)
  4555.     return makeexpr_assign(grabarg(a, 0),
  4556.                    makeexpr_un(EK_BNOT, b->val.type, b));
  4557.     if (a->kind == EK_PLUS) {
  4558.     for (i = 0; i < a->nargs && a->nargs > 1; ) {
  4559.         if (isconstantexpr(a->args[i])) {
  4560.         b = makeexpr_minus(b, a->args[i]);
  4561.         deletearg(&a, i);
  4562.         } else
  4563.         i++;
  4564.     }
  4565.     if (a->nargs == 1)
  4566.         return makeexpr_assign(grabarg(a, 0), b);
  4567.     }
  4568.     if (a->kind == EK_TIMES) {
  4569.     for (i = 0; i < a->nargs && a->nargs > 1; ) {
  4570.         if (isconstantexpr(a->args[i])) {
  4571.         if (a->val.type->kind == TK_REAL)
  4572.             b = makeexpr_divide(b, a->args[i]);
  4573.         else {
  4574.             if (ISCONST(b->kind) && ISCONST(a->args[i]->kind) &&
  4575.             (b->val.i % a->args[i]->val.i) != 0) {
  4576.             break;
  4577.             }
  4578.             b = makeexpr_div(b, a->args[i]);
  4579.         }
  4580.         deletearg(&a, i);
  4581.         } else
  4582.         i++;
  4583.     }
  4584.     if (a->nargs == 1)
  4585.         return makeexpr_assign(grabarg(a, 0), b);
  4586.     }
  4587.     if ((a->kind == EK_DIVIDE || a->kind == EK_DIV) &&
  4588.      isconstantexpr(a->args[1])) {
  4589.     b = makeexpr_times(b, a->args[1]);
  4590.     return makeexpr_assign(a->args[0], b);
  4591.     }
  4592.     if (a->kind == EK_LSH && isconstantexpr(a->args[1])) {
  4593.     if (ISCONST(b->kind) && ISCONST(a->args[1]->kind)) {
  4594.         if ((b->val.i & ((1L << a->args[1]->val.i)-1)) == 0) {
  4595.         b->val.i >>= a->args[1]->val.i;
  4596.         return makeexpr_assign(grabarg(a, 0), b);
  4597.         }
  4598.     } else {
  4599.         b = makeexpr_bin(EK_RSH, b->val.type, b, a->args[1]);
  4600.         return makeexpr_assign(a->args[0], b);
  4601.     }
  4602.     }
  4603.     if (a->kind == EK_RSH && isconstantexpr(a->args[1])) {
  4604.     if (ISCONST(b->kind) && ISCONST(a->args[1]->kind))
  4605.         b->val.i <<= a->args[1]->val.i;
  4606.     else
  4607.         b = makeexpr_bin(EK_LSH, b->val.type, b, a->args[1]);
  4608.     return makeexpr_assign(a->args[0], b);
  4609.     }
  4610.     if (isarithkind(a->kind))
  4611.     warning("Invalid assignment [168]");
  4612.     return makeexpr_bin(EK_ASSIGN, a->val.type, a, makeexpr_unlongcast(b));
  4613. }
  4614.  
  4615.  
  4616.  
  4617.  
  4618. Expr *makeexpr_comma(a, b)
  4619. Expr *a, *b;
  4620. {
  4621.     Type *type;
  4622.  
  4623.     if (!a || nosideeffects(a, 1))
  4624.         return b;
  4625.     if (!b)
  4626.         return a;
  4627.     type = b->val.type;
  4628.     a = commute(a, b, EK_COMMA);
  4629.     a->val.type = type;
  4630.     return a;
  4631. }
  4632.  
  4633.  
  4634.  
  4635.  
  4636. int strmax(ex)
  4637. Expr *ex;
  4638. {
  4639.     Meaning *mp;
  4640.     long smin, smax;
  4641.     Value val;
  4642.     Type *type;
  4643.  
  4644.     type = ex->val.type;
  4645.     if (type->kind == TK_POINTER)
  4646.         type = type->basetype;
  4647.     if (type->kind == TK_CHAR)
  4648.         return 1;
  4649.     if (type->kind == TK_ARRAY && type->basetype->kind == TK_CHAR) {
  4650.         if (ord_range(type->indextype, &smin, &smax))
  4651.             return smax - smin + 1;
  4652.         else
  4653.             return stringceiling;
  4654.     }
  4655.     if (type->kind != TK_STRING) {
  4656.         intwarning("strmax", "strmax encountered a non-string value [169]");
  4657.         return stringceiling;
  4658.     }
  4659.     if (ex->kind == EK_CONST)
  4660.         return ex->val.i;
  4661.     if (ex->kind == EK_VAR && foldstrconsts != 0 &&
  4662.         (mp = (Meaning *)(ex->val.i))->kind == MK_CONST && mp->val.type)
  4663.         return mp->val.i;
  4664.     if (ex->kind == EK_BICALL) {
  4665.     if (!strcmp(ex->val.s, strsubname)) {
  4666.         if (isliteralconst(ex->args[3], &val) && val.type)
  4667.         return val.i;
  4668.     }
  4669.     }
  4670.     if (ord_range(type->indextype, NULL, &smax))
  4671.         return smax;
  4672.     else
  4673.         return stringceiling;
  4674. }
  4675.  
  4676.  
  4677.  
  4678.  
  4679. int strhasnull(val)
  4680. Value val;
  4681. {
  4682.     int i;
  4683.  
  4684.     for (i = 0; i < val.i; i++) {
  4685.         if (!val.s[i])
  4686.             return (i == val.i-1) ? 1 : 2;
  4687.     }
  4688.     return 0;
  4689. }
  4690.  
  4691.  
  4692.  
  4693. int istempsprintf(ex)
  4694. Expr *ex;
  4695. {
  4696.     return (ex->kind == EK_BICALL && !strcmp(ex->val.s, "sprintf") &&
  4697.             ex->nargs >= 2 &&
  4698.             istempvar(ex->args[0]) &&
  4699.             ex->args[1]->kind == EK_CONST &&
  4700.             ex->args[1]->val.type->kind == TK_STRING);
  4701. }
  4702.  
  4703.  
  4704.  
  4705. Expr *makeexpr_sprintfify(ex)
  4706. Expr *ex;
  4707. {
  4708.     Meaning *tvar;
  4709.     char stringbuf[500];
  4710.     char *cp, ch;
  4711.     int j, nnulls;
  4712.     Expr *ex2;
  4713.  
  4714.     if (debug>2) { fprintf(outf,"makeexpr_sprintfify("); dumpexpr(ex); fprintf(outf,")\n"); }
  4715.     if (istempsprintf(ex))
  4716.         return ex;
  4717.     ex = makeexpr_stringcast(ex);
  4718.     tvar = makestmttempvar(tp_str255, name_STRING);
  4719.     if (ex->kind == EK_CONST && ex->val.type->kind == TK_STRING) {
  4720.         cp = stringbuf;
  4721.         nnulls = 0;
  4722.         for (j = 0; j < ex->val.i; j++) {
  4723.             ch = ex->val.s[j];
  4724.             if (!ch) {
  4725.                 if (j < ex->val.i-1)
  4726.                     note("Null character in sprintf control string [147]");
  4727.                 else
  4728.                     note("Null character at end of sprintf control string [148]");
  4729.                 if (keepnulls) {
  4730.                     *cp++ = '%';
  4731.                     *cp++ = 'c';
  4732.                     nnulls++;
  4733.                 }
  4734.             } else {
  4735.                 *cp++ = ch;
  4736.                 if (ch == '%')
  4737.                     *cp++ = ch;
  4738.             }
  4739.         }
  4740.         *cp = 0;
  4741.         ex = makeexpr_bicall_2("sprintf", tp_str255,
  4742.                                makeexpr_var(tvar),
  4743.                                makeexpr_string(stringbuf));
  4744.         while (--nnulls >= 0)
  4745.             insertarg(&ex, 2, makeexpr_char(0));
  4746.         return ex;
  4747.     } else if (ex->val.type->kind == TK_ARRAY &&
  4748.                ex->val.type->basetype->kind == TK_CHAR) {
  4749.         ex2 = arraysize(ex->val.type, 0);
  4750.         return cleansprintf(
  4751.                 makeexpr_bicall_4("sprintf", tp_str255,
  4752.                                   makeexpr_var(tvar),
  4753.                                   makeexpr_string("%.*s"),
  4754.                                   ex2,
  4755.                                   makeexpr_addrstr(ex)));
  4756.     } else {
  4757.         if (ord_type(ex->val.type)->kind == TK_CHAR)
  4758.             cp = "%c";
  4759.         else if (ex->val.type->kind == TK_STRING)
  4760.             cp = "%s";
  4761.         else {
  4762.             warning("Mixing non-strings with strings [170]");
  4763.             return ex;
  4764.         }
  4765.         return makeexpr_bicall_3("sprintf", tp_str255,
  4766.                                  makeexpr_var(tvar),
  4767.                                  makeexpr_string(cp),
  4768.                                  ex);
  4769.     }
  4770. }
  4771.  
  4772.  
  4773.  
  4774. Expr *makeexpr_unsprintfify(ex)
  4775. Expr *ex;
  4776. {
  4777.     char stringbuf[500];
  4778.     char *cp, ch;
  4779.     int i;
  4780.  
  4781.     if (debug>2) { fprintf(outf,"makeexpr_unsprintfify("); dumpexpr(ex); fprintf(outf,")\n"); }
  4782.     if (!istempsprintf(ex))
  4783.         return ex;
  4784.     canceltempvar(istempvar(ex->args[0]));
  4785.     for (i = 2; i < ex->nargs; i++) {
  4786.         if (ex->args[i]->val.type->kind != TK_CHAR ||
  4787.             !checkconst(ex, 0))
  4788.             return ex;
  4789.     }
  4790.     cp = stringbuf;
  4791.     for (i = 0; i < ex->args[1]->val.i; i++) {
  4792.         ch = ex->args[1]->val.s[i];
  4793.         *cp++ = ch;
  4794.         if (ch == '%') {
  4795.             if (++i == ex->args[1]->val.i)
  4796.                 return ex;
  4797.             ch = ex->args[1]->val.s[i];
  4798.             if (ch == 'c')
  4799.                 cp[-1] = 0;
  4800.             else if (ch != '%')
  4801.                 return ex;
  4802.         }
  4803.     }
  4804.     freeexpr(ex);
  4805.     return makeexpr_lstring(stringbuf, cp - stringbuf);
  4806. }
  4807.  
  4808.  
  4809.  
  4810. /* Returns >= 0 iff unsprintfify would return a string constant */
  4811.  
  4812. int sprintflength(ex, allownulls)
  4813. Expr *ex;
  4814. int allownulls;
  4815. {
  4816.     int i, len;
  4817.  
  4818.     if (!istempsprintf(ex))
  4819.         return -1;
  4820.     for (i = 2; i < ex->nargs; i++) {
  4821.         if (!allownulls ||
  4822.             ex->args[i]->val.type->kind != TK_CHAR ||
  4823.             !checkconst(ex, 0))
  4824.             return -1;
  4825.     }
  4826.     len = 0;
  4827.     for (i = 0; i < ex->args[1]->val.i; i++) {
  4828.         len++;
  4829.         if (ex->args[1]->val.s[i] == '%') {
  4830.             if (++i == ex->args[1]->val.i)
  4831.                 return -1;
  4832.             if (ex->args[1]->val.s[i] != 'c' &&
  4833.                 ex->args[1]->val.s[i] != '%')
  4834.                 return -1;
  4835.         }
  4836.     }
  4837.     return len;
  4838. }
  4839.  
  4840.  
  4841.  
  4842. Expr *makeexpr_concat(a, b, usesprintf)
  4843. Expr *a, *b;
  4844. int usesprintf;
  4845. {
  4846.     int i, ii, j, len, nargs;
  4847.     Type *type;
  4848.     Meaning *mp, *tvar;
  4849.     Expr *ex, *args[2];
  4850.     int akind[2];
  4851.     Value val, val1, val2;
  4852.     char formatstr[300];
  4853.  
  4854.     if (debug>2) { fprintf(outf,"makeexpr_concat("); dumpexpr(a); fprintf(outf,", "); dumpexpr(b); fprintf(outf,")\n"); }
  4855.     if (!a)
  4856.         return b;
  4857.     if (!b)
  4858.         return a;
  4859.     a = makeexpr_stringcast(a);
  4860.     b = makeexpr_stringcast(b);
  4861.     if (checkconst(a, 0)) {
  4862.         freeexpr(a);
  4863.         return b;
  4864.     }
  4865.     if (checkconst(b, 0)) {
  4866.         freeexpr(b);
  4867.         return a;
  4868.     }
  4869.     len = strmax(a) + strmax(b);
  4870.     type = makestringtype(len);
  4871.     if (a->kind == EK_CONST && b->kind == EK_CONST) {
  4872.         val1 = a->val;
  4873.         val2 = b->val;
  4874.         val.i = val1.i + val2.i;
  4875.         val.s = ALLOC(val.i+1, char, literals);
  4876.     val.s[val.i] = 0;
  4877.         val.type = type;
  4878.         memcpy(val.s, val1.s, val1.i);
  4879.         memcpy(val.s + val1.i, val2.s, val2.i);
  4880.         freeexpr(a);
  4881.         freeexpr(b);
  4882.         return makeexpr_val(val);
  4883.     }
  4884.     tvar = makestmttempvar(type, name_STRING);
  4885.     if (sprintf_value != 2 || usesprintf) {
  4886.         nargs = 2;                 /* Generate a call to sprintf(), unfolding */
  4887.         args[0] = a;               /*  nested sprintf()'s. */
  4888.         args[1] = b;
  4889.         *formatstr = 0;
  4890.         for (i = 0; i < 2; i++) {
  4891. #if 1
  4892.             ex = args[i] = makeexpr_sprintfify(args[i]);
  4893.         if (!ex->args[1] || !ex->args[1]->val.s)
  4894.         intwarning("makeexpr_concat", "NULL in ex->args[1]");
  4895.         else
  4896.         strncat(formatstr, ex->args[1]->val.s, ex->args[1]->val.i);
  4897.             canceltempvar(istempvar(ex->args[0]));
  4898.             nargs += (ex->nargs - 2);
  4899.             akind[i] = 0;      /* now obsolete */
  4900. #else
  4901.             ex = args[i];
  4902.             if (ex->kind == EK_CONST)
  4903.                 ex = makeexpr_sprintfify(ex);
  4904.             if (istempsprintf(ex)) {
  4905.                 strncat(formatstr, ex->args[1]->val.s, ex->args[1]->val.i);
  4906.                 canceltempvar(istempvar(ex->args[0]));
  4907.                 nargs += (ex->nargs - 2);
  4908.                 akind[i] = 0;
  4909.             } else {
  4910.                 strcat(formatstr, "%s");
  4911.                 nargs++;
  4912.                 akind[i] = 1;
  4913.             }
  4914. #endif
  4915.         }
  4916.         ex = makeexpr(EK_BICALL, nargs);
  4917.         ex->val.type = type;
  4918.         ex->val.s = stralloc("sprintf");
  4919.         ex->args[0] = makeexpr_var(tvar);
  4920.         ex->args[1] = makeexpr_string(formatstr);
  4921.         j = 2;
  4922.         for (i = 0; i < 2; i++) {
  4923.             switch (akind[i]) {
  4924.                 case 0:   /* flattened sub-sprintf */
  4925.                     for (ii = 2; ii < args[i]->nargs; ii++)
  4926.                         ex->args[j++] = copyexpr(args[i]->args[ii]);
  4927.                     freeexpr(args[i]);
  4928.                     break;
  4929.                 case 1:   /* included string expr */
  4930.                     ex->args[j++] = args[i];
  4931.                     break;
  4932.             }
  4933.         }
  4934.     } else {
  4935.         ex = a;
  4936.         while (ex->kind == EK_BICALL && !strcmp(ex->val.s, "strcat"))
  4937.             ex = ex->args[0];
  4938.         if (ex->kind == EK_BICALL && !strcmp(ex->val.s, "strcpy") &&
  4939.             (mp = istempvar(ex->args[0])) != NULL) {
  4940.             canceltempvar(mp);
  4941.             freeexpr(ex->args[0]);
  4942.             ex->args[0] = makeexpr_var(tvar);
  4943.         } else {
  4944.             a = makeexpr_bicall_2("strcpy", type, makeexpr_var(tvar), a);
  4945.         }
  4946.         ex = makeexpr_bicall_2("strcat", type, a, b);
  4947.     }
  4948.     if (debug>2) { fprintf(outf,"makeexpr_concat returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  4949.     return ex;
  4950. }
  4951.  
  4952.  
  4953.  
  4954. Expr *cleansprintf(ex)
  4955. Expr *ex;
  4956. {
  4957.     int fidx, i, j, k, len, changed = 0;
  4958.     char *cp, *bp;
  4959.     char fmtbuf[300];
  4960.  
  4961.     if (ex->kind != EK_BICALL)
  4962.     return ex;
  4963.     if (!strcmp(ex->val.s, "printf"))
  4964.     fidx = 0;
  4965.     else if (!strcmp(ex->val.s, "sprintf") ||
  4966.          !strcmp(ex->val.s, "fprintf"))
  4967.     fidx = 1;
  4968.     else
  4969.     return ex;
  4970.     len = ex->args[fidx]->val.i;
  4971.     cp = ex->args[fidx]->val.s;      /* printf("%*d",17,x)  =>  printf("%17d",x) */
  4972.     bp = fmtbuf;
  4973.     j = fidx + 1;
  4974.     for (i = 0; i < len; i++) {
  4975.         *bp++ = cp[i];
  4976.         if (cp[i] == '%') {
  4977.         if (cp[i+1] == 's' && ex->args[j]->kind == EK_CONST) {
  4978.         bp--;
  4979.         for (k = 0; k < ex->args[j]->val.i; k++)
  4980.             *bp++ = ex->args[j]->val.s[k];
  4981.         delfreearg(&ex, j);
  4982.         changed = 1;
  4983.         i++;
  4984.         continue;
  4985.         }
  4986.             for (i++; i < len &&
  4987.                       !(isalpha(cp[i]) && cp[i] != 'l'); i++) {
  4988.                 if (cp[i] == '*') {
  4989.                     if (isliteralconst(ex->args[j], NULL) == 2) {
  4990.                         sprintf(bp, "%ld", ex->args[j]->val.i);
  4991.                         bp += strlen(bp);
  4992.                         delfreearg(&ex, j);
  4993.                         changed = 1;
  4994.                     } else {
  4995.                         *bp++ = cp[i];
  4996.                         j++;
  4997.                     }
  4998.                 } else
  4999.                     *bp++ = cp[i];
  5000.             }
  5001.             if (i < len)
  5002.                 *bp++ = cp[i];
  5003.             j++;
  5004.         }
  5005.     }
  5006.     *bp = 0;
  5007.     if (changed) {
  5008.         freeexpr(ex->args[fidx]);
  5009.         ex->args[fidx] = makeexpr_string(fmtbuf);
  5010.     }
  5011.     return ex;
  5012. }
  5013.  
  5014.  
  5015.  
  5016. Expr *makeexpr_substring(vex, ex, exi, exj)
  5017. Expr *vex, *ex, *exi, *exj;
  5018. {
  5019.     exi = makeexpr_unlongcast(exi);
  5020.     exj = makeexpr_longcast(exj, 0);
  5021.     ex = bumpstring(ex, exi, 1);
  5022.     return cleansprintf(makeexpr_bicall_4("sprintf", tp_str255,
  5023.                                           vex,
  5024.                                           makeexpr_string("%.*s"),
  5025.                                           exj,
  5026.                                           ex));
  5027. }
  5028.  
  5029.  
  5030.  
  5031.  
  5032. Expr *makeexpr_dot(ex, mp)
  5033. Expr *ex;
  5034. Meaning *mp;
  5035. {
  5036.     Type *ot1, *ot2;
  5037.     Expr *ex2, *ex3, *nex;
  5038.     Meaning *tvar;
  5039.  
  5040.     if (ex->kind == EK_FUNCTION && copystructfuncs > 0) {
  5041.         tvar = makestmttempvar(ex->val.type, name_TEMP);
  5042.         ex2 = makeexpr_assign(makeexpr_var(tvar), ex);
  5043.         ex = makeexpr_var(tvar);
  5044.     } else
  5045.         ex2 = NULL;
  5046.     if (mp->constdefn) {
  5047.         nex = makeexpr(EK_MACARG, 0);
  5048.         nex->val.type = tp_integer;
  5049.         ex3 = replaceexprexpr(copyexpr(mp->constdefn), nex, ex, 0);
  5050.         freeexpr(ex);
  5051.         freeexpr(nex);
  5052.         ex = gentle_cast(ex3, mp->val.type);
  5053.     } else {
  5054.         ex = makeexpr_un(EK_DOT, mp->type, ex);
  5055.         ex->val.i = (long)mp;
  5056.         ot1 = ord_type(mp->type);
  5057.         ot2 = ord_type(mp->val.type);
  5058.         if (ot1->kind != ot2->kind && ot2->kind == TK_ENUM && ot2->meaning && useenum)
  5059.             ex = makeexpr_cast(ex, mp->val.type);
  5060.         else if (mp->val.i && !hassignedchar &&
  5061.          (mp->type == tp_sint || mp->type == tp_abyte)) {
  5062.             if (*signextname) {
  5063.                 ex = makeexpr_bicall_2(signextname, tp_integer,
  5064.                                        ex, makeexpr_long(mp->val.i));
  5065.             } else
  5066.                 note(format_s("Unable to sign-extend field %s [149]", mp->name));
  5067.         }
  5068.     }
  5069.     ex->val.type = mp->val.type;
  5070.     return makeexpr_comma(ex2, ex);
  5071. }
  5072.  
  5073.  
  5074.  
  5075. Expr *makeexpr_dotq(ex, name, type)
  5076. Expr *ex;
  5077. char *name;
  5078. Type *type;
  5079. {
  5080.     ex = makeexpr_un(EK_DOT, type, ex);
  5081.     ex->val.s = stralloc(name);
  5082.     return ex;
  5083. }
  5084.  
  5085.  
  5086.  
  5087. Expr *strmax_func(ex)
  5088. Expr *ex;
  5089. {
  5090.     Meaning *mp;
  5091.     Expr *ex2;
  5092.     Type *type;
  5093.  
  5094.     type = ex->val.type;
  5095.     if (type->kind == TK_POINTER) {
  5096.         intwarning("strmax_func", "got a pointer instead of a string [171]");
  5097.         type = type->basetype;
  5098.     }
  5099.     if (type->kind == TK_CHAR)
  5100.         return makeexpr_long(1);
  5101.     if (type->kind != TK_STRING) {
  5102.         warning("STRMAX of non-string value [172]");
  5103.         return makeexpr_long(stringceiling);
  5104.     }
  5105.     if (ex->kind == EK_CONST)
  5106.     return makeexpr_long(ex->val.i);
  5107.     if (ex->kind == EK_VAR &&
  5108.     (mp = (Meaning *)ex->val.i)->kind == MK_CONST &&
  5109.     mp->type == tp_str255 && mp->val.type)
  5110.     return makeexpr_long(mp->val.i);
  5111.     if (ex->kind == EK_VAR &&
  5112.         (mp = (Meaning *)ex->val.i)->kind == MK_VARPARAM &&
  5113.         mp->type == tp_strptr) {
  5114.     if (mp->anyvarflag) {
  5115.         if (mp->ctx != curctx && mp->ctx->kind == MK_FUNCTION)
  5116.         note(format_s("Reference to STRMAX of parent proc's \"%s\" must be fixed [150]",
  5117.                   mp->name));
  5118.         return makeexpr_name(format_s(name_STRMAX, mp->name), tp_int);
  5119.     } else
  5120.         note(format_s("STRMAX of \"%s\" wants VarStrings=1 [151]", mp->name));
  5121.     }
  5122.     ord_range_expr(type->indextype, NULL, &ex2);
  5123.     return copyexpr(ex2);
  5124. }
  5125.  
  5126.  
  5127.  
  5128.  
  5129. Expr *makeexpr_nil()
  5130. {
  5131.     Expr *ex;
  5132.  
  5133.     ex = makeexpr(EK_CONST, 0);
  5134.     ex->val.type = tp_anyptr;
  5135.     ex->val.i = 0;
  5136.     ex->val.s = NULL;
  5137.     return ex;
  5138. }
  5139.  
  5140.  
  5141.  
  5142. Expr *makeexpr_ctx(ctx)
  5143. Meaning *ctx;
  5144. {
  5145.     Expr *ex;
  5146.  
  5147.     ex = makeexpr(EK_CTX, 0);
  5148.     ex->val.type = tp_text;     /* handy pointer type */
  5149.     ex->val.i = (long)ctx;
  5150.     return ex;
  5151. }
  5152.  
  5153.  
  5154.  
  5155.  
  5156. Expr *force_signed(ex)
  5157. Expr *ex;
  5158. {
  5159.     Type *tp;
  5160.  
  5161.     if (isliteralconst(ex, NULL) == 2 && ex->nargs == 0)
  5162.         return ex;
  5163.     tp = true_type(ex);
  5164.     if (tp == tp_ushort || tp == tp_ubyte || tp == tp_uchar)
  5165.     return makeexpr_cast(ex, tp_sshort);
  5166.     else if (tp == tp_unsigned || tp == tp_uint) {
  5167.     if (exprlongness(ex) < 0)
  5168.         return makeexpr_cast(ex, tp_sint);
  5169.     else
  5170.         return makeexpr_cast(ex, tp_integer);
  5171.     }
  5172.     return ex;
  5173. }
  5174.  
  5175.  
  5176.  
  5177. Expr *force_unsigned(ex)
  5178. Expr *ex;
  5179. {
  5180.     Type *tp;
  5181.  
  5182.     if (isliteralconst(ex, NULL) == 2 && !expr_is_neg(ex))
  5183.         return ex;
  5184.     tp = true_type(ex);
  5185.     if (tp == tp_unsigned || tp == tp_uint || tp == tp_ushort ||
  5186.     tp == tp_ubyte || tp == tp_uchar)
  5187.         return ex;
  5188.     if (tp->kind == TK_CHAR)
  5189.     return makeexpr_actcast(ex, tp_uchar);
  5190.     else if (exprlongness(ex) < 0)
  5191.         return makeexpr_cast(ex, tp_uint);
  5192.     else
  5193.         return makeexpr_cast(ex, tp_unsigned);
  5194. }
  5195.  
  5196.  
  5197.  
  5198.  
  5199. #define CHECKSIZE(size) (((size) > 0 && (size)%charsize == 0) ? (size)/charsize : 0)
  5200.  
  5201. long type_sizeof(type, pasc)
  5202. Type *type;
  5203. int pasc;
  5204. {
  5205.     long s1, smin, smax;
  5206.     int charsize = (sizeof_char) ? sizeof_char : CHAR_BIT;      /* from <limits.h> */
  5207.  
  5208.     switch (type->kind) {
  5209.  
  5210.         case TK_INTEGER:
  5211.             if (type == tp_integer ||
  5212.                 type == tp_unsigned)
  5213.                 return pasc ? 4 : CHECKSIZE(sizeof_integer);
  5214.             else
  5215.                 return pasc ? 2 : CHECKSIZE(sizeof_short);
  5216.  
  5217.         case TK_CHAR:
  5218.         case TK_BOOLEAN:
  5219.             return 1;
  5220.  
  5221.         case TK_SUBR:
  5222.             type = findbasetype(type, ODECL_NOPRES);
  5223.             if (pasc) {
  5224.                 if (type == tp_integer || type == tp_unsigned)
  5225.                     return 4;
  5226.                 else
  5227.                     return 2;
  5228.             } else {
  5229.                 if (type == tp_abyte || type == tp_ubyte || type == tp_sbyte)
  5230.                     return 1;
  5231.                 else if (type == tp_ushort || type == tp_sshort)
  5232.                     return CHECKSIZE(sizeof_short);
  5233.                 else
  5234.                     return CHECKSIZE(sizeof_integer);
  5235.             }
  5236.  
  5237.         case TK_POINTER:
  5238.             return pasc ? 4 : CHECKSIZE(sizeof_pointer);
  5239.  
  5240.         case TK_REAL:
  5241.         if (type == tp_longreal)
  5242.         return pasc ? (which_lang == LANG_TURBO ? 6 : 8) : CHECKSIZE(sizeof_double);
  5243.         else
  5244.         return pasc ? 4 : CHECKSIZE(sizeof_float);
  5245.  
  5246.         case TK_ENUM:
  5247.         if (!pasc)
  5248.         return CHECKSIZE(sizeof_enum);
  5249.         type = findbasetype(type, ODECL_NOPRES);
  5250.             return type->kind != TK_ENUM ? type_sizeof(type, pasc)
  5251.            : CHECKSIZE(pascalenumsize);
  5252.  
  5253.         case TK_SMALLSET:
  5254.         case TK_SMALLARRAY:
  5255.             return pasc ? 0 : type_sizeof(type->basetype, pasc);
  5256.  
  5257.         case TK_ARRAY:
  5258.             s1 = type_sizeof(type->basetype, pasc);
  5259.             if (s1 && ord_range(type->indextype, &smin, &smax))
  5260.                 return s1 * (smax - smin + 1);
  5261.             else
  5262.                 return 0;
  5263.  
  5264.         case TK_RECORD:
  5265.             if (pasc && type->meaning) {
  5266.                 if (!strcmp(type->meaning->sym->name, "NA_WORD"))
  5267.                     return 2;
  5268.                 else if (!strcmp(type->meaning->sym->name, "NA_LONGWORD"))
  5269.                     return 4;
  5270.                 else if (!strcmp(type->meaning->sym->name, "NA_QUADWORD"))
  5271.                     return 8;
  5272.                 else
  5273.                     return 0;
  5274.             } else
  5275.                 return 0;
  5276.  
  5277.         default:
  5278.             return 0;
  5279.     }
  5280. }
  5281.  
  5282.  
  5283.  
  5284. Static Value eval_expr_either(ex, pasc)
  5285. Expr *ex;
  5286. int pasc;
  5287. {
  5288.     Value val, val2;
  5289.     Meaning *mp;
  5290.     int i;
  5291.  
  5292.     if (debug>2) { fprintf(outf,"eval_expr("); dumpexpr(ex); fprintf(outf,")\n"); }
  5293.     switch (ex->kind) {
  5294.  
  5295.         case EK_CONST:
  5296.         case EK_LONGCONST:
  5297.             return ex->val;
  5298.  
  5299.         case EK_VAR:
  5300.             mp = (Meaning *) ex->val.i;
  5301.             if (mp->kind == MK_CONST &&
  5302.                 (foldconsts != 0 ||
  5303.                  mp == mp_maxint || mp == mp_minint))
  5304.                 return mp->val;
  5305.             break;
  5306.  
  5307.         case EK_SIZEOF:
  5308.             i = type_sizeof(ex->args[0]->val.type, pasc);
  5309.             if (i)
  5310.                 return make_ord(tp_integer, i);
  5311.             break;
  5312.  
  5313.         case EK_PLUS:
  5314.             val = eval_expr_either(ex->args[0], pasc);
  5315.             if (!val.type || ord_type(val.type)->kind != TK_INTEGER)
  5316.                 val.type = NULL;
  5317.             for (i = 1; val.type && i < ex->nargs; i++) {
  5318.                 val2 = eval_expr_either(ex->args[i], pasc);
  5319.                 if (!val2.type || ord_type(val2.type)->kind != TK_INTEGER)
  5320.                     val.type = NULL;
  5321.                 else {
  5322.                     val.i += val2.i;
  5323.             val.type = tp_integer;
  5324.         }
  5325.             }
  5326.             return val;
  5327.  
  5328.         case EK_TIMES:
  5329.             val = eval_expr_either(ex->args[0], pasc);
  5330.             if (!val.type || ord_type(val.type)->kind != TK_INTEGER)
  5331.                 val.type = NULL;
  5332.             for (i = 1; val.type && i < ex->nargs; i++) {
  5333.                 val2 = eval_expr_either(ex->args[i], pasc);
  5334.                 if (!val2.type || ord_type(val2.type)->kind != TK_INTEGER)
  5335.                     val.type = NULL;
  5336.                 else {
  5337.                     val.i *= val2.i;
  5338.             val.type = tp_integer;
  5339.         }
  5340.             }
  5341.             return val;
  5342.  
  5343.         case EK_DIV:
  5344.             val = eval_expr_either(ex->args[0], pasc);
  5345.             val2 = eval_expr_either(ex->args[1], pasc);
  5346.             if (val.type && ord_type(val.type)->kind == TK_INTEGER &&
  5347.                 val2.type && ord_type(val2.type)->kind == TK_INTEGER &&
  5348.         val2.i) {
  5349.                 val.i /= val2.i;
  5350.         val.type = tp_integer;
  5351.                 return val;
  5352.             }
  5353.             break;
  5354.  
  5355.         case EK_MOD:
  5356.             val = eval_expr_either(ex->args[0], pasc);
  5357.             val2 = eval_expr_either(ex->args[1], pasc);
  5358.             if (val.type && ord_type(val.type)->kind == TK_INTEGER &&
  5359.                 val2.type && ord_type(val2.type)->kind == TK_INTEGER &&
  5360.         val2.i) {
  5361.                 val.i %= val2.i;
  5362.         val.type = tp_integer;
  5363.                 return val;
  5364.             }
  5365.             break;
  5366.  
  5367.         case EK_NEG:
  5368.             val = eval_expr_either(ex->args[0], pasc);
  5369.             if (val.type) {
  5370.                 val.i = -val.i;
  5371.                 return val;
  5372.             }
  5373.             break;
  5374.  
  5375.         case EK_LSH:
  5376.             val = eval_expr_either(ex->args[0], pasc);
  5377.             val2 = eval_expr_either(ex->args[1], pasc);
  5378.             if (val.type && val2.type) {
  5379.                 val.i <<= val2.i;
  5380.                 return val;
  5381.             }
  5382.             break;
  5383.  
  5384.         case EK_RSH:
  5385.             val = eval_expr_either(ex->args[0], pasc);
  5386.             val2 = eval_expr_either(ex->args[1], pasc);
  5387.             if (val.type && val2.type) {
  5388.                 val.i >>= val2.i;
  5389.                 return val;
  5390.             }
  5391.             break;
  5392.  
  5393.         case EK_BAND:
  5394.             val = eval_expr_either(ex->args[0], pasc);
  5395.             val2 = eval_expr_either(ex->args[1], pasc);
  5396.             if (val.type && val2.type) {
  5397.                 val.i &= val2.i;
  5398.                 return val;
  5399.             }
  5400.             break;
  5401.  
  5402.         case EK_BOR:
  5403.             val = eval_expr_either(ex->args[0], pasc);
  5404.             val2 = eval_expr_either(ex->args[1], pasc);
  5405.             if (val.type && val2.type) {
  5406.                 val.i |= val2.i;
  5407.                 return val;
  5408.             }
  5409.             break;
  5410.  
  5411.         case EK_BXOR:
  5412.             val = eval_expr_either(ex->args[0], pasc);
  5413.             val2 = eval_expr_either(ex->args[1], pasc);
  5414.             if (val.type && val2.type) {
  5415.                 val.i ^= val2.i;
  5416.                 return val;
  5417.             }
  5418.             break;
  5419.  
  5420.         case EK_BNOT:
  5421.             val = eval_expr_either(ex->args[0], pasc);
  5422.             if (val.type) {
  5423.                 val.i = ~val.i;
  5424.                 return val;
  5425.             }
  5426.             break;
  5427.  
  5428.         case EK_EQ:
  5429.         case EK_NE:
  5430.         case EK_GT:
  5431.         case EK_LT:
  5432.         case EK_GE:
  5433.         case EK_LE:
  5434.             val = eval_expr_either(ex->args[0], pasc);
  5435.             val2 = eval_expr_either(ex->args[1], pasc);
  5436.             if (val.type) {
  5437.                 if (val.i == val2.i)
  5438.                     val.i = (ex->kind == EK_EQ || ex->kind == EK_GE || ex->kind == EK_LE);
  5439.                 else if (val.i < val2.i)
  5440.                     val.i = (ex->kind == EK_LT || ex->kind == EK_LE || ex->kind == EK_NE);
  5441.                 else
  5442.                     val.i = (ex->kind == EK_GT || ex->kind == EK_GE || ex->kind == EK_NE);
  5443.                 val.type = tp_boolean;
  5444.                 return val;
  5445.             }
  5446.             break;
  5447.  
  5448.         case EK_NOT:
  5449.             val = eval_expr_either(ex->args[0], pasc);
  5450.             if (val.type)
  5451.                 val.i = !val.i;
  5452.             return val;
  5453.  
  5454.         case EK_AND:
  5455.             for (i = 0; i < ex->nargs; i++) {
  5456.                 val = eval_expr_either(ex->args[i], pasc);
  5457.                 if (!val.type || !val.i)
  5458.                     return val;
  5459.             }
  5460.             return val;
  5461.  
  5462.         case EK_OR:
  5463.             for (i = 0; i < ex->nargs; i++) {
  5464.                 val = eval_expr_either(ex->args[i], pasc);
  5465.                 if (!val.type || val.i)
  5466.                     return val;
  5467.             }
  5468.             return val;
  5469.  
  5470.         case EK_COMMA:
  5471.             return eval_expr_either(ex->args[ex->nargs-1], pasc);
  5472.  
  5473.     default:
  5474.         break;
  5475.     }
  5476.     val.type = NULL;
  5477.     return val;
  5478. }
  5479.  
  5480.  
  5481. Value eval_expr(ex)
  5482. Expr *ex;
  5483. {
  5484.     return eval_expr_either(ex, 0);
  5485. }
  5486.  
  5487.  
  5488. Value eval_expr_consts(ex)
  5489. Expr *ex;
  5490. {
  5491.     Value val;
  5492.     short save_fold = foldconsts;
  5493.  
  5494.     foldconsts = 1;
  5495.     val = eval_expr_either(ex, 0);
  5496.     foldconsts = save_fold;
  5497.     return val;
  5498. }
  5499.  
  5500.  
  5501. Value eval_expr_pasc(ex)
  5502. Expr *ex;
  5503. {
  5504.     return eval_expr_either(ex, 1);
  5505. }
  5506.  
  5507.  
  5508.  
  5509. int expr_is_const(ex)
  5510. Expr *ex;
  5511. {
  5512.     int i;
  5513.  
  5514.     switch (ex->kind) {
  5515.  
  5516.         case EK_CONST:
  5517.         case EK_LONGCONST:
  5518.         case EK_SIZEOF:
  5519.             return 1;
  5520.  
  5521.         case EK_VAR:
  5522.             return (((Meaning *)ex->val.i)->kind == MK_CONST);
  5523.  
  5524.         case EK_HAT:
  5525.         case EK_ASSIGN:
  5526.         case EK_POSTINC:
  5527.         case EK_POSTDEC:
  5528.             return 0;
  5529.  
  5530.         case EK_ADDR:
  5531.             if (ex->args[0]->kind == EK_VAR)
  5532.                 return 1;
  5533.             return 0;   /* conservative */
  5534.  
  5535.         case EK_FUNCTION:
  5536.             if (!nosideeffects_func(ex))
  5537.                 return 0;
  5538.             break;
  5539.  
  5540.         case EK_BICALL:
  5541.             if (!nosideeffects_func(ex))
  5542.                 return 0;
  5543.             break;
  5544.  
  5545.     default:
  5546.         break;
  5547.     }
  5548.     for (i = 0; i < ex->nargs; i++) {
  5549.         if (!expr_is_const(ex->args[i]))
  5550.             return 0;
  5551.     }
  5552.     return 1;
  5553. }
  5554.  
  5555.  
  5556.  
  5557.  
  5558.  
  5559. Expr *eatcasts(ex)
  5560. Expr *ex;
  5561. {
  5562.     while (ex->kind == EK_CAST)
  5563.         ex = grabarg(ex, 0);
  5564.     return ex;
  5565. }
  5566.  
  5567.  
  5568.  
  5569.  
  5570.  
  5571. /* End. */
  5572.  
  5573.  
  5574.  
  5575.