home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 379a.lha / p2c1_13a / src / src.zoo / expr2.c < prev    next >
C/C++ Source or Header  |  1990-03-11  |  24KB  |  1,001 lines
  1. /* "p2c", a Pascal to C translator.
  2.    Copyright (C) 1989 David Gillespie.
  3.    Author's address: daveg@csvax.caltech.edu; 256-80 Caltech/Pasadena CA 91125.
  4.  
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation (any version).
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  13.  
  14. You should have received a copy of the GNU General Public License
  15. along with this program; see the file COPYING.  If not, write to
  16. the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  17.  
  18. #define PROTO_EXPR2_C
  19. #include "trans.h"
  20.  
  21. Expr *resimplify(ex)
  22. Expr *ex;
  23. {
  24.     Expr *ex2;
  25.     Type *type;
  26.     int i;
  27.  
  28.     if (debug>2) { fprintf(outf,"resimplify("); dumpexpr(ex); fprintf(outf,")\n"); }
  29.     if (!ex)
  30.         return NULL;
  31.     type = ex->val.type;
  32.     switch (ex->kind) {
  33.  
  34.         case EK_PLUS:
  35.             ex2 = ex->args[0];
  36.             for (i = 1; i < ex->nargs; i++)
  37.                 ex2 = makeexpr_plus(ex2, ex->args[i]);
  38.             FREE(ex);
  39.             return ex2;
  40.  
  41.         case EK_TIMES:
  42.             ex2 = ex->args[0];
  43.             for (i = 1; i < ex->nargs; i++)
  44.                 ex2 = makeexpr_times(ex2, ex->args[i]);
  45.             FREE(ex);
  46.             return ex2;
  47.  
  48.         case EK_NEG:
  49.             ex = makeexpr_neg(grabarg(ex, 0));
  50.             ex->val.type = type;
  51.             return ex;
  52.  
  53.         case EK_NOT:
  54.             ex = makeexpr_not(grabarg(ex, 0));
  55.             ex->val.type = type;
  56.             return ex;
  57.  
  58.         case EK_HAT:
  59.             ex = makeexpr_hat(grabarg(ex, 0), 0);
  60.         if (ex->kind == EK_HAT)
  61.         ex->val.type = type;
  62.             return ex;
  63.  
  64.         case EK_ADDR:
  65.             ex = makeexpr_addr(grabarg(ex, 0));
  66.             ex->val.type = type;
  67.             return ex;
  68.  
  69.     case EK_ASSIGN:
  70.         ex2 = makeexpr_assign(ex->args[0], ex->args[1]);
  71.         FREE(ex);
  72.         return ex2;
  73.  
  74.     default:
  75.         break;
  76.     }
  77.     return ex;
  78. }
  79.  
  80.  
  81.  
  82.  
  83.  
  84.  
  85. int realzero(s)
  86. register char *s;
  87. {
  88.     if (*s == '-') s++;
  89.     while (*s == '0' || *s == '.') s++;
  90.     return (!isdigit(*s));
  91. }
  92.  
  93.  
  94. int checkconst(ex, val)
  95. Expr *ex;
  96. long val;
  97. {
  98.     Meaning *mp;
  99.     Value exval;
  100.  
  101.     if (!ex)
  102.         return 0;
  103.     if (ex->kind == EK_CAST || ex->kind == EK_ACTCAST)
  104.         ex = ex->args[0];
  105.     if (ex->kind == EK_CONST || ex->kind == EK_LONGCONST)
  106.         exval = ex->val;
  107.     else if (ex->kind == EK_VAR && 
  108.              (mp = (Meaning *)ex->val.i)->kind == MK_CONST &&
  109.              foldconsts != 0)
  110.         exval = mp->val;
  111.     else
  112.         return 0;
  113.     switch (exval.type->kind) {
  114.  
  115.         case TK_BOOLEAN:
  116.         case TK_INTEGER:
  117.         case TK_CHAR:
  118.         case TK_ENUM:
  119.         case TK_SUBR:
  120.         case TK_SMALLSET:
  121.         case TK_SMALLARRAY:
  122.             return exval.i == val;
  123.  
  124.         case TK_POINTER:
  125.         case TK_STRING:
  126.             return (val == 0 && exval.i == 0);
  127.  
  128.         case TK_REAL:
  129.             return (val == 0 && realzero(exval.s));
  130.  
  131.     default:
  132.         return 0;
  133.     }
  134. }
  135.  
  136.  
  137.  
  138. int isliteralconst(ex, valp)
  139. Expr *ex;
  140. Value *valp;
  141. {
  142.     Meaning *mp;
  143.  
  144.     if (ex) {
  145.         switch (ex->kind) {
  146.  
  147.             case EK_CONST:
  148.             case EK_LONGCONST:
  149.                 if (valp)
  150.                     *valp = ex->val;
  151.                 return 2;
  152.  
  153.             case EK_VAR:
  154.                 mp = (Meaning *)ex->val.i;
  155.                 if (mp->kind == MK_CONST) {
  156.                     if (valp) {
  157.                         if (foldconsts == 0)
  158.                             valp->type = NULL;
  159.                         else
  160.                             *valp = mp->val;
  161.                     }
  162.                     return 1;
  163.                 }
  164.                 break;
  165.  
  166.         default:
  167.         break;
  168.         }
  169.     }
  170.     if (valp)
  171.         valp->type = NULL;
  172.     return 0;
  173. }
  174.  
  175.  
  176.  
  177. int isconstexpr(ex, valp)
  178. Expr *ex;
  179. long *valp;
  180. {
  181.     Value exval;
  182.  
  183.     if (debug>2) { fprintf(outf,"isconstexpr("); dumpexpr(ex); fprintf(outf,")\n"); }
  184.     exval = eval_expr(ex);
  185.     if (exval.type) {
  186.         if (valp)
  187.             *valp = exval.i;
  188.         return 1;
  189.     } else
  190.         return 0;
  191. }
  192.  
  193.  
  194.  
  195. int isconstantexpr(ex)
  196. Expr *ex;
  197. {
  198.     Meaning *mp;
  199.     int i;
  200.  
  201.     switch (ex->kind) {
  202.  
  203.         case EK_CONST:
  204.         case EK_LONGCONST:
  205.         case EK_SIZEOF:
  206.             return 1;
  207.  
  208.         case EK_ADDR:
  209.             if (ex->args[0]->kind == EK_VAR) {
  210.                 mp = (Meaning *)ex->val.i;
  211.                 return (!mp->ctx || mp->ctx->kind == MK_MODULE);
  212.             }
  213.             return 0;
  214.  
  215.         case EK_VAR:
  216.             mp = (Meaning *)ex->val.i;
  217.             return (mp->kind == MK_CONST);
  218.  
  219.         case EK_BICALL:
  220.         case EK_FUNCTION:
  221.             if (!deterministic_func(ex))
  222.                 return 0;
  223.  
  224.         /* fall through */
  225.         case EK_EQ:
  226.         case EK_NE:
  227.         case EK_LT:
  228.         case EK_GT:
  229.         case EK_LE:
  230.         case EK_GE:
  231.         case EK_PLUS:
  232.         case EK_NEG:
  233.         case EK_TIMES:
  234.         case EK_DIVIDE:
  235.         case EK_DIV:
  236.         case EK_MOD:
  237.         case EK_AND:
  238.         case EK_OR:
  239.         case EK_NOT:
  240.         case EK_BAND:
  241.         case EK_BOR:
  242.         case EK_BXOR:
  243.         case EK_BNOT:
  244.         case EK_LSH:
  245.         case EK_RSH:
  246.         case EK_CAST:
  247.         case EK_ACTCAST:
  248.         case EK_COND:
  249.             for (i = 0; i < ex->nargs; i++) {
  250.                 if (!isconstantexpr(ex->args[i]))
  251.                     return 0;
  252.             }
  253.             return 1;
  254.  
  255.         case EK_COMMA:
  256.             return isconstantexpr(ex->args[ex->nargs-1]);
  257.  
  258.     default:
  259.         return 0;
  260.     }
  261. }
  262.  
  263. Expr *docast(a, type)
  264. Expr *a;
  265. Type *type;
  266. {
  267.     Value val;
  268.     Meaning *mp;
  269.     int i;
  270.     Expr *ex;
  271.  
  272.     if (a->val.type->kind == TK_SMALLSET && type->kind == TK_SET) {
  273.         mp = makestmttempvar(type, name_SET);
  274.         return makeexpr_bicall_2(setexpandname, type,
  275.                                  makeexpr_var(mp),
  276.                                  makeexpr_arglong(a, 1));
  277.     } else if (a->val.type->kind == TK_SET && type->kind == TK_SMALLSET) {
  278.         return packset(a, type);
  279.     }
  280.     switch (a->kind) {
  281.  
  282.         case EK_VAR:
  283.             mp = (Meaning *) a->val.i;
  284.             if (mp->kind == MK_CONST) {
  285.                 if (mp->val.type->kind == TK_STRING && type->kind == TK_CHAR) {
  286.                     val = value_cast(mp->val, type);
  287.                     a->kind = EK_CONST;
  288.                     a->val = val;
  289.                     return a;
  290.                 }
  291.             }
  292.             break;
  293.  
  294.         case EK_CONST:
  295.         case EK_LONGCONST:
  296.             val = value_cast(a->val, type);
  297.             if (val.type) {
  298.                 a->val = val;
  299.                 return a;
  300.             }
  301.             break;
  302.  
  303.         case EK_PLUS:
  304.         case EK_NEG:
  305.         case EK_TIMES:
  306.             if (type->kind == TK_REAL) {
  307.                 for (i = 0; i < a->nargs; i++) {
  308.                     ex = docast(a->args[i], type);
  309.                     if (ex) {
  310.                         a->args[i] = ex;
  311.                         a->val.type = type;
  312.                         return a;
  313.                     }
  314.                 }
  315.             }
  316.             break;
  317.  
  318.     default:
  319.         break;
  320.     }
  321.     return NULL;
  322. }
  323.  
  324.  
  325.  
  326. /* Make an "active" cast, i.e., one that performs an explicit operation */
  327. Expr *makeexpr_actcast(a, type)
  328. Expr *a;
  329. Type *type;
  330. {
  331.     if (debug>2) { fprintf(outf,"makeexpr_actcast("); dumpexpr(a); fprintf(outf,", "); dumptypename(type, 1); fprintf(outf,")\n"); }
  332.  
  333.     if (similartypes(a->val.type, type)) {
  334.         a->val.type = type;
  335.         return a;
  336.     }
  337.     return makeexpr_un(EK_ACTCAST, type, a);
  338. }
  339.  
  340.  
  341.  
  342. Expr *makeexpr_cast(a, type)
  343. Expr *a;
  344. Type *type;
  345. {
  346.     Expr *ex;
  347.  
  348.     if (debug>2) { fprintf(outf,"makeexpr_cast("); dumpexpr(a); fprintf(outf,", "); dumptypename(type, 1); fprintf(outf,")\n"); }
  349.     if (a->val.type == type)
  350.         return a;
  351.     ex = docast(a, type);
  352.     if (ex)
  353.         return ex;
  354.     if (a->kind == EK_CAST &&
  355.         a->args[0]->val.type->kind == TK_POINTER &&
  356.         similartypes(type, a->args[0]->val.type)) {
  357.         a = grabarg(a, 0);
  358.         a->val.type = type;
  359.         return a;
  360.     }
  361.     if ((a->kind == EK_CAST &&
  362.          ((a->val.type->kind == TK_POINTER && type->kind == TK_POINTER) ||
  363.           (ord_type(a->val.type)->kind == TK_INTEGER && ord_type(type)->kind == TK_INTEGER))) ||
  364.         similartypes(type, a->val.type)) {
  365.         a->val.type = type;
  366.         return a;
  367.     }
  368.     return makeexpr_un(EK_CAST, type, a);
  369. }
  370.  
  371.  
  372.  
  373. Expr *gentle_cast(a, type)
  374. Expr *a;
  375. Type *type;
  376. {
  377.     Expr *ex;
  378.     Type *btype;
  379.     long smin, smax;
  380.  
  381.     if (debug>2) { fprintf(outf,"gentle_cast("); dumpexpr(a); fprintf(outf,", "); dumptypename(type, 1); fprintf(outf,")\n"); }
  382.     if (!type) {
  383.     intwarning("gentle_cast", "type == NULL");
  384.     return a;
  385.     }
  386.     if (a->val.type->kind == TK_POINTER && type->kind == TK_POINTER) {
  387.         if (voidstar && (type == tp_anyptr || a->val.type == tp_anyptr)) {
  388.             if (type == tp_anyptr && a->kind == EK_CAST &&
  389.                 a->args[0]->val.type->kind == TK_POINTER)
  390.                 return a->args[0];    /* remove explicit cast since casting implicitly */
  391.             return a;                 /* casting to/from "void *" */
  392.         }
  393.         return makeexpr_cast(a, type);
  394.     }
  395.     if (type->kind == TK_STRING)
  396.         return makeexpr_stringify(a);
  397.     if (type->kind == TK_ARRAY && a->val.type->kind == TK_STRING &&
  398.         a->kind == EK_CONST && ord_range(type->indextype, &smin, &smax)) {
  399.         smax = smax - smin + 1;
  400.         if (a->val.i > smax) {
  401.             warning("Too many characters for packed array of char [162]");
  402.         } else if (a->val.i < smax) {
  403.             ex = makeexpr_lstring(a->val.s, smax);
  404.             while (smax > a->val.i)
  405.                 ex->val.s[--smax] = ' ';
  406.             freeexpr(a);
  407.             return ex;
  408.         }
  409.     }
  410.     btype = (type->kind == TK_SUBR) ? type->basetype : type;
  411.     if ((a->kind == EK_CAST || a->kind == EK_ACTCAST) && 
  412.         btype->kind == TK_INTEGER &&
  413.         ord_type(a->val.type)->kind == TK_INTEGER)
  414.         return makeexpr_longcast(a, long_type(type));
  415.     if (a->val.type == btype)
  416.         return a;
  417.     ex = docast(a, btype);
  418.     if (ex)
  419.         return ex;
  420.     if (btype->kind == TK_CHAR && a->val.type->kind == TK_STRING)
  421.         return makeexpr_hat(a, 0);
  422.     return a;
  423. }
  424.  
  425.  
  426.  
  427. Expr *makeexpr_charcast(ex)
  428. Expr *ex;
  429. {
  430.     if (ex->kind == EK_CONST && ex->val.type->kind == TK_STRING &&
  431.         ex->val.i == 1) {
  432.         ex->val.type = tp_char;
  433.         ex->val.i = ex->val.s[0] & 0xff;
  434.         ex->val.s = NULL;
  435.     }
  436.     return ex;
  437. }
  438.  
  439.  
  440.  
  441. Expr *makeexpr_stringcast(ex)
  442. Expr *ex;
  443. {
  444.     char ch;
  445.  
  446.     if (ex->kind == EK_CONST && ord_type(ex->val.type)->kind == TK_CHAR) {
  447.         ch = ex->val.i;
  448.         freeexpr(ex);
  449.         ex = makeexpr_lstring(&ch, 1);
  450.     }
  451.     return ex;
  452. }
  453.  
  454.  
  455.  
  456.  
  457.  
  458. /* 0/1 = force to int/long, 2/3 = check if int/long */
  459.  
  460. Static Expr *dolongcast(a, tolong)
  461. Expr *a;
  462. int tolong;
  463. {
  464.     Meaning *mp;
  465.     Expr *ex;
  466.     Type *type;
  467.     int i;
  468.  
  469.     switch (a->kind) {
  470.  
  471.         case EK_DOT:
  472.             if (!a->val.i) {
  473.                 if (long_type(a->val.type) == (tolong&1))
  474.                     return a;
  475.                 break;
  476.             }
  477.  
  478.         /* fall through */
  479.         case EK_VAR:
  480.             mp = (Meaning *)a->val.i;
  481.             if (mp->kind == MK_FIELD && mp->val.i) {
  482.                 if (mp->val.i <= ((sizeof_int > 0) ? sizeof_int : 16) &&
  483.                     !(tolong&1))
  484.                     return a;
  485.             } else if (mp->kind == MK_VAR ||
  486.                        mp->kind == MK_VARREF ||
  487.                        mp->kind == MK_PARAM ||
  488.                        mp->kind == MK_VARPARAM ||
  489.                        mp->kind == MK_FIELD) {
  490.                 if (long_type(mp->type) == (tolong&1))
  491.                     return a;
  492.             }
  493.             break;
  494.  
  495.         case EK_FUNCTION:
  496.             mp = (Meaning *)a->val.i;
  497.             if (long_type(mp->type->basetype) == (tolong&1))
  498.                 return a;
  499.             break;
  500.  
  501.         case EK_BICALL:
  502.             if (!strcmp(a->val.s, signextname) && *signextname) {
  503.                 i = 0;
  504.                 goto unary;
  505.             }
  506.         if (!strcmp(a->val.s, "strlen"))
  507.         goto size_t_case;
  508.             /* fall through */
  509.  
  510.         case EK_HAT:      /* get true type from a->val.type */
  511.         case EK_INDEX:
  512.         case EK_SPCALL:
  513.         case EK_NAME:
  514.             if (long_type(a->val.type) == (tolong&1))
  515.                 return a;
  516.             break;
  517.  
  518.         case EK_ASSIGN:   /* destination determines type, */
  519.         case EK_POSTINC:  /*  but must not be changed */
  520.         case EK_POSTDEC:
  521.             return dolongcast(a->args[0], tolong|2);
  522.  
  523.         case EK_CAST:
  524.             if (ord_type(a->val.type)->kind == TK_INTEGER &&
  525.                  long_type(a->val.type) == (tolong&1))
  526.                 return a;
  527.             if (tolong == 0) {
  528.                 a->val.type = tp_int;
  529.                 return a;
  530.             } else if (tolong == 1) {
  531.                 a->val.type = tp_integer;
  532.                 return a;
  533.             }
  534.             break;
  535.  
  536.         case EK_ACTCAST:
  537.             if (ord_type(a->val.type)->kind == TK_INTEGER &&
  538.                  long_type(a->val.type) == (tolong&1))
  539.                 return a;
  540.             break;
  541.  
  542.         case EK_CONST:
  543.             type = ord_type(a->val.type);
  544.             if (type->kind == TK_INTEGER || type->kind == TK_SMALLSET) {
  545.                 if (tolong == 1)
  546.                     a->kind = EK_LONGCONST;
  547.                 if (tolong != 3)
  548.                     return a;
  549.             }
  550.             break;
  551.  
  552.         case EK_LONGCONST:
  553.             if (tolong == 0) {
  554.                 if (a->val.i >= -32767 && a->val.i <= 32767)
  555.                     a->kind = EK_CONST;
  556.                 else
  557.                     return NULL;
  558.             }
  559.             if (tolong != 2)
  560.                 return a;
  561.             break;
  562.  
  563.         case EK_SIZEOF:
  564.     size_t_case:
  565.             if (size_t_long > 0 && tolong&1)
  566.                 return a;
  567.             if (size_t_long == 0 && !(tolong&1))
  568.                 return a;
  569.             break;
  570.  
  571.         case EK_PLUS:     /* usual arithmetic conversions apply */
  572.         case EK_TIMES:
  573.         case EK_DIV:
  574.         case EK_MOD:
  575.         case EK_BAND:
  576.         case EK_BOR:
  577.         case EK_BXOR:
  578.         case EK_COND:
  579.             i = (a->kind == EK_COND) ? 1 : 0;
  580.             if (tolong&1) {
  581.                 for (; i < a->nargs; i++) {
  582.                     ex = dolongcast(a->args[i], tolong);
  583.                     if (ex) {
  584.                         a->args[i] = ex;
  585.                         return a;
  586.                     }
  587.                 }
  588.             } else {
  589.                 for (; i < a->nargs; i++) {
  590.                     if (!dolongcast(a->args[i], tolong))
  591.                         return NULL;
  592.                 }
  593.                 return a;
  594.             }
  595.             break;
  596.  
  597.         case EK_BNOT:     /* single argument defines result type */
  598.         case EK_NEG:
  599.         case EK_LSH:
  600.         case EK_RSH:
  601.         case EK_COMMA:
  602.             i = (a->kind == EK_COMMA) ? a->nargs-1 : 0;
  603. unary:
  604.             if (tolong&1) {
  605.                 ex = dolongcast(a->args[i], tolong);
  606.                 if (ex) {
  607.                     a->args[i] = ex;
  608.                     return a;
  609.                 }
  610.             } else {
  611.                 if (dolongcast(a->args[i], tolong))
  612.                     return a;
  613.             }
  614.             break;
  615.  
  616.         case EK_AND:  /* operators which always return int */
  617.         case EK_OR:
  618.         case EK_EQ:
  619.         case EK_NE:
  620.         case EK_LT:
  621.         case EK_GT:
  622.         case EK_LE:
  623.         case EK_GE:
  624.             if (tolong&1)
  625.                 break;
  626.             return a;
  627.  
  628.     default:
  629.         break;
  630.     }
  631.     return NULL;
  632. }
  633.  
  634.  
  635. /* Return -1 if short int or plain int, 1 if long, 0 if can't tell */
  636. int exprlongness(ex)
  637. Expr *ex;
  638. {
  639.     if (sizeof_int >= 32)
  640.         return -1;
  641.     return (dolongcast(ex, 3) != NULL) -
  642.            (dolongcast(ex, 2) != NULL);
  643. }
  644.  
  645.  
  646. Expr *makeexpr_longcast(a, tolong)
  647. Expr *a;
  648. int tolong;
  649. {
  650.     Expr *ex;
  651.     Type *type;
  652.  
  653.     if (sizeof_int >= 32)
  654.         return a;
  655.     type = ord_type(a->val.type);
  656.     if (type->kind != TK_INTEGER && type->kind != TK_SMALLSET)
  657.         return a;
  658.     a = makeexpr_unlongcast(a);
  659.     if (tolong) {
  660.         ex = dolongcast(a, 1);
  661.     } else {
  662.         ex = dolongcast(copyexpr(a), 0);
  663.         if (ex) {
  664.             if (!dolongcast(ex, 2)) {
  665.                 freeexpr(ex);
  666.                 ex = NULL;
  667.             }
  668.         }
  669.     }
  670.     if (ex)
  671.         return ex;
  672.     return makeexpr_un(EK_CAST, (tolong) ? tp_integer : tp_int, a);
  673. }
  674.  
  675.  
  676. Expr *makeexpr_arglong(a, tolong)
  677. Expr *a;
  678. int tolong;
  679. {
  680.     int cast = castlongargs;
  681.     if (cast < 0)
  682.     cast = castargs;
  683.     if (cast > 0 || (cast < 0 && prototypes == 0)) {
  684.     return makeexpr_longcast(a, tolong);
  685.     }
  686.     return a;
  687. }
  688.  
  689.  
  690.  
  691. Expr *makeexpr_unlongcast(a)
  692. Expr *a;
  693. {
  694.     switch (a->kind) {
  695.  
  696.         case EK_LONGCONST:
  697.             if (a->val.i >= -32767 && a->val.i <= 32767)
  698.                 a->kind = EK_CONST;
  699.             break;
  700.  
  701.         case EK_CAST:
  702.             if ((a->val.type == tp_integer ||
  703.                  a->val.type == tp_int) &&
  704.                 ord_type(a->args[0]->val.type)->kind == TK_INTEGER) {
  705.                 a = grabarg(a, 0);
  706.             }
  707.             break;
  708.  
  709.         default:
  710.         break;
  711.  
  712.     }
  713.     return a;
  714. }
  715.  
  716.  
  717.  
  718. Expr *makeexpr_forcelongness(a)    /* force a to have a definite longness */
  719. Expr *a;
  720. {
  721.     Expr *ex;
  722.  
  723.     ex = makeexpr_unlongcast(copyexpr(a));
  724.     if (exprlongness(ex)) {
  725.         freeexpr(a);
  726.         return ex;
  727.     }
  728.     freeexpr(ex);
  729.     if (exprlongness(a) == 0)
  730.         return makeexpr_longcast(a, 1);
  731.     else
  732.         return a;
  733. }
  734.  
  735.  
  736.  
  737. Expr *makeexpr_ord(ex)
  738. Expr *ex;
  739. {
  740.     ex = makeexpr_charcast(ex);
  741.     switch (ord_type(ex->val.type)->kind) {
  742.  
  743.         case TK_ENUM:
  744.             return makeexpr_cast(ex, tp_int);
  745.  
  746.         case TK_CHAR:
  747.             if (ex->kind == EK_CONST &&
  748.                 (ex->val.i >= 32 && ex->val.i < 127)) {
  749.                 insertarg(&ex, 0, makeexpr_name("'%lc'", tp_integer));
  750.             }
  751.             ex->val.type = tp_int;
  752.             return ex;
  753.  
  754.         case TK_BOOLEAN:
  755.             ex->val.type = tp_int;
  756.             return ex;
  757.  
  758.         case TK_POINTER:
  759.             return makeexpr_cast(ex, tp_integer);
  760.  
  761.         default:
  762.             return ex;
  763.     }
  764. }
  765.  
  766.  
  767.  
  768.  
  769. /* Tell whether an expression "looks" negative */
  770. int expr_looks_neg(ex)
  771. Expr *ex;
  772. {
  773.     int i;
  774.  
  775.     switch (ex->kind) {
  776.  
  777.         case EK_NEG:
  778.             return 1;
  779.  
  780.         case EK_CONST:
  781.         case EK_LONGCONST:
  782.             switch (ord_type(ex->val.type)->kind) {
  783.                 case TK_INTEGER:
  784.                 case TK_CHAR:
  785.                     return (ex->val.i < 0);
  786.                 case TK_REAL:
  787.                     return (ex->val.s && ex->val.s[0] == '-');
  788.                 default:
  789.                     return 0;
  790.             }
  791.  
  792.         case EK_TIMES:
  793.         case EK_DIVIDE:
  794.             for (i = 0; i < ex->nargs; i++) {
  795.                 if (expr_looks_neg(ex->args[i]))
  796.                     return 1;
  797.             }
  798.             return 0;
  799.  
  800.         case EK_CAST:
  801.             return expr_looks_neg(ex->args[0]);
  802.  
  803.         default:
  804.             return 0;
  805.     }
  806. }
  807.  
  808.  
  809.  
  810. /* Tell whether an expression is probably negative */
  811. int expr_is_neg(ex)
  812. Expr *ex;
  813. {
  814.     int i;
  815.  
  816.     i = possiblesigns(ex) & (1|4);
  817.     if (i == 1)
  818.     return 1;    /* if expression really is negative! */
  819.     if (i == 4)
  820.     return 0;    /* if expression is definitely positive. */
  821.     return expr_looks_neg(ex);
  822. }
  823.  
  824.  
  825.  
  826. int expr_neg_cost(a)
  827. Expr *a;
  828. {
  829.     int i, c;
  830.  
  831.     switch (a->kind) {
  832.  
  833.         case EK_CONST:
  834.         case EK_LONGCONST:
  835.             switch (ord_type(a->val.type)->kind) {
  836.                 case TK_INTEGER:
  837.                 case TK_CHAR:
  838.                 case TK_REAL:
  839.                     return 0;
  840.         default:
  841.             return 1;
  842.             }
  843.  
  844.         case EK_NEG:
  845.             return -1;
  846.  
  847.         case EK_TIMES:
  848.         case EK_DIVIDE:
  849.             for (i = 0; i < a->nargs; i++) {
  850.                 c = expr_neg_cost(a->args[i]);
  851.                 if (c <= 0)
  852.                     return c;
  853.             }
  854.             return 1;
  855.  
  856.         case EK_PLUS:
  857.             for (i = 0; i < a->nargs; i++) {
  858.                 if (expr_looks_neg(a->args[i]))
  859.                     return 0;
  860.             }
  861.             return 1;
  862.  
  863.         default:
  864.             return 1;
  865.     }
  866. }
  867.  
  868.  
  869.  
  870. Expr *enum_to_int(a)
  871. Expr *a;
  872. {
  873.     if (ord_type(a->val.type)->kind == TK_ENUM) {
  874.         if (a->kind == EK_CAST &&
  875.              ord_type(a->args[0]->val.type)->kind == TK_INTEGER)
  876.             return grabarg(a, 0);
  877.         else
  878.             return makeexpr_cast(a, tp_integer);
  879.     } else
  880.         return a;
  881. }
  882.  
  883.  
  884.  
  885. Expr *neg_inside_sum(a)
  886. Expr *a;
  887. {
  888.     int i;
  889.  
  890.     for (i = 0; i < a->nargs; i++)
  891.         a->args[i] = makeexpr_neg(a->args[i]);
  892.     return a;
  893. }
  894.  
  895.  
  896.  
  897. Expr *makeexpr_neg(a)
  898. Expr *a;
  899. {
  900.     int i;
  901.  
  902.     if (debug>2) { fprintf(outf,"makeexpr_neg("); dumpexpr(a); fprintf(outf,")\n"); }
  903.     a = enum_to_int(a);
  904.     switch (a->kind) {
  905.  
  906.         case EK_CONST:
  907.         case EK_LONGCONST:
  908.             switch (ord_type(a->val.type)->kind) {
  909.  
  910.                 case TK_INTEGER:
  911.                 case TK_CHAR:
  912.                     if (a->val.i == MININT)
  913.                         valrange();
  914.                     else
  915.                         a->val.i = - a->val.i;
  916.                     return a;
  917.  
  918.                 case TK_REAL:
  919.                     if (!realzero(a->val.s)) {
  920.                         if (a->val.s[0] == '-')
  921.                             strchange(&a->val.s, a->val.s+1);
  922.                         else
  923.                             strchange(&a->val.s, format_s("-%s", a->val.s));
  924.                     }
  925.                     return a;
  926.  
  927.         default:
  928.             break;
  929.             }
  930.             break;
  931.  
  932.         case EK_PLUS:
  933.             if (expr_neg_cost(a) <= 0)
  934.                 return neg_inside_sum(a);
  935.             break;
  936.  
  937.         case EK_TIMES:
  938.         case EK_DIVIDE:
  939.             for (i = 0; i < a->nargs; i++) {
  940.                 if (expr_neg_cost(a->args[i]) <= 0) {
  941.                     a->args[i] = makeexpr_neg(a->args[i]);
  942.                     return a;
  943.                 }
  944.             }
  945.             break;
  946.  
  947.         case EK_CAST:
  948.             if (a->val.type != tp_unsigned && 
  949.                  a->val.type != tp_uint &&
  950.                  a->val.type != tp_ushort &&
  951.                  a->val.type != tp_ubyte &&
  952.                  a->args[0]->val.type != tp_unsigned && 
  953.                  a->args[0]->val.type != tp_uint &&
  954.                  a->args[0]->val.type != tp_ushort &&
  955.                  a->args[0]->val.type != tp_ubyte &&
  956.                  expr_looks_neg(a->args[0])) {
  957.                 a->args[0] = makeexpr_neg(a->args[0]);
  958.                 return a;
  959.             }
  960.             break;
  961.  
  962.         case EK_NEG:
  963.             return grabarg(a, 0);
  964.  
  965.     default:
  966.         break;
  967.     }
  968.     return makeexpr_un(EK_NEG, promote_type(a->val.type), a);
  969. }
  970.  
  971. #define ISCONST(kind) ((kind)==EK_CONST || (kind)==EK_LONGCONST)
  972. #define MOVCONST(ex) (ISCONST((ex)->kind) && (ex)->val.type->kind != TK_STRING)
  973. #define COMMUTATIVE (kind != EK_COMMA && type->kind != TK_REAL)
  974.  
  975. Type *true_type(ex)
  976. Expr *ex;
  977. {
  978.     Meaning *mp;
  979.     Type *type, *tp;
  980.  
  981.     while (ex->kind == EK_CAST)
  982.     ex = ex->args[0];
  983.     type = ex->val.type;
  984.     if (ex->kind == EK_VAR || ex->kind == EK_FUNCTION || ex->kind == EK_DOT) {
  985.     mp = (Meaning *)ex->val.i;
  986.     if (mp && mp->type && mp->type->kind != TK_VOID)
  987.         type = mp->type;
  988.     }
  989.     if (ex->kind == EK_INDEX) {
  990.     tp = true_type(ex->args[0]);
  991.     if ((tp->kind == TK_ARRAY || tp->kind == TK_SMALLARRAY ||
  992.          tp->kind == TK_STRING) &&
  993.         tp->basetype && tp->basetype->kind != TK_VOID)
  994.         type = tp->basetype;
  995.     }
  996.     if (type->kind == TK_SUBR)
  997.     type = findbasetype(type, 0);
  998.     return type;
  999. }
  1000.  
  1001.