home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 379a.lha / p2c1_13a / src / src.zoo / expr1.c < prev    next >
C/C++ Source or Header  |  1990-03-11  |  22KB  |  1,003 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_EXPR1_C
  19. #include "trans.h"
  20.  
  21. void free_value(val)
  22. Value *val;
  23. {
  24.     if (!val || !val->type)
  25.     return;
  26.     switch (val->type->kind) {
  27.  
  28.         case TK_STRING:
  29.         case TK_REAL:
  30.         case TK_ARRAY:
  31.         case TK_RECORD:
  32.         case TK_SET:
  33.             if (val->s)
  34.                 FREE(val->s);
  35.             break;
  36.  
  37.     default:
  38.         break;
  39.     }
  40. }
  41.  
  42.  
  43. Value copyvalue(val)
  44. Value val;
  45. {
  46.     char *cp;
  47.  
  48.     switch (val.type->kind) {
  49.  
  50.         case TK_STRING:
  51.         case TK_SET:
  52.             if (val.s) {
  53.                 cp = ALLOC(val.i+1, char, literals);
  54.                 memcpy(cp, val.s, val.i);
  55.         cp[val.i] = 0;
  56.                 val.s = cp;
  57.             }
  58.             break;
  59.  
  60.         case TK_REAL:
  61.         case TK_ARRAY:
  62.         case TK_RECORD:
  63.             if (val.s)
  64.                 val.s = stralloc(val.s);
  65.             break;
  66.  
  67.     default:
  68.         break;
  69.     }
  70.     return val;
  71. }
  72.  
  73.  
  74. int valuesame(a, b)
  75. Value a, b;
  76. {
  77.     if (a.type != b.type)
  78.         return 0;
  79.     switch (a.type->kind) {
  80.  
  81.         case TK_INTEGER:
  82.         case TK_CHAR:
  83.         case TK_BOOLEAN:
  84.         case TK_ENUM:
  85.         case TK_SMALLSET:
  86.         case TK_SMALLARRAY:
  87.             return (a.i == b.i);
  88.  
  89.         case TK_STRING:
  90.         case TK_SET:
  91.             return (a.i == b.i && !memcmp(a.s, b.s, a.i));
  92.  
  93.         case TK_REAL:
  94.         case TK_ARRAY:
  95.         case TK_RECORD:
  96.             return (!strcmp(a.s, b.s));
  97.  
  98.         default:
  99.             return 1;
  100.     }
  101. }
  102.  
  103.  
  104.  
  105. char *value_name(val, intfmt, islong)
  106. Value val;
  107. char *intfmt;
  108. int islong;
  109. {
  110.     Meaning *mp;
  111.     Type *type = val.type;
  112.  
  113.     if (type->kind == TK_SUBR)
  114.     type = type->basetype;
  115.     switch (type->kind) {
  116.  
  117.         case TK_INTEGER:
  118.         case TK_SMALLSET:
  119.         case TK_SMALLARRAY:
  120.             if (!intfmt)
  121.         intfmt = "%ld";
  122.         if (*intfmt == '\'') {
  123.         if (val.i >= -'~' && val.i <= -' ') {
  124.             intfmt = format_s("-%s", intfmt);
  125.             val.i = -val.i;
  126.         }
  127.         if (val.i < ' ' || val.i > '~' || islong)
  128.             intfmt = "%ld";
  129.         }
  130.             if (islong)
  131.                 intfmt = format_s("%sL", intfmt);
  132.             return format_d(intfmt, val.i);
  133.  
  134.         case TK_REAL:
  135.             return val.s;
  136.  
  137.         case TK_ARRAY:    /* obsolete */
  138.         case TK_RECORD:   /* obsolete */
  139.             return val.s;
  140.  
  141.         case TK_STRING:
  142.             return makeCstring(val.s, val.i);
  143.  
  144.         case TK_BOOLEAN:
  145.             if (!intfmt)
  146.                 if (val.i == 1 && *name_TRUE &&
  147.             strcmp(name_TRUE, "1") && !islong)
  148.                     intfmt = name_TRUE;
  149.                 else if (val.i == 0 && *name_FALSE &&
  150.              strcmp(name_FALSE, "0") && !islong)
  151.                     intfmt = name_FALSE;
  152.                 else
  153.                     intfmt = "%ld";
  154.             if (islong)
  155.                 intfmt = format_s("%sL", intfmt);
  156.             return format_d(intfmt, val.i);
  157.  
  158.         case TK_CHAR:
  159.             if (islong)
  160.                 return format_d("%ldL", val.i);
  161.         else if ((val.i < 0 || val.i > 127) && highcharints)
  162.         return format_d("%ld", val.i);
  163.             else
  164.                 return makeCchar(val.i);
  165.  
  166.         case TK_POINTER:
  167.             return (*name_NULL) ? name_NULL : "NULL";
  168.  
  169.         case TK_ENUM:
  170.             mp = val.type->fbase;
  171.             while (mp && mp->val.i != val.i)
  172.                 mp = mp->xnext;
  173.             if (!mp) {
  174.                 intwarning("value_name", "bad enum value [152]");
  175.                 return format_d("%ld", val.i);
  176.             }
  177.             return mp->name;
  178.  
  179.         default:
  180.             intwarning("value_name", format_s("bad type for constant: %s [153]", 
  181.                                               typekindname(type->kind)));
  182.             return "<spam>";
  183.     }
  184. }
  185.  
  186.  
  187.  
  188.  
  189. Value value_cast(val, type)
  190. Value val;
  191. Type *type;
  192. {
  193.     char buf[20];
  194.  
  195.     if (type->kind == TK_SUBR)
  196.         type = type->basetype;
  197.     if (val.type == type)
  198.         return val;
  199.     if (type && val.type) {
  200.         switch (type->kind) {
  201.  
  202.             case TK_REAL:
  203.                 if (ord_type(val.type)->kind == TK_INTEGER) {
  204.                     sprintf(buf, "%d.0", val.i);
  205.                     val.s = stralloc(buf);
  206.                     val.type = tp_real;
  207.                     return val;
  208.                 }
  209.                 break;
  210.  
  211.             case TK_CHAR:
  212.                 if (val.type->kind == TK_STRING) {
  213.                     if (val.i != 1)
  214.                         if (val.i > 0)
  215.                             warning("Char constant with more than one character [154]");
  216.                         else
  217.                             warning("Empty char constant [155]");
  218.                     val.i = val.s[0] & 0xff;
  219.                     val.s = NULL;
  220.                     val.type = tp_char;
  221.                     return val;
  222.                 }
  223.  
  224.             case TK_POINTER:
  225.                 if (val.type == tp_anyptr && castnull != 1) {
  226.                     val.type = type;
  227.                     return val;
  228.                 }
  229.  
  230.         default:
  231.         break;
  232.         }
  233.     }
  234.     val.type = NULL;
  235.     return val;
  236. }
  237.  
  238.  
  239.  
  240. Type *ord_type(tp)
  241. Type *tp;
  242. {
  243.     if (!tp) {
  244.         warning("Expected a constant [127]");
  245.         return tp_integer;
  246.     }
  247.     switch (tp->kind) {
  248.  
  249.         case TK_SUBR:
  250.             tp = tp->basetype;
  251.             break;
  252.  
  253.         case TK_STRING:
  254.             if (!CHECKORDEXPR(tp->indextype->smax, 1))
  255.                 tp = tp_char;
  256.             break;
  257.  
  258.     default:
  259.         break;
  260.  
  261.     }
  262.     return tp;
  263. }
  264.  
  265.  
  266.  
  267. int long_type(tp)
  268. Type *tp;
  269. {
  270.     switch (tp->kind) {
  271.  
  272.         case TK_INTEGER:
  273.             return (tp != tp_int && tp != tp_uint && tp != tp_sint);
  274.  
  275.         case TK_SUBR:
  276.             return (findbasetype(tp, 0) == tp_integer);
  277.  
  278.         default:
  279.             return 0;
  280.     }
  281. }
  282.  
  283.  
  284.  
  285. Value make_ord(type, i)
  286. Type *type;
  287. long i;
  288. {
  289.     Value val;
  290.  
  291.     if (type->kind == TK_ENUM)
  292.         type = findbasetype(type, 0);
  293.     if (type->kind == TK_SUBR)
  294.         type = type->basetype;
  295.     val.type = type;
  296.     val.i = i;
  297.     val.s = NULL;
  298.     return val;
  299. }
  300.  
  301.  
  302.  
  303. long ord_value(val)
  304. Value val;
  305. {
  306.     switch (val.type->kind) {
  307.  
  308.         case TK_INTEGER:
  309.         case TK_ENUM:
  310.         case TK_CHAR:
  311.         case TK_BOOLEAN:
  312.             return val.i;
  313.  
  314.         case TK_STRING:
  315.             if (val.i == 1)
  316.                 return val.s[0] & 0xff;
  317.  
  318.         /* fall through */
  319.         default:
  320.             warning("Expected an ordinal type [156]");
  321.             return 0;
  322.     }
  323. }
  324.  
  325.  
  326.  
  327. void ord_range_expr(type, smin, smax)
  328. Type *type;
  329. Expr **smin, **smax;
  330. {
  331.     if (!type) {
  332.         warning("Expected a constant [127]");
  333.         type = tp_integer;
  334.     }
  335.     if (type->kind == TK_STRING)
  336.         type = tp_char;
  337.     switch (type->kind) {
  338.  
  339.         case TK_SUBR:
  340.         case TK_INTEGER:
  341.         case TK_ENUM:
  342.         case TK_CHAR:
  343.         case TK_BOOLEAN:
  344.             if (smin) *smin = type->smin;
  345.             if (smax) *smax = type->smax;
  346.             break;
  347.  
  348.         default:
  349.             warning("Expected an ordinal type [156]");
  350.             if (smin) *smin = makeexpr_long(0);
  351.             if (smax) *smax = makeexpr_long(1);
  352.             break;
  353.     }
  354. }
  355.  
  356.  
  357. int ord_range(type, smin, smax)
  358. Type *type;
  359. long *smin, *smax;
  360. {
  361.     Expr *emin, *emax;
  362.     Value vmin, vmax;
  363.  
  364.     ord_range_expr(type, &emin, &emax);
  365.     if (smin) {
  366.         vmin = eval_expr(emin);
  367.         if (!vmin.type)
  368.             return 0;
  369.     }
  370.     if (smax) {
  371.         vmax = eval_expr(emax);
  372.         if (!vmax.type)
  373.             return 0;
  374.     }
  375.     if (smin) *smin = ord_value(vmin);
  376.     if (smax) *smax = ord_value(vmax);
  377.     return 1;
  378. }
  379.  
  380.  
  381.  
  382.  
  383.  
  384.  
  385.  
  386. void freeexpr(ex)
  387. register Expr *ex;
  388. {
  389.     register int i;
  390.  
  391.     if (ex) {
  392.         for (i = 0; i < ex->nargs; i++)
  393.             freeexpr(ex->args[i]);
  394.         switch (ex->kind) {
  395.  
  396.             case EK_CONST:
  397.             case EK_LONGCONST:
  398.                 free_value(&ex->val);
  399.                 break;
  400.  
  401.             case EK_DOT:
  402.             case EK_NAME:
  403.             case EK_BICALL:
  404.                 if (ex->val.s)
  405.                     FREE(ex->val.s);
  406.                 break;
  407.  
  408.         default:
  409.         break;
  410.         }
  411.         FREE(ex);
  412.     }
  413. }
  414.  
  415.  
  416.  
  417.  
  418. Expr *makeexpr(kind, n)
  419. enum exprkind kind;
  420. int n;
  421. {
  422.     Expr *ex;
  423.  
  424.     ex = ALLOCV(sizeof(Expr) + (n-1)*sizeof(Expr *), Expr, exprs);
  425.     ex->val.i = 0;
  426.     ex->val.s = NULL;
  427.     ex->kind = kind;
  428.     ex->nargs = n;
  429.     return ex;
  430. }
  431.  
  432.  
  433. Expr *makeexpr_un(kind, type, arg1)
  434. enum exprkind kind;
  435. Type *type;
  436. Expr *arg1;
  437. {
  438.     Expr *ex;
  439.  
  440.     ex = makeexpr(kind, 1);
  441.     ex->val.type = type;
  442.     ex->args[0] = arg1;
  443.     if (debug>2) { fprintf(outf,"makeexpr_un returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  444.     return ex;
  445. }
  446.  
  447.  
  448. Expr *makeexpr_bin(kind, type, arg1, arg2)
  449. enum exprkind kind;
  450. Type *type;
  451. Expr *arg1, *arg2;
  452. {
  453.     Expr *ex;
  454.  
  455.     ex = makeexpr(kind, 2);
  456.     ex->val.type = type;
  457.     ex->args[0] = arg1;
  458.     ex->args[1] = arg2;
  459.     if (debug>2) { fprintf(outf,"makeexpr_bin returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  460.     return ex;
  461. }
  462.  
  463.  
  464.  
  465. Expr *makeexpr_val(val)
  466. Value val;
  467. {
  468.     Expr *ex;
  469.  
  470.     if (val.type->kind == TK_INTEGER && 
  471.         (val.i < -32767 || val.i > 32767) &&
  472.         sizeof_int < 32)
  473.         ex = makeexpr(EK_LONGCONST, 0);
  474.     else
  475.         ex = makeexpr(EK_CONST, 0);
  476.     ex->val = val;
  477.     if (debug>2) { fprintf(outf,"makeexpr_val returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  478.     return ex;
  479. }
  480.  
  481.  
  482.  
  483. Expr *makeexpr_char(c)
  484. int c;
  485. {
  486.     return makeexpr_val(make_ord(tp_char, c));
  487. }
  488.  
  489.  
  490. Expr *makeexpr_long(i)
  491. long i;
  492. {
  493.     return makeexpr_val(make_ord(tp_integer, i));
  494. }
  495.  
  496.  
  497. Expr *makeexpr_real(r)
  498. char *r;
  499. {
  500.     Value val;
  501.  
  502.     val.type = tp_real;
  503.     val.i = 0;
  504.     val.s = stralloc(r);
  505.     return makeexpr_val(val);
  506. }
  507.  
  508.  
  509. Expr *makeexpr_lstring(msg, len)
  510. char *msg;
  511. int len;
  512. {
  513.     Value val;
  514.  
  515.     val.type = tp_str255;
  516.     val.i = len;
  517.     val.s = ALLOC(len+1, char, literals);
  518.     memcpy(val.s, msg, len);
  519.     val.s[len] = 0;
  520.     return makeexpr_val(val);
  521. }
  522.  
  523.  
  524. Expr *makeexpr_string(msg)
  525. char *msg;
  526. {
  527.     Value val;
  528.  
  529.     val.type = tp_str255;
  530.     val.i = strlen(msg);
  531.     val.s = stralloc(msg);
  532.     return makeexpr_val(val);
  533. }
  534.  
  535.  
  536. int checkstring(ex, msg)
  537. Expr *ex;
  538. char *msg;
  539. {
  540.     if (!ex || ex->val.type->kind != TK_STRING || ex->kind != EK_CONST)
  541.         return 0;
  542.     if (ex->val.i != strlen(msg))
  543.         return 0;
  544.     return memcmp(ex->val.s, msg, ex->val.i) == 0;
  545. }
  546.  
  547.  
  548.  
  549. Expr *makeexpr_var(mp)
  550. Meaning *mp;
  551. {
  552.     Expr *ex;
  553.  
  554.     ex = makeexpr(EK_VAR, 0);
  555.     ex->val.i = (long) mp;
  556.     ex->val.type = mp->type;
  557.     if (debug>2) { fprintf(outf,"makeexpr_var returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  558.     return ex;
  559. }
  560.  
  561.  
  562.  
  563. Expr *makeexpr_name(name, type)
  564. char *name;
  565. Type *type;
  566. {
  567.     Expr *ex;
  568.  
  569.     ex = makeexpr(EK_NAME, 0);
  570.     ex->val.s = stralloc(name);
  571.     ex->val.type = type;
  572.     if (debug>2) { fprintf(outf,"makeexpr_name returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  573.     return ex;
  574. }
  575.  
  576.  
  577.  
  578. Expr *makeexpr_setbits()
  579. {
  580.     if (*name_SETBITS)
  581.         return makeexpr_name(name_SETBITS, tp_integer);
  582.     else
  583.         return makeexpr_long(setbits);
  584. }
  585.  
  586.  
  587.  
  588. /* Note: BICALL's to the following functions should obey the ANSI standard. */
  589. /*       Non-ANSI transformations occur while writing the expression. */
  590. /*              char *sprintf(buf, fmt, ...)   [returns buf]  */
  591. /*              void *memcpy(dest, src, size)  [returns dest] */
  592.  
  593. Expr *makeexpr_bicall_0(name, type)
  594. char *name;
  595. Type *type;
  596. {
  597.     Expr *ex;
  598.  
  599.     if (!name || !*name) {
  600.         intwarning("makeexpr_bicall_0", "Required name of built-in procedure is missing [157]");
  601.         name = "MissingProc";
  602.     }
  603.     ex = makeexpr(EK_BICALL, 0);
  604.     ex->val.s = stralloc(name);
  605.     ex->val.type = type;
  606.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  607.     return ex;
  608. }
  609.  
  610.  
  611. Expr *makeexpr_bicall_1(name, type, arg1)
  612. char *name;
  613. Type *type;
  614. Expr *arg1;
  615. {
  616.     Expr *ex;
  617.  
  618.     if (!name || !*name) {
  619.         intwarning("makeexpr_bicall_1", "Required name of built-in procedure is missing [157]");
  620.         name = "MissingProc";
  621.     }
  622.     ex = makeexpr(EK_BICALL, 1);
  623.     ex->val.s = stralloc(name);
  624.     ex->val.type = type;
  625.     ex->args[0] = arg1;
  626.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  627.     return ex;
  628. }
  629.  
  630.  
  631. Expr *makeexpr_bicall_2(name, type, arg1, arg2)
  632. char *name;
  633. Type *type;
  634. Expr *arg1, *arg2;
  635. {
  636.     Expr *ex;
  637.  
  638.     if (!name || !*name) {
  639.         intwarning("makeexpr_bicall_2", "Required name of built-in procedure is missing [157]");
  640.         name = "MissingProc";
  641.     }
  642.     ex = makeexpr(EK_BICALL, 2);
  643.     if (!strcmp(name, "~SETIO"))
  644.         name = (iocheck_flag) ? "~~SETIO" : name_SETIO;
  645.     ex->val.s = stralloc(name);
  646.     ex->val.type = type;
  647.     ex->args[0] = arg1;
  648.     ex->args[1] = arg2;
  649.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  650.     return ex;
  651. }
  652.  
  653.  
  654. Expr *makeexpr_bicall_3(name, type, arg1, arg2, arg3)
  655. char *name;
  656. Type *type;
  657. Expr *arg1, *arg2, *arg3;
  658. {
  659.     Expr *ex;
  660.  
  661.     if (!name || !*name) {
  662.         intwarning("makeexpr_bicall_3", "Required name of built-in procedure is missing [157]");
  663.         name = "MissingProc";
  664.     }
  665.     ex = makeexpr(EK_BICALL, 3);
  666.     ex->val.s = stralloc(name);
  667.     ex->val.type = type;
  668.     ex->args[0] = arg1;
  669.     ex->args[1] = arg2;
  670.     ex->args[2] = arg3;
  671.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  672.     return ex;
  673. }
  674.  
  675.  
  676. Expr *makeexpr_bicall_4(name, type, arg1, arg2, arg3, arg4)
  677. char *name;
  678. Type *type;
  679. Expr *arg1, *arg2, *arg3, *arg4;
  680. {
  681.     Expr *ex;
  682.  
  683.     if (!name || !*name) {
  684.         intwarning("makeexpr_bicall_4", "Required name of built-in procedure is missing [157]");
  685.         name = "MissingProc";
  686.     }
  687.     ex = makeexpr(EK_BICALL, 4);
  688.     if (!strcmp(name, "~CHKIO"))
  689.         name = (iocheck_flag) ? "~~CHKIO" : name_CHKIO;
  690.     ex->val.s = stralloc(name);
  691.     ex->val.type = type;
  692.     ex->args[0] = arg1;
  693.     ex->args[1] = arg2;
  694.     ex->args[2] = arg3;
  695.     ex->args[3] = arg4;
  696.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  697.     return ex;
  698. }
  699.  
  700.  
  701. Expr *makeexpr_bicall_5(name, type, arg1, arg2, arg3, arg4, arg5)
  702. char *name;
  703. Type *type;
  704. Expr *arg1, *arg2, *arg3, *arg4, *arg5;
  705. {
  706.     Expr *ex;
  707.  
  708.     if (!name || !*name) {
  709.         intwarning("makeexpr_bicall_5", "Required name of built-in procedure is missing [157]");
  710.         name = "MissingProc";
  711.     }
  712.     ex = makeexpr(EK_BICALL, 5);
  713.     ex->val.s = stralloc(name);
  714.     ex->val.type = type;
  715.     ex->args[0] = arg1;
  716.     ex->args[1] = arg2;
  717.     ex->args[2] = arg3;
  718.     ex->args[3] = arg4;
  719.     ex->args[4] = arg5;
  720.     if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
  721.     return ex;
  722. }
  723.  
  724.  
  725.  
  726.  
  727. Expr *copyexpr(ex)
  728. register Expr *ex;
  729. {
  730.     register int i;
  731.     register Expr *ex2;
  732.  
  733.     if (ex) {
  734.         ex2 = makeexpr(ex->kind, ex->nargs);
  735.         for (i = 0; i < ex->nargs; i++)
  736.             ex2->args[i] = copyexpr(ex->args[i]);
  737.         switch (ex->kind) {
  738.  
  739.             case EK_CONST:
  740.             case EK_LONGCONST:
  741.                 ex2->val = copyvalue(ex->val);
  742.                 break;
  743.  
  744.             case EK_DOT:
  745.             case EK_NAME:
  746.             case EK_BICALL:
  747.                 ex2->val.type = ex->val.type;
  748.                 ex2->val.i = ex->val.i;
  749.                 if (ex->val.s)
  750.                     ex2->val.s = stralloc(ex->val.s);
  751.                 break;
  752.  
  753.             default:
  754.                 ex2->val = ex->val;
  755.                 break;
  756.         }
  757.         return ex2;
  758.     } else
  759.         return NULL;
  760. }
  761.  
  762.  
  763.  
  764. int exprsame(a, b, strict)
  765. register Expr *a, *b;
  766. int strict;
  767. {
  768.     register int i;
  769.  
  770.     if (!a)
  771.         return (!b);
  772.     if (!b)
  773.         return 0;
  774.     if (a->val.type != b->val.type && strict != 2) {
  775.         if (strict ||
  776.         !((a->val.type->kind == TK_POINTER &&
  777.            a->val.type->basetype == b->val.type) ||
  778.           (b->val.type->kind == TK_POINTER &&
  779.            b->val.type->basetype == a->val.type)))
  780.         return 0;
  781.     }
  782.     if (a->kind != b->kind || a->nargs != b->nargs)
  783.         return 0;
  784.     switch (a->kind) {
  785.  
  786.         case EK_CONST:
  787.         case EK_LONGCONST:
  788.             if (!valuesame(a->val, b->val))
  789.                 return 0;
  790.             break;
  791.  
  792.         case EK_BICALL:
  793.         case EK_NAME:
  794.             if (strcmp(a->val.s, b->val.s))
  795.                 return 0;
  796.             break;
  797.  
  798.         case EK_VAR:
  799.         case EK_FUNCTION:
  800.         case EK_CTX:
  801.         case EK_MACARG:
  802.             if (a->val.i != b->val.i)
  803.                 return 0;
  804.             break;
  805.  
  806.         case EK_DOT:
  807.             if (a->val.i != b->val.i ||
  808.                 (!a->val.i && strcmp(a->val.s, b->val.s)))
  809.                 return 0;
  810.             break;
  811.  
  812.     default:
  813.         break;
  814.     }
  815.     i = a->nargs;
  816.     while (--i >= 0)
  817.         if (!exprsame(a->args[i], b->args[i], (strict == 2) ? 1 : strict))
  818.             return 0;
  819.     return 1;
  820. }
  821.  
  822.  
  823.  
  824. int exprequiv(a, b)
  825. register Expr *a, *b;
  826. {
  827.     register int i, j, k;
  828.     enum exprkind kind2;
  829.  
  830.     if (!a)
  831.         return (!b);
  832.     if (!b)
  833.         return 0;
  834.     switch (a->kind) {
  835.  
  836.         case EK_PLUS:
  837.         case EK_TIMES:
  838.         case EK_BAND:
  839.         case EK_BOR:
  840.         case EK_BXOR:
  841.         case EK_EQ:
  842.         case EK_NE:
  843.             if (b->kind != a->kind || b->nargs != a->nargs ||
  844.                 b->val.type != a->val.type)
  845.                 return 0;
  846.             if (a->nargs > 3)
  847.                 break;
  848.             for (i = 0; i < b->nargs; i++) {
  849.                 if (exprequiv(a->args[0], b->args[i])) {
  850.                     for (j = 0; j < b->nargs; j++) {
  851.                         if (j != i &&
  852.                             exprequiv(a->args[1], b->args[i])) {
  853.                             if (a->nargs == 2)
  854.                                 return 1;
  855.                             for (k = 0; k < b->nargs; k++) {
  856.                                 if (k != i && k != j &&
  857.                                     exprequiv(a->args[2], b->args[k]))
  858.                                     return 1;
  859.                             }
  860.                         }
  861.                     }
  862.                 }
  863.             }
  864.             break;
  865.  
  866.         case EK_LT:
  867.         case EK_GT:
  868.         case EK_LE:
  869.         case EK_GE:
  870.             switch (a->kind) {
  871.                 case EK_LT:  kind2 = EK_GT; break;
  872.                 case EK_GT:  kind2 = EK_LT; break;
  873.                 case EK_LE:  kind2 = EK_GE; break;
  874.                 default:     kind2 = EK_LE; break;
  875.             }
  876.             if (b->kind != kind2 || b->val.type != a->val.type)
  877.                 break;
  878.             if (exprequiv(a->args[0], b->args[1]) &&
  879.                 exprequiv(a->args[1], b->args[0])) {
  880.                 return 1;
  881.             }
  882.             break;
  883.  
  884.         case EK_CONST:
  885.         case EK_LONGCONST:
  886.         case EK_BICALL:
  887.         case EK_NAME:
  888.         case EK_VAR:
  889.         case EK_FUNCTION:
  890.         case EK_CTX:
  891.         case EK_DOT:
  892.             return exprsame(a, b, 0);
  893.  
  894.     default:
  895.         break;
  896.     }
  897.     if (b->kind != a->kind || b->nargs != a->nargs ||
  898.         b->val.type != a->val.type)
  899.         return 0;
  900.     i = a->nargs;
  901.     while (--i >= 0)
  902.         if (!exprequiv(a->args[i], b->args[i]))
  903.             return 0;
  904.     return 1;
  905. }
  906.  
  907.  
  908.  
  909. void deletearg(ex, n)
  910. Expr **ex;
  911. register int n;
  912. {
  913.     register Expr *ex1 = *ex, *ex2;
  914.     register int i;
  915.  
  916.     if (debug>2) { fprintf(outf,"deletearg("); dumpexpr(*ex); fprintf(outf,", %d)\n", n); }
  917.     if (n < 0 || n >= (*ex)->nargs) {
  918.         intwarning("deletearg", "argument number out of range [158]");
  919.         return;
  920.     }
  921.     ex2 = makeexpr(ex1->kind, ex1->nargs-1);
  922.     ex2->val = ex1->val;
  923.     for (i = 0; i < n; i++)
  924.         ex2->args[i] = ex1->args[i];
  925.     for (; i < ex2->nargs; i++)
  926.         ex2->args[i] = ex1->args[i+1];
  927.     *ex = ex2;
  928.     FREE(ex1);
  929.     if (debug>2) { fprintf(outf,"deletearg returns "); dumpexpr(*ex); fprintf(outf,"\n"); }
  930. }
  931.  
  932.  
  933.  
  934. void insertarg(ex, n, arg)
  935. Expr **ex;
  936. Expr *arg;
  937. register int n;
  938. {
  939.     register Expr *ex1 = *ex, *ex2;
  940.     register int i;
  941.  
  942.     if (debug>2) { fprintf(outf,"insertarg("); dumpexpr(*ex); fprintf(outf,", %d)\n", n); }
  943.     if (n < 0 || n > (*ex)->nargs) {
  944.         intwarning("insertarg", "argument number out of range [159]");
  945.         return;
  946.     }
  947.     ex2 = makeexpr(ex1->kind, ex1->nargs+1);
  948.     ex2->val = ex1->val;
  949.     for (i = 0; i < n; i++)
  950.         ex2->args[i] = ex1->args[i];
  951.     ex2->args[n] = arg;
  952.     for (; i < ex1->nargs; i++)
  953.         ex2->args[i+1] = ex1->args[i];
  954.     *ex = ex2;
  955.     FREE(ex1);
  956.     if (debug>2) { fprintf(outf,"insertarg returns "); dumpexpr(*ex); fprintf(outf,"\n"); }
  957. }
  958.  
  959.  
  960.  
  961. Expr *grabarg(ex, n)
  962. Expr *ex;
  963. int n;
  964. {
  965.     Expr *ex2;
  966.  
  967.     if (n < 0 || n >= ex->nargs) {
  968.         intwarning("grabarg", "argument number out of range [160]");
  969.         return ex;
  970.     }
  971.     ex2 = ex->args[n];
  972.     ex->args[n] = makeexpr_long(0);   /* placeholder */
  973.     freeexpr(ex);
  974.     return ex2;
  975. }
  976.  
  977.  
  978.  
  979. void delsimparg(ep, n)
  980. Expr **ep;
  981. int n;
  982. {
  983.     if (n < 0 || n >= (*ep)->nargs) {
  984.         intwarning("delsimparg", "argument number out of range [161]");
  985.         return;
  986.     }
  987.     deletearg(ep, n);
  988.     switch ((*ep)->kind) {
  989.  
  990.         case EK_PLUS:
  991.         case EK_TIMES:
  992.         case EK_COMMA:
  993.             if ((*ep)->nargs == 1)
  994.                 *ep = grabarg(*ep, 0);
  995.             break;
  996.  
  997.     default:
  998.         break;
  999.  
  1000.     }
  1001. }
  1002.  
  1003.