home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 100-199 / ff141.lzh / SmallC / CCEXPR.C < prev    next >
Text File  |  1988-05-15  |  17KB  |  626 lines
  1. /*      >>>>>>> start of cc5 <<<<<<<    */
  2.  
  3. /* 2/23/88 */
  4.  
  5. expression()
  6.         {
  7.         int lval[2];
  8.         if(heir1(lval))
  9.                 rvalue(lval);
  10.         }
  11.  
  12. heir1(lval)
  13.         int lval[];
  14.         {
  15.         int k, lval2[2];
  16.         k=heir2(lval);
  17.         if(match("="))
  18.                 {
  19.                 if(k==0)
  20.                         {
  21.                         needlval();
  22.                         return 0;
  23.                         }
  24.                 if (lval[1])
  25.                         zpush();
  26.                 if(heir1(lval2))
  27.                         rvalue(lval2);
  28.                 store(lval);
  29.                 return 0;
  30.                 }
  31.         else return k;
  32.         }
  33.  
  34. heir2(lval)
  35.         int lval[];
  36.         {
  37.         int k, lval2[2];
  38.         k=heir3(lval);
  39.         blanks();
  40.         if(ch()!='|')
  41.                 return k;
  42.         if(k)
  43.                 rvalue(lval);
  44.         while(1)
  45.                 {
  46.                 if(match("|"))
  47.                         {
  48.                         zpush();
  49.                         if(heir3(lval2))
  50.                                 rvalue(lval2);
  51.                         zpop();
  52.                         zor();
  53.                         }
  54.                 else return 0;
  55.                 }
  56.         }
  57.  
  58. heir3(lval)
  59.         int lval[];
  60.         {
  61.         int k, lval2[2];
  62.         k=heir4(lval);
  63.         blanks();
  64.         if(ch()!='^')
  65.                 return k;
  66.         if(k)
  67.                 rvalue(lval);
  68.         while(1)
  69.                 {
  70.                 if (match("^"))
  71.                         {
  72.                         zpush();
  73.                         if(heir4(lval2))
  74.                                 rvalue(lval2);
  75.                         zpop();
  76.                         zxor();
  77.                         }
  78.                 else return 0;
  79.                 }
  80.         }
  81.  
  82. heir4(lval)
  83.         int lval[];
  84.         {
  85.         int k, lval2[2];
  86.         k=heir5(lval);
  87.         blanks();
  88.         if(ch()!='&')
  89.                 return k;
  90.         if(k)
  91.                 rvalue(lval);
  92.         while(1)
  93.                 {
  94.                 if(match("&"))
  95.                         {
  96.                         zpush();
  97.                         if(heir5(lval2))
  98.                                 rvalue(lval2);
  99.                         zpop();
  100.                         zand();
  101.                         }
  102.                 else return 0;
  103.                 }
  104.         }
  105.  
  106. heir5(lval)
  107.         int lval[];
  108.         {
  109.         int k, lval2[2];
  110.         k=heir6(lval);
  111.         blanks();
  112.         if((streq(line+lptr,"==")==0) & (streq(line+lptr,"!=")==0))
  113.                 return k;
  114.         if(k)
  115.                 rvalue(lval);
  116.         while(1)
  117.                 {
  118.                 if (match("=="))
  119.                         {
  120.                         zpush();
  121.                         if(heir6(lval2))
  122.                                 rvalue(lval2);
  123.                         zpop();
  124.                         zeq();
  125.                         }
  126.                 else if (match("!="))
  127.                         {
  128.                         zpush();
  129.                         if(heir6(lval2))
  130.                                 rvalue(lval2);
  131.                         zpop();
  132.                         zne();
  133.                         }
  134.                 else return 0;
  135.                 }
  136.         }
  137.  
  138. heir6(lval)
  139.         int lval[];
  140.         {
  141.         int k;
  142.         k=heir7(lval);
  143.         blanks();
  144.         if((streq(line+lptr,"<")==0)&
  145.                 (streq(line+lptr,">")==0)&
  146.                 (streq(line+lptr,"<=")==0)&
  147.                 (streq(line+lptr,">=")==0))
  148.                         return k;
  149.         if(streq(line+lptr,">>"))
  150.                 return k;
  151.         if(streq(line+lptr,"<<"))
  152.                 return k;
  153.         if(k)
  154.                 rvalue(lval);
  155.         while(1)
  156.                 {
  157.                 if (match("<="))
  158.                         {
  159.                         if(heir6wrk(1,lval)) continue;
  160.                         zle();
  161.                         }
  162.                 else if (match(">="))
  163.                         {
  164.                         if(heir6wrk(2,lval)) continue;
  165.                         zge();
  166.                         }
  167.                 else if((streq(line+lptr,"<")) & (streq(line+lptr,"<<")==0))
  168.                         {
  169.                         inbyte();
  170.                         if(heir6wrk(3,lval)) continue;
  171.                         zlt();
  172.                         }
  173.                 else if((streq(line+lptr,">")) & (streq(line+lptr,">>")==0))
  174.                         {
  175.                         inbyte();
  176.                         if(heir6wrk(4,lval)) continue;
  177.                         zgt();
  178.                         }
  179.                 else return 0;
  180.                 }
  181.         }
  182.  
  183. heir6wrk(k,lval)
  184.         int k,lval[];
  185.         {
  186.         int lval2[2];
  187.         zpush();
  188.         if(heir7(lval2))
  189.                 rvalue(lval2);
  190.         zpop();
  191.         if(cptr=lval[0])
  192.                 if(cptr[ident]==pointer)
  193.                         {
  194.                         heir6op(k);
  195.                         return 1;
  196.                         }
  197.         if(cptr=lval2[0])
  198.                 if(cptr[ident]==pointer)
  199.                         {
  200.                         heir6op(k);
  201.                         return 1;
  202.                         }
  203.         return 0;
  204.         }
  205.  
  206. heir6op(k)
  207.         int k;
  208.         {
  209.         if(k==1)
  210.                 ule();
  211.         else if(k==2)
  212.                 uge();
  213.         else if(k==3)
  214.                 ult();
  215.         else ugt();
  216.         }
  217.  
  218. /*      >>>>>> start of cc6 <<<<<<      */
  219.  
  220. heir7(lval)
  221.         int lval[];
  222.         {
  223.         int k, lval2[2];
  224.         k=heir8(lval);
  225.         blanks();
  226.         if((streq(line+lptr,">>")==0) & (streq(line+lptr,"<<")==0))
  227.                 return k;
  228.         if(k)
  229.                 rvalue(lval);
  230.         while(1)
  231.                 {
  232.                 if (match(">>"))
  233.                         {
  234.                         zpush();
  235.                         if(heir8(lval2))
  236.                                 rvalue(lval2);
  237.                         zpop();
  238.                         asr();
  239.                         }
  240.                 else if (match("<<"))
  241.                         {
  242.                         zpush();
  243.                         if(heir8(lval2))
  244.                                 rvalue(lval2);
  245.                         zpop();
  246.                         asl();
  247.                         }
  248.                 else return 0;
  249.                 }
  250.         }
  251.  
  252. heir8(lval)
  253.         int lval[];
  254.         {
  255.         int k, lval2[2];
  256.         k=heir9(lval);
  257.         blanks();
  258.         if((ch()!='+') & (ch()!='-'))
  259.                 return k;
  260.         if(k)
  261.                 rvalue(lval);
  262.         while(1)
  263.                 {if (match("+"))
  264.                         {
  265.                         zpush();
  266.                         if(heir9(lval2))
  267.                                 rvalue(lval2);
  268.                         if(cptr=lval[0])
  269.                                 if((cptr[ident]==pointer) & (cptr[type]==cint))
  270.                                         doublereg();
  271.                         zpop();
  272.                         zadd();
  273.                         }
  274.                 else if (match("-"))
  275.                         {
  276.                         zpush();
  277.                         if(heir9(lval2))
  278.                                 rvalue(lval2);
  279.                         if(cptr=lval[0])
  280.                                 if((cptr[ident]==pointer) & (cptr[type]==cint))
  281.                                         doublereg();
  282.                         zpop();
  283.                         zsub();
  284.                         }
  285.                 else return 0;
  286.                 }
  287.         }
  288.  
  289. heir9(lval)
  290.         int lval[];
  291.         {
  292.         int k, lval2[2];
  293.         k=heir10(lval);
  294.         blanks();
  295.         if((ch()!='*') & (ch()!='/') & (ch()!='%'))
  296.                 return k;
  297.         if(k)
  298.                 rvalue(lval);
  299.         while(1)
  300.                 {
  301.                 if (match("*"))
  302.                         {
  303.                         zpush();
  304.                         if(heir9(lval2))
  305.                                 rvalue(lval2);
  306.                         zpop();
  307.                         mult();
  308.                         }
  309.                 else if (match("/"))
  310.                         {
  311.                         zpush();
  312.                         if(heir10(lval2))
  313.                                 rvalue(lval2);
  314.                         zpop();
  315.                         div();
  316.                         }
  317.                 else if (match("%"))
  318.                         {
  319.                         zpush();
  320.                         if(heir10(lval2))
  321.                                 rvalue(lval2);
  322.                         zpop();
  323.                         zmod();
  324.                         }
  325.                 else return 0;
  326.                 }
  327.         }
  328.  
  329. heir10(lval)
  330.         int lval[];
  331.         {
  332.         int k;
  333.         if(match("++"))
  334.                 {
  335.                 if((k=heir10(lval))==0)
  336.                         {
  337.                         needlval();
  338.                         return 0;
  339.                         }
  340.                 heir10inc(lval);
  341.                 return 0;
  342.                 }
  343.         else if(match("--"))
  344.                 {
  345.                 if((k=heir10(lval))==0)
  346.                         {
  347.                         needlval();
  348.                         return 0;
  349.                         }
  350.                 heir10dec(lval);
  351.                 return 0;
  352.                 }
  353.         else if (match("-"))
  354.                 {
  355.                 k=heir10(lval);
  356.                 if(k)
  357.                         rvalue(lval);
  358.                 neg();
  359.                 return 0;
  360.                 }
  361.         else if(match("*"))
  362.                 {
  363.                 heir10as(lval);
  364.                 return 1;
  365.                 }
  366.         else if(match("&"))
  367.                 {
  368.                 k=heir10(lval);
  369.                 if(k==0)
  370.                         {
  371.                         error("illegal address");
  372.                         return 0;
  373.                         }
  374.                 else if(lval[1])
  375.                         return 0;
  376.                 else
  377.                         {
  378.                         heir10at(lval);
  379.                         return 0;
  380.                         }
  381.                 }
  382.         else
  383.                 {
  384.                 k=heir11(lval);
  385.                 if(match("++"))
  386.                         {
  387.                         if(k==0)
  388.                                 {
  389.                                 needlval();
  390.                                 return 0;
  391.                                 }
  392.                         heir10id(lval);
  393.                         return 0;
  394.                         }
  395.                 else if(match("--"))
  396.                         {
  397.                         if(k==0)
  398.                                 {
  399.                                 needlval();
  400.                                 return 0;
  401.                                 }
  402.                         heir10di(lval);
  403.                         return 0;
  404.                         }
  405.                 else return k;
  406.                 }
  407.         }
  408.  
  409. heir10inc(lval)
  410.         int lval[];
  411.         {
  412.         char *ptr;
  413.         if(lval[1])
  414.                 zpush();
  415.         rvalue(lval);
  416.         inc();
  417.         ptr=lval[0];
  418.         if((ptr[ident]==pointer) & (ptr[type]==cint))
  419.                 add3();
  420.         store(lval);
  421.         }
  422.  
  423. heir10dec(lval)
  424.         int lval[];
  425.         {
  426.         char *ptr;
  427.         if(lval[1])
  428.                 zpush();
  429.         rvalue(lval);
  430.         dec();
  431.         ptr=lval[0];
  432.         if((ptr[ident]==pointer) & (ptr[type]==cint))
  433.                 sub3();
  434.         store(lval);
  435.         }
  436.  
  437. heir10as(lval)
  438.         int lval[];
  439.         {
  440.         int k;
  441.         char *ptr;
  442.         k=heir10(lval);
  443.         if(k)
  444.                 rvalue(lval);
  445.         lval[1]=cint;
  446.         if(ptr=lval[0])
  447.                 lval[1]=ptr[type];
  448.         lval[0]=0;
  449.         }
  450.  
  451. heir10at(lval)
  452.         int lval[];
  453.         {
  454.         char *ptr;
  455.         immlabel(ptr=lval[0]);
  456.         lval[1]=ptr[type];
  457.         }
  458.  
  459. heir10id(lval)
  460.         int lval[];
  461.         {
  462.         char *ptr;
  463.         if(lval[1])
  464.                 zpush();
  465.         rvalue(lval);
  466.         inc();
  467.         ptr=lval[0];
  468.         if((ptr[ident]==pointer) & (ptr[type]==cint))
  469.                 add3();
  470.         store(lval);
  471.         dec();
  472.         if((ptr[ident]==pointer) & (ptr[type]==cint))
  473.                 sub3();
  474.         }
  475.  
  476. heir10di(lval)
  477.         int lval[];
  478.         {
  479.         char *ptr;
  480.         if(lval[1])
  481.                 zpush();
  482.         rvalue(lval);
  483.         dec();
  484.         ptr=lval[0];
  485.         if((ptr[ident]==pointer) & (ptr[type]==cint))
  486.                 sub3();
  487.         store(lval);
  488.         inc();
  489.         if((ptr[ident]==pointer) & (ptr[type]==cint))
  490.                 add3();
  491.         }
  492.  
  493. /*      >>>>>>> start of cc7 <<<<<<<    */
  494.  
  495. heir11(lval)
  496.         int *lval;
  497.         {
  498.         int k;
  499.         char *ptr;
  500.         k=primary(lval);
  501.         ptr=lval[0];
  502.         blanks();
  503.         if((ch()=='[') | (ch()=='('))
  504.                 while(1)
  505.                         {
  506.                         if(match("["))
  507.                                 {
  508.                                 if(ptr==0)
  509.                                         {
  510.                                         error("can't subscript");
  511.                                         junk();
  512.                                         needbrack("]");
  513.                                         return 0;
  514.                                         }
  515.                                 else if(ptr[ident]==pointer)
  516.                                         rvalue(lval);
  517.                                 else if(ptr[ident]!=array)
  518.                                         {
  519.                                         error("can't subscript");
  520.                                         k=0;
  521.                                         }
  522.                                 zpush();
  523.                                 expression();
  524.                                 needbrack("]");
  525.                                 if((ptr[type])==cint)
  526.                                         doublereg();
  527.                                 zpop();
  528.                                 zadd();
  529.                                 lval[1]=ptr[type];
  530.                                 k=1;
  531.                                 }
  532.                         else if(match("("))
  533.                                 {
  534.                                 if(ptr==0)
  535.                                         {
  536.                                         callfunction(0);
  537.                                         }
  538.                                 else if(ptr[ident]!=function)
  539.                                         {
  540.                                         rvalue(lval);
  541.                                         callfunction(0);
  542.                                         }
  543.                                 else callfunction(ptr);
  544.                                 k=lval[0]=0;
  545.                                 }
  546.                         else return k;
  547.                         }
  548.         if(ptr==0)
  549.                 return k;
  550.         if(ptr[ident]==function)
  551.                 {
  552.                 immlabel(ptr);
  553.                 return 0;
  554.                 }
  555.         return k;
  556.         }
  557.  
  558. primary(lval)
  559.         int *lval;
  560.         {
  561.         char *ptr, sname[namesize];
  562.         int num[1];
  563.         int k;
  564.         if(match("("))
  565.                 {
  566.                 k=heir1(lval);
  567.                 needbrack(")");
  568.                 return k;
  569.                 }
  570.         if(symname(sname))
  571.                 {
  572.                 if(ptr=findloc(sname))
  573.                         {
  574.                         getloc(ptr);
  575.                         lval[0]=ptr;
  576.                         lval[1]=ptr[type];
  577.                         if(ptr[ident]==pointer)
  578.                                 lval[1]=cint;
  579.                         if((ptr[ident]==argument) & (ptr[type]==cchar))
  580.                                 lval[1]=cchararg;
  581.                         else if(ptr[ident]==array)
  582.                                 return 0;
  583.                         return 1;
  584.                         }
  585.                 if(ptr=findglb(sname))
  586.                         if(ptr[ident]!=function)
  587.                         {
  588.                         lval[0]=ptr;
  589.                         lval[1]=0;
  590.                         if(ptr[ident]!=array)
  591.                                 return 1;
  592.                         immlabel(ptr);
  593.                         return 0;
  594.                         }
  595.                 ptr=addglb(sname,function,cint,0);
  596.                 lval[0]=ptr;
  597.                 lval[1]=0;
  598.                 return 0;
  599.                 }
  600.         if(constant(num))
  601.                 return(lval[0]=lval[1]=0);
  602.         else
  603.                 {
  604.                 error("invalid expression");
  605.                 immval(0);
  606.                 junk();
  607.                 return 0;
  608.                 }
  609.         }
  610.  
  611. store(lval)
  612.         int *lval;
  613.         {
  614.         if (lval[1]==0)
  615.                 putmem(lval[0]);
  616.         else putstk(lval[1]);
  617.         }
  618.  
  619. rvalue(lval)
  620.         int *lval;
  621.         {
  622.         if((lval[0]!=0) & (lval[1]==0))
  623.                 getmem(lval[0]);
  624.         else indirect(lval[1]);
  625.         }
  626.