home *** CD-ROM | disk | FTP | other *** search
/ messroms.de / 2007-01-13_www.messroms.de.zip / VZ200 / TOOLS / ZCCSRC.ZIP / scc / expr.c < prev    next >
C/C++ Source or Header  |  2000-03-03  |  11KB  |  720 lines
  1. /*    File expr.c: 2.2 (83/06/21,11:24:26) */
  2. /*% cc -O -c %
  3.  *
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include "defs.h"
  8. #include "data.h"
  9. #include "proto.h"
  10.  
  11. /*
  12.  *    lval[0] - symbol table address, else 0 for constant
  13.  *    lval[1] - type indirect object to fetch, else 0 for static object
  14.  *    lval[2] - type pointer or array, else 0
  15.  */
  16.  
  17. void expression(int comma)
  18. {
  19.     int lval[3];
  20.  
  21.     do
  22.     {
  23.         if (heir1(lval))
  24.             rvalue(lval);
  25.         if (!comma)
  26.             return;
  27.     } while (match(","));
  28. }
  29.  
  30. int heir1(int lval[])
  31. {
  32.     int k, lval2[3];
  33.     char fc;
  34.  
  35.     k = heir1a(lval);
  36.     if (match("="))
  37.     {
  38.         if (k == 0)
  39.         {
  40.             needlval();
  41.             return (0);
  42.         }
  43.         if (lval[1])
  44.             gpush();
  45.         if (heir1(lval2))
  46.             rvalue(lval2);
  47.         store(lval);
  48.         return (0);
  49.     }
  50.     else
  51.     {
  52.         fc = ch();
  53.         if (match("-=") || match("+=") || match("*=") || match("/=") ||
  54.             match("%=") || match(">>=") || match("<<=") ||
  55.             match("&=") || match("^=") || match("|="))
  56.         {
  57.             if (k == 0)
  58.             {
  59.                 needlval();
  60.                 return (0);
  61.             }
  62.             if (lval[1])
  63.                 gpush();
  64.             rvalue(lval);
  65.             gpush();
  66.             if (heir1(lval2))
  67.                 rvalue(lval2);
  68.             switch (fc)
  69.             {
  70.             case '-':
  71.                 if (dbltest(lval, lval2))
  72.                     gaslint();
  73.                 gsub();
  74.                 result(lval, lval2);
  75.                 break;
  76.             case '+':
  77.                 if (dbltest(lval, lval2))
  78.                     gaslint();
  79.                 gadd(lval, lval2);
  80.                 result(lval, lval2);
  81.                 break;
  82.             case '*':
  83.                 gmult();
  84.                 break;
  85.             case '/':
  86.                 gdiv();
  87.                 break;
  88.             case '%':
  89.                 gmod();
  90.                 break;
  91.             case '>':
  92.                 gasr();
  93.                 break;
  94.             case '<':
  95.                 gasl();
  96.                 break;
  97.             case '&':
  98.                 gand();
  99.                 break;
  100.             case '^':
  101.                 gxor();
  102.                 break;
  103.             case '|':
  104.                 gor();
  105.                 break;
  106.             }
  107.             store(lval);
  108.             return (0);
  109.         }
  110.         else
  111.             return (k);
  112.     }
  113. }
  114.  
  115. int heir1a(int lval[])
  116. {
  117.     int k, lval2[3], lab1, lab2;
  118.  
  119.     k = heir1b(lval);
  120.     blanks();
  121.     if (ch() != '?')
  122.         return (k);
  123.     if (k)
  124.         rvalue(lval);
  125.     for (;;)
  126.     {
  127.         if (match("?"))
  128.         {
  129.             testjump(lab1 = getlabel(), FALSE);
  130.             if (heir1b(lval2))
  131.                 rvalue(lval2);
  132.             jump(lab2 = getlabel());
  133.             printlabel(lab1);
  134.             col();
  135.             nl();
  136.             blanks();
  137.             if (!match(":"))
  138.             {
  139.                 error("missing colon");
  140.                 return (0);
  141.             }
  142.             if (heir1b(lval2))
  143.                 rvalue(lval2);
  144.             printlabel(lab2);
  145.             col();
  146.             nl();
  147.         }
  148.         else
  149.             return (0);
  150.     }
  151. }
  152.  
  153. int heir1b(int lval[])
  154. {
  155.     int k, lval2[3], lab;
  156.  
  157.     k = heir1c(lval);
  158.     blanks();
  159.     if (!sstreq("||"))
  160.         return (k);
  161.     if (k)
  162.         rvalue(lval);
  163.     for (;;)
  164.     {
  165.         if (match("||"))
  166.         {
  167.             testjump(lab = getlabel(), TRUE);
  168.             if (heir1c(lval2))
  169.                 rvalue(lval2);
  170.             printlabel(lab);
  171.             col();
  172.             nl();
  173.             gbool();
  174.         }
  175.         else
  176.             return (0);
  177.     }
  178. }
  179.  
  180. int heir1c(int lval[])
  181. {
  182.     int k, lval2[3], lab;
  183.  
  184.     k = heir2(lval);
  185.     blanks();
  186.     if (!sstreq("&&"))
  187.         return (k);
  188.     if (k)
  189.         rvalue(lval);
  190.     for (;;)
  191.     {
  192.         if (match("&&"))
  193.         {
  194.             testjump(lab = getlabel(), FALSE);
  195.             if (heir2(lval2))
  196.                 rvalue(lval2);
  197.             printlabel(lab);
  198.             col();
  199.             nl();
  200.             gbool();
  201.         }
  202.         else
  203.             return (0);
  204.     }
  205. }
  206.  
  207. int heir2(int lval[])
  208. {
  209.     int k, lval2[3];
  210.  
  211.     k = heir3(lval);
  212.     blanks();
  213.     if (ch() != '|' || nch() == '|' || nch() == '=')
  214.         return (k);
  215.     if (k)
  216.         rvalue(lval);
  217.     for (;;)
  218.     {
  219.         if (ch() == '|' && nch() != '|' && nch() != '=')
  220.         {
  221.             inbyte();
  222.             gpush();
  223.             if (heir3(lval2))
  224.                 rvalue(lval2);
  225.             gor();
  226.             blanks();
  227.         }
  228.         else
  229.             return (0);
  230.     }
  231. }
  232.  
  233. int heir3(int lval[])
  234. {
  235.     int k, lval2[3];
  236.  
  237.     k = heir4(lval);
  238.     blanks();
  239.     if (ch() != '^' || nch() == '=')
  240.         return (k);
  241.     if (k)
  242.         rvalue(lval);
  243.     for (;;)
  244.     {
  245.         if (ch() == '^' && nch() != '=')
  246.         {
  247.             inbyte();
  248.             gpush();
  249.             if (heir4(lval2))
  250.                 rvalue(lval2);
  251.             gxor();
  252.             blanks();
  253.         }
  254.         else
  255.             return (0);
  256.     }
  257. }
  258.  
  259. int heir4(int lval[])
  260. {
  261.     int k, lval2[3];
  262.  
  263.     k = heir5(lval);
  264.     blanks();
  265.     if (ch() != '&' || nch() == '|' || nch() == '=')
  266.         return (k);
  267.     if (k)
  268.         rvalue(lval);
  269.     for (;;)
  270.     {
  271.         if (ch() == '&' && nch() != '&' && nch() != '=')
  272.         {
  273.             inbyte();
  274.             gpush();
  275.             if (heir5(lval2))
  276.                 rvalue(lval2);
  277.             gand();
  278.             blanks();
  279.         }
  280.         else
  281.             return (0);
  282.     }
  283. }
  284.  
  285. int heir5(int lval[])
  286. {
  287.     int k, lval2[3];
  288.  
  289.     k = heir6(lval);
  290.     blanks();
  291.     if (!sstreq("==") && !sstreq("!="))
  292.         return (k);
  293.     if (k)
  294.         rvalue(lval);
  295.     for (;;)
  296.     {
  297.         if (match("=="))
  298.         {
  299.             gpush();
  300.             if (heir6(lval2))
  301.                 rvalue(lval2);
  302.             geq();
  303.         }
  304.         else
  305.         if (match("!="))
  306.         {
  307.             gpush();
  308.             if (heir6(lval2))
  309.                 rvalue(lval2);
  310.             gne();
  311.         }
  312.         else
  313.             return (0);
  314.     }
  315. }
  316.  
  317. int heir6(int lval[])
  318. {
  319.     int k, lval2[3];
  320.  
  321.     k = heir7(lval);
  322.     blanks();
  323.     if (!sstreq("<") && !sstreq("<=") && !sstreq(">=") && !sstreq(">"))
  324.         return (k);
  325.     if (sstreq("<<") || sstreq(">>"))
  326.         return (k);
  327.     if (k)
  328.         rvalue(lval);
  329.     for (;;)
  330.     {
  331.         if (match("<="))
  332.         {
  333.             gpush();
  334.             if (heir7(lval2))
  335.                 rvalue(lval2);
  336.             if (lval[2] || lval2[2])
  337.             {
  338.                 gule();
  339.                 continue;
  340.             }
  341.             gle();
  342.         }
  343.         else
  344.         if (match(">="))
  345.         {
  346.             gpush();
  347.             if (heir7(lval2))
  348.                 rvalue(lval2);
  349.             if (lval[2] || lval2[2])
  350.             {
  351.                 guge();
  352.                 continue;
  353.             }
  354.             gge();
  355.         }
  356.         else
  357.         if ((sstreq("<")) && !sstreq("<<"))
  358.         {
  359.             inbyte();
  360.             gpush();
  361.             if (heir7(lval2))
  362.                 rvalue(lval2);
  363.             if (lval[2] || lval2[2])
  364.             {
  365.                 gult();
  366.                 continue;
  367.             }
  368.             glt();
  369.         }
  370.         else
  371.         if ((sstreq(">")) && !sstreq(">>"))
  372.         {
  373.             inbyte();
  374.             gpush();
  375.             if (heir7(lval2))
  376.                 rvalue(lval2);
  377.             if (lval[2] || lval2[2])
  378.             {
  379.                 gugt();
  380.                 continue;
  381.             }
  382.             ggt();
  383.         }
  384.         else
  385.             return (0);
  386.         blanks();
  387.     }
  388. }
  389.  
  390. int heir7(int lval[])
  391. {
  392.     int k, lval2[3];
  393.  
  394.     k = heir8(lval);
  395.     blanks();
  396.     if ((!sstreq(">>") && !sstreq("<<")) || sstreq(">>=") || sstreq("<<="))
  397.         return (k);
  398.     if (k)
  399.         rvalue(lval);
  400.     for (;;)
  401.     {
  402.         if (sstreq(">>") && !sstreq(">>="))
  403.         {
  404.             inbyte();
  405.             inbyte();
  406.             gpush();
  407.             if (heir8(lval2))
  408.                 rvalue(lval2);
  409.             gasr();
  410.         }
  411.         else
  412.         if (sstreq("<<") && !sstreq("<<="))
  413.         {
  414.             inbyte();
  415.             inbyte();
  416.             gpush();
  417.             if (heir8(lval2))
  418.                 rvalue(lval2);
  419.             gasl();
  420.         }
  421.         else
  422.             return (0);
  423.         blanks();
  424.     }
  425. }
  426.  
  427. int heir8(int lval[])
  428. {
  429.     int k, lval2[3];
  430.  
  431.     k = heir9(lval);
  432.     blanks();
  433.     if ((ch() != '+' && ch() != '-') || nch() == '=')
  434.         return (k);
  435.     if (k)
  436.         rvalue(lval);
  437.     for (;;)
  438.     {
  439.         if (match("+"))
  440.         {
  441.             gpush();
  442.             if (heir9(lval2))
  443.                 rvalue(lval2);
  444.             /* if left is pointer and right is int, scale right */
  445.             if (dbltest(lval, lval2))
  446.                 gaslint();
  447.             /* will scale left if right int pointer and left int */
  448.             gadd(lval, lval2);
  449.             result(lval, lval2);
  450.         }
  451.         else
  452.         if (match("-"))
  453.         {
  454.             gpush();
  455.             if (heir9(lval2))
  456.                 rvalue(lval2);
  457.             /* if dbl, can only be: pointer - int, or
  458.              * pointer - pointer, thus,
  459.              * in first case, int is scaled up,
  460.              * in second, result is scaled down. */
  461.             if (dbltest(lval, lval2))
  462.                 gaslint();
  463.             gsub();
  464.             /* if both pointers, scale result */
  465.             if (lval[2] == CINT && lval2[2] == CINT)
  466.                 gasrint();               /* divide by intsize */
  467.             result(lval, lval2);
  468.         }
  469.         else
  470.             return (0);
  471.     }
  472. }
  473.  
  474. int heir9(int lval[])
  475. {
  476.     int k, lval2[3];
  477.  
  478.     k = heir10(lval);
  479.     blanks();
  480.     if ((ch() != '*' && ch() != '/' && ch() != '%') || nch() == '=')
  481.         return (k);
  482.     if (k)
  483.         rvalue(lval);
  484.     for (;;)
  485.     {
  486.         if (match("*"))
  487.         {
  488.             gpush();
  489.             if (heir10(lval2))
  490.                 rvalue(lval2);
  491.             gmult();
  492.         }
  493.         else
  494.         if (match("/"))
  495.         {
  496.             gpush();
  497.             if (heir10(lval2))
  498.                 rvalue(lval2);
  499.             gdiv();
  500.         }
  501.         else
  502.         if (match("%"))
  503.         {
  504.             gpush();
  505.             if (heir10(lval2))
  506.                 rvalue(lval2);
  507.             gmod();
  508.         }
  509.         else
  510.             return (0);
  511.     }
  512. }
  513.  
  514. int heir10(int lval[])
  515. {
  516.     int k;
  517.     char *ptr;
  518.  
  519.     if (match("++"))
  520.     {
  521.         if ((k = heir10(lval)) == 0)
  522.         {
  523.             needlval();
  524.             return (0);
  525.         }
  526.         if (lval[1])
  527.             gpush();
  528.         rvalue(lval);
  529.         ginc(lval);
  530.         store(lval);
  531.         return (0);
  532.     }
  533.     else
  534.     if (match("--"))
  535.     {
  536.         if ((k = heir10(lval)) == 0)
  537.         {
  538.             needlval();
  539.             return (0);
  540.         }
  541.         if (lval[1])
  542.             gpush();
  543.         rvalue(lval);
  544.         gdec(lval);
  545.         store(lval);
  546.         return (0);
  547.     }
  548.     else
  549.     if (match("-"))
  550.     {
  551.         k = heir10(lval);
  552.         if (k)
  553.             rvalue(lval);
  554.         gneg();
  555.         return (0);
  556.     }
  557.     else
  558.     if (match("~"))
  559.     {
  560.         k = heir10(lval);
  561.         if (k)
  562.             rvalue(lval);
  563.         gcom();
  564.         return (0);
  565.     }
  566.     else
  567.     if (match("!"))
  568.     {
  569.         k = heir10(lval);
  570.         if (k)
  571.             rvalue(lval);
  572.         glneg();
  573.         return (0);
  574.     }
  575.     else
  576.     if (ch() == '*' && nch() != '=')
  577.     {
  578.         inbyte();
  579.         k = heir10(lval);
  580.         if (k)
  581.             rvalue(lval);
  582.         if (NULL!=(ptr = (char *)lval[0]))       /* HJB 02/29/00 */
  583.             lval[1] = ptr[TYPE];
  584.         else
  585.             lval[1] = CINT;
  586.         lval[2] = 0;                   /* flag as not pointer or array */
  587.         return (1);
  588.     }
  589.     else
  590.     if (ch() == '&' && nch() != '&' && nch() != '=')
  591.     {
  592.         inbyte();
  593.         k = heir10(lval);
  594.         if (k == 0)
  595.         {
  596.             error("illegal address");
  597.             return (0);
  598.         }
  599.         if (NULL!=(ptr = (char *)lval[0]))        /* HJB 02/29/00 */
  600.             lval[2] = ptr[TYPE];
  601.         if (lval[1])
  602.             return (0);
  603.         /* global and non-array */
  604.         immed();
  605.         prefix();
  606.         outstr((ptr = (char *)lval[0]));
  607.         nl();
  608.         lval[1] = ptr[TYPE];
  609.         return (0);
  610.     }
  611.     else
  612.     {
  613.         k = heir11(lval);
  614.         if (match("++"))
  615.         {
  616.             if (k == 0)
  617.             {
  618.                 needlval();
  619.                 return (0);
  620.             }
  621.             if (lval[1])
  622.                 gpush();
  623.             rvalue(lval);
  624.             ginc(lval);
  625.             store(lval);
  626.             gdec(lval);
  627.             return (0);
  628.         }
  629.         else
  630.         if (match("--"))
  631.         {
  632.             if (k == 0)
  633.             {
  634.                 needlval();
  635.                 return (0);
  636.             }
  637.             if (lval[1])
  638.                 gpush();
  639.             rvalue(lval);
  640.             gdec(lval);
  641.             store(lval);
  642.             ginc(lval);
  643.             return (0);
  644.         }
  645.         else
  646.             return (k);
  647.     }
  648. }
  649.  
  650. int heir11(int lval[])
  651. {
  652.     int k;
  653.     char *ptr;
  654.  
  655.     k = primary(lval);
  656.     ptr = (char *)lval[0];
  657.     blanks();
  658.     if (ch() == '[' || ch() == '(')
  659.     for (;;)
  660.     {
  661.         if (match("["))
  662.         {
  663.             if (ptr == 0)
  664.             {
  665.                 error("can't subscript");
  666.                 junk();
  667.                 needbrack("]");
  668.                 return (0);
  669.             }
  670.             else
  671.             if (ptr[IDENT] == POINTER)
  672.                 rvalue(lval);
  673.             else
  674.             if (ptr[IDENT] != ARRAY)
  675.             {
  676.                 error("can't subscript");
  677.                 k = 0;
  678.             }
  679.             gpush();
  680.             expression(YES);
  681.             needbrack("]");
  682.             if (ptr[TYPE] == CINT)
  683.                 gaslint();
  684.             gadd(NULL, NULL);
  685.             lval[0] = 0;
  686.             lval[1] = ptr[TYPE];
  687.             k = 1;
  688.         }
  689.         else
  690.         if (match("("))
  691.         {
  692.             if (ptr == 0)
  693.                 callfunction(0);
  694.             else
  695.             if (ptr[IDENT] != FUNCTION)
  696.             {
  697.                 rvalue(lval);
  698.                 callfunction(0);
  699.             }
  700.             else
  701.                 callfunction(ptr);
  702.             k = lval[0] = 0;
  703.         }
  704.         else
  705.             return (k);
  706.     }
  707.     if (ptr == 0)
  708.         return (k);
  709.     if (ptr[IDENT] == FUNCTION)
  710.     {
  711.         immed();
  712.         prefix();
  713.         outstr(ptr);
  714.         nl();
  715.         return (0);
  716.     }
  717.     return (k);
  718. }
  719.  
  720.