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 / CC34.C < prev    next >
C/C++ Source or Header  |  1988-05-15  |  17KB  |  767 lines
  1. /*      >>>>> start of cc3 <<<<<<<<<    */
  2.  
  3. /* 3/3/88 */
  4.  
  5. /*                                      */
  6. /*      Perform a function call         */
  7. /*                                      */
  8. /* called from heir11, this routine will either call */
  9. /*      the named function, or if the supplied ptr is */
  10. /*      zero, will call the contents of BX              */
  11. callfunction(ptr)
  12.         char *ptr;      /* symbol table entry (or 0) */
  13. {       int nargs;
  14.         nargs=0;
  15.         blanks();       /* already saw open paren */
  16.         if(ptr==0)zpush();      /* calling BX */
  17.         while(streq(line+lptr,")")==0)
  18.                 {if(endst())break;
  19.                 expression();   /* get an argument */
  20.                 if(ptr==0)swapstk(); /* don't push addr */
  21.                 zpush();        /* push argument */
  22.                 nargs=nargs+4;  /* count args*4 */
  23.                 if (match(",")==0) break;
  24.                 }
  25.         needbrack(")");
  26.         if(ptr)zcall(ptr);
  27.         else callstk();
  28.         Zsp=modstk(Zsp+nargs);  /* clean up arguments */
  29. }
  30.  
  31. junk()
  32. {       if(an(inbyte()))
  33.                 while(an(ch()))gch();
  34.         else while(an(ch())==0)
  35.                 {if(ch()==0)break;
  36.                 gch();
  37.                 }
  38.         blanks();
  39. }
  40.  
  41. endst()
  42. {       blanks();
  43.         return ((streq(line+lptr,";")|(ch()==0)));
  44. }
  45.  
  46. illname()
  47. {       error("illegal symbol name");junk();}
  48.  
  49. multidef(sname)
  50.         char *sname;
  51. {       error("already defined");
  52.         comment();
  53.         outstr(sname);nl();
  54. }
  55.  
  56. needbrack(str)
  57.         char *str;
  58.         {
  59.         if(match(str)==0)
  60.                 {
  61.                 error("missing bracket");
  62.                 comment();outstr(str);nl();
  63.                 }
  64.         }
  65.  
  66. needlval()
  67.         {
  68.         error("must be lvalue");
  69.         }
  70.  
  71. findglb(sname)
  72.         char *sname;
  73.         {
  74.         char *ptr;
  75.         ptr=startglb;
  76.         while(ptr!=glbptr)
  77.                 {if(astreq(sname,ptr,namemax))return ptr;
  78.                 ptr=ptr+symsiz;
  79.                 }
  80.         return 0;
  81.         }
  82.  
  83. findloc(sname)
  84.         char *sname;
  85.         {
  86.         char *ptr;
  87.         ptr=startloc;
  88.         while(ptr!=locptr)
  89.                 {if(astreq(sname,ptr,namemax))return ptr;
  90.                 ptr=ptr+symsiz;
  91.                 }
  92.         return 0;
  93.         }
  94.  
  95. addglb(sname, class, typ, value)
  96.         char *sname, class, typ;
  97.         int value;
  98.         {
  99.         char *ptr;
  100.         if(cptr=findglb(sname))
  101.                 return cptr;
  102.         if(glbptr>=endglb)
  103.                 {
  104.                 error("global symbol table overflow");
  105.                 return 0;
  106.                 }
  107.         cptr=ptr=glbptr;
  108.         while (an(*ptr++ = *sname++));  /* copy name */
  109.         cptr[ident]=class;
  110.         cptr[type]=typ;
  111.         cptr[storage]=statik;
  112.         cptr[offset]=value;
  113.         cptr[offset+1]=value>>8;
  114.         glbptr=glbptr+symsiz;
  115.         return cptr;
  116.         }
  117.  
  118. addloc(sname, class, typ, value)
  119.         char *sname, class, typ;
  120.         int value;
  121.         {
  122.         char *ptr;
  123.         if(cptr=findloc(sname))
  124.                 return cptr;
  125.         if(locptr>=endloc)
  126.                 {
  127.                 error("local symbol table overflow");
  128.                 return 0;
  129.                 }
  130.         cptr=ptr=locptr;
  131.         while(an(*ptr++ = *sname++));   /* copy name */
  132.         cptr[ident]=class;
  133.         cptr[type]=typ;
  134.         cptr[storage]=stkloc;
  135.         cptr[offset]=value;
  136.         cptr[offset+1]=value>>8;
  137.         locptr=locptr+symsiz;
  138.         return cptr;
  139.         }
  140.  
  141. addext(sname, id)
  142.         char *sname, id;
  143.         {
  144.         char *ptr;
  145.         if(cptr=findext(sname)) return cptr;
  146.         if(extptr>=endextrn)
  147.                 {error("external symbol table overflow"); return 0;}
  148.         cptr=ptr=extptr;
  149.         while(an(*ptr++=*sname++)); /* copy name */
  150.         /* type stored in byte following zero terminating name */
  151.         *ptr++=id;
  152.         extptr=ptr;
  153.         return cptr;
  154.         }
  155.  
  156. findext(sname)
  157.         char *sname;
  158.         {
  159.         char *ptr;
  160.         ptr=startextrn;
  161.         while(ptr<extptr)
  162.                 {
  163.                 if(astreq(sname,ptr,namemax))
  164.                         return ptr;
  165.                 ptr=ptr+strlen(ptr)+2;
  166.                 }
  167.         return 0;
  168.         }
  169.  
  170. /* Test if next input string is legal symbol name */
  171. symname(sname)
  172.         char *sname;
  173.         {
  174.         int k; char c;
  175.         blanks();
  176.         if(alpha(ch())==0)
  177.                 return 0;
  178.         k=0;
  179.         while (an(ch()))
  180.                 sname[k++]=gch();
  181.         sname[k]=0;
  182.         return 1;
  183.         }
  184.  
  185. /* Return next avail internal label number */
  186. getlabel()
  187.         {
  188.         return(++nxtlab);
  189.         }
  190.  
  191. /* Print specified number as label */
  192. printlabel(label)
  193.         int label;
  194.         {
  195.         outasm("cc");
  196.         outdec(label);
  197.         }
  198.  
  199. /* Test if given character is alpha */
  200. alpha(c)
  201.         char c;
  202.         {
  203.         c=c&127;
  204.         return (((c>='a')&(c<='z')) | ((c>='A')&(c<='Z')) | (c=='_'));
  205.         }
  206.  
  207. /* Test if given character is numeric */
  208. numeric(c)
  209.         char c;
  210.         {
  211.         c=c&127;
  212.         return ((c>='0') & (c<='9'));
  213.         }
  214.  
  215. /* Test if given character is alphanumeric */
  216. an(c)
  217.         char c;
  218.         {
  219.         return ((alpha(c)) | (numeric(c)));
  220.         }
  221.  
  222. /* Print a carriage return and a string only to console */
  223. pl(str)
  224.         char *str;
  225.         {
  226.         int k;
  227.         k=0;
  228.         putchar(hosteol);
  229.         while (str[k])
  230.                 putchar(str[k++]);
  231.         }
  232.  
  233. addwhile(ptr)
  234.         int ptr[];
  235.         {
  236.         int k;
  237.         if (wqptr==wqmax)
  238.                 {
  239.                 error("too many active whiles");
  240.                 return;
  241.                 }
  242.         k=0;
  243.         while (k<wqsiz)
  244.                 {*wqptr++ = ptr[k++];}
  245.         }
  246.  
  247. delwhile()
  248.         {
  249.         if(readwhile())
  250.                 wqptr=wqptr-wqsiz;
  251.         }
  252.  
  253. readwhile()
  254.         {
  255.         if(wqptr==wq)
  256.                 {
  257.                 error("no active whiles");
  258.                 return 0;
  259.                 }
  260.         else return (wqptr-wqsiz);
  261.         }
  262.  
  263. ch()
  264.         {
  265.         return (line[lptr]&127);
  266.         }
  267.  
  268. nch()
  269.         {
  270.         if(ch()==0)
  271.                 return 0;
  272.         else return(line[lptr+1]&127);
  273.         }
  274.  
  275. gch()
  276.         {
  277.         if(ch()==0)
  278.                 return 0;
  279.         else return(line[lptr++]&127);
  280.         }
  281.  
  282. kill()
  283.         {
  284.         lptr=0;
  285.         line[lptr]=0;
  286.         }
  287.  
  288. inbyte()
  289.         {
  290.         while(ch()==0)
  291.                 {
  292.                 if(eof)
  293.                         return 0;
  294.                 inline();
  295.                 preprocess();
  296.                 }
  297.         return gch();
  298.         }
  299.  
  300. inchar()
  301.         {
  302.         if(ch()==0)
  303.                 inline();
  304.         if(eof)
  305.                 return 0;
  306.         return(gch());
  307.         }
  308.  
  309. inline()
  310.         {
  311.         int k, unit;
  312.         while(1)
  313.                 {
  314.                 if(input==0)
  315.                         {
  316.                         eof=1;
  317.                         return;
  318.                         }
  319.                 if((unit=input2)==0)
  320.                         unit=input;
  321.                 kill();
  322.                 while ((k=getc(unit))>0)
  323.                         {
  324.                         if((k==hosteol) | (lptr>=linemax))
  325.                                 break;
  326.                         line[lptr++]=k;
  327.                         }
  328.                 line[lptr]=0;   /* append null */
  329.                 lineno++;       /* read one more line           gtf 7/2/80 */
  330.                 if(k<=0)
  331.                         {
  332.                         fclose(unit);
  333.                         if(input2)
  334.                                 endinclude();           /* gtf 7/16/80 */
  335.                         else input=0;
  336.                         }
  337.                 if(lptr)
  338.                         {
  339.                         if((ctext) & (cmode))
  340.                                 {
  341.                                 comment();
  342.                                 outstr(line);
  343.                                 nl();
  344.                                 }
  345.                 lptr=0;
  346.                         return;
  347.                         }
  348.                 }
  349.         }
  350.  
  351. /*      >>>>>> start of cc4 <<<<<<<     */
  352.  
  353. preprocess()
  354.         {
  355.         int k;
  356.         char c, sname[namesize];
  357.         if(cmode==0)
  358.                 return;
  359.         mptr=lptr=0;
  360.         while(ch())
  361.                 {
  362.                 if((ch()==' ') | (ch()==9))
  363.                         predel();
  364.                 else if(ch()=='"')
  365.                         prequote();
  366.                 else if(ch()==39)
  367.                         preapos();
  368.                 else if((ch()=='/') & (nch()=='*'))
  369.                         precomm();
  370.                 else if(alpha(ch()))    /* from an(): 9/22/80 gtf */
  371.                         {
  372.                         k=0;
  373.                         while(an(ch()))
  374.                                 {
  375.                                 if(k<namemax)
  376.                                         sname[k++]=ch();
  377.                                 gch();
  378.                                 }
  379.                         sname[k]=0;
  380.                         if(k=findmac(sname))
  381.                                 while(c=macq[k++])
  382.                                         keepch(c);
  383.                         else
  384.                                 {
  385.                                 k=0;
  386.                                 while(c=sname[k++])
  387.                                         keepch(c);
  388.                                 }
  389.                         }
  390.                 else keepch(gch());
  391.                 }
  392.         keepch(0);
  393.         if(mptr>=mpmax)
  394.                 error("line too long");
  395.         lptr=mptr=0;
  396.         while (line[lptr++]=mline[mptr++]);
  397.         lptr=0;
  398.         }
  399.  
  400. keepch(c)
  401.         char c;
  402.         {
  403.         mline[mptr]=c;
  404.         if(mptr<mpmax)mptr++;
  405.         return c;
  406.         }
  407.  
  408. predel()
  409.         {keepch(' ');
  410.         while((ch()==' ')|
  411.                 (ch()==9))
  412.                 gch();
  413.         }
  414.  
  415. prequote()
  416.         {keepch(ch());
  417.         gch();
  418.         while(ch()!='"')
  419.                 {
  420.                 if(ch()==0)
  421.                         {
  422.                         error("missing quote");
  423.                         break;
  424.                         }
  425.                 keepch(gch());
  426.                 }
  427.         gch();
  428.         keepch('"');
  429.         }
  430.  
  431. preapos()
  432.         {
  433.         keepch(39);
  434.         gch();
  435.         while(ch()!=39)
  436.                 {
  437.                 if(ch()==0)
  438.                         {
  439.                         error("missing apostrophe");
  440.                         break;
  441.                         }
  442.                 keepch(gch());
  443.                 }
  444.         gch();
  445.         keepch(39);
  446.         }
  447.  
  448. precomm()
  449.         {
  450.         inchar();
  451.         inchar();
  452.         while (((ch()=='*') & (nch()=='/'))==0)
  453.                 {
  454.                 if(ch()==0)
  455.                         inline();
  456.                 else inchar();
  457.                 if(eof)
  458.                         break;
  459.                 }
  460.         inchar();
  461.         inchar();
  462.         }
  463.  
  464. addmac()
  465.         {
  466.         char sname[namesize];
  467.         int k;
  468.         if(symname(sname)==0)
  469.                 {
  470.                 illname();
  471.                 kill();
  472.                 return;
  473.                 }
  474.         k=0;
  475.         while (putmac(sname[k++]));
  476.         while(ch()==' ' | ch()==9)
  477.                 gch();
  478.         while (putmac(gch()));
  479.         if(macptr>=macmax)
  480.                 error("macro table full");
  481.         }
  482.  
  483. putmac(c)
  484.         char c;
  485.         {       macq[macptr]=c;
  486.         if(macptr<macmax)macptr++;
  487.         return c;
  488. }
  489.  
  490. findmac(sname)
  491.         char *sname;
  492.         {
  493.         int k;
  494.         k=0;
  495.         while(k<macptr)
  496.                 {
  497.                 if(astreq(sname,macq+k,namemax))
  498.                         {
  499.                         while (macq[k++]);
  500.                         return k;
  501.                         }
  502.                 while(macq[k++]);
  503.                 while(macq[k++]);
  504.                 }
  505.         return 0;
  506.         }
  507.  
  508. /* direct output to console             gtf 7/16/80 */
  509. toconsole()
  510.         {
  511.         saveout = output;
  512.         output = 0;
  513.         }
  514.  
  515. /* direct output back to file           gtf 7/16/80 */
  516. tofile()
  517.         {
  518.         if(saveout)
  519.                 output = saveout;
  520.         saveout = 0;
  521.         }
  522.  
  523. outbyte(c)
  524.         char c;
  525.         {
  526.         if(c==0)
  527.                 return 0;
  528.         if(output)
  529.                 {
  530.                 if((putc(c,output))<=0)
  531.                         {
  532.                         closeout();
  533.                         error("Output file error");
  534.                         abort();                        /* gtf 7/17/80 */
  535.                         }
  536.                 }
  537.         else putchar(c);
  538.         return c;
  539.         }
  540.  
  541. outstr(ptr)
  542.         char ptr[];
  543.         {
  544.         int k;
  545.         k=0;
  546.         while (outbyte(ptr[k++]));
  547.         }
  548.  
  549. /* write text destined for the assembler to read */
  550. /* (i.e. stuff not in comments)                 */
  551. /*  gtf  6/26/80 */
  552. outasm(ptr)
  553.         char *ptr;
  554.         {
  555.         while (outbyte(raise(*ptr++)));
  556.         }
  557.  
  558. nl()
  559.         {
  560.         if(output)
  561.                 outbyte(targeol);
  562.         else outbyte(hosteol);
  563.         }
  564.  
  565. tab()
  566.         {
  567.         outbyte(32);
  568.         }
  569.  
  570. col()
  571.         {
  572.         outbyte(58);
  573.         }
  574.  
  575. error(ptr)
  576.         char ptr[];
  577.         {
  578.         int k;
  579.         char junk[81];
  580.         toconsole();
  581.         bell();
  582.         outstr("Line ");
  583.         outdec(lineno);
  584.         outstr(", ");
  585.         if(infunc==0)
  586.                 outbyte('(');
  587.         if(currfn==NULL)
  588.                 outstr("start of file");
  589.         else outstr(currfn+name);
  590.         if(infunc==0)
  591.                 outbyte(')');
  592.         outstr(" + ");
  593.         outdec(lineno-fnstart);
  594.         outstr(": ");
  595.         outstr(ptr);
  596.         nl();
  597.         outstr(line);
  598.         nl();
  599.         k=0;    /* skip to error position */
  600.         while(k<lptr)
  601.                 {
  602.                 if(line[k++]==9)
  603.                         tab();
  604.                 else    outbyte(' ');
  605.                 }
  606.         outbyte('^');
  607.         nl();
  608.         ++errcnt;
  609.         if(errstop)
  610.                 {
  611.                 pl("Continue (Y,n,g) ? ");
  612.                 gets(junk);
  613.                 k=junk[0];
  614.                 if((k=='N') | (k=='n'))
  615.                         abort();
  616.                 if((k=='G') | (k=='g'))
  617.                         errstop=0;
  618.                 }
  619.         tofile();
  620.         }
  621.  
  622. ol(ptr)
  623.         char ptr[];
  624.         {
  625.         ot(ptr);
  626.         nl();
  627.         }
  628.  
  629. ot(ptr)
  630.         char ptr[];
  631.         {
  632.         tab();
  633.         outasm(ptr);
  634.         }
  635.  
  636. streq(str1,str2)
  637.         char str1[],str2[];
  638.         {
  639.         int k;
  640.         k=0;
  641.         while (str2[k])
  642.                 {
  643.                 if((str1[k])!=(str2[k]))
  644.                         return 0;
  645.                 k++;
  646.                 }
  647.         return k;
  648.         }
  649.  
  650. astreq(str1,str2,len)
  651.         char str1[], str2[];
  652.         int len;
  653.         {
  654.         int k;
  655.         k=0;
  656.         while (k<len)
  657.                 {
  658.                 if((str1[k])!=(str2[k]))
  659.                         break;
  660.                 if(str1[k]==0)
  661.                         break;
  662.                 if(str2[k]==0)
  663.                         break;
  664.                 k++;
  665.                 }
  666.         if(an(str1[k]))
  667.                 return 0;
  668.         if(an(str2[k]))
  669.                 return 0;
  670.         return k;
  671.         }
  672.  
  673. match(lit)
  674.         char *lit;
  675.         {
  676.         int k;
  677.         blanks();
  678.         if(k=streq(line+lptr,lit))
  679.                 {
  680.                 lptr=lptr+k;
  681.                 return 1;
  682.                 }
  683.         return 0;
  684.         }
  685.  
  686. amatch(lit, len)
  687.         char *lit;
  688.         int len;
  689.         {
  690.         int k;
  691.         blanks();
  692.         if(k=astreq(line+lptr,lit,len))
  693.                 {
  694.                 lptr=lptr+k;
  695.                 while (an(ch()))
  696.                         inbyte();
  697.                 return 1;
  698.                 }
  699.         return 0;
  700.         }
  701.  
  702. blanks()
  703.         {
  704.                 while(1)
  705.                 {
  706.                         while(ch()==0)
  707.                         {
  708.                         inline();
  709.                         preprocess();
  710.                         if(eof)
  711.                                 break;
  712.                         }
  713.                 if(ch()==' ')
  714.                         gch();
  715.                 else if(ch()==9)
  716.                         gch();
  717.                 else return;
  718.                 }
  719.         }
  720.  
  721. outdec(number)
  722.         int number;
  723.         {
  724.         int k, zs;
  725.         char c;
  726.         zs = 0;
  727.         k=10000;
  728.         if(number<0)
  729.                 {
  730.                 number=(-number);
  731.                 outbyte('-');
  732.                 }
  733.         while (k>=1)
  734.                 {
  735.                 c=number/k + '0';
  736.                 if ((c!='0') | (k==1) | (zs))
  737.                         {
  738.                         zs=1;
  739.                         outbyte(c);
  740.                         }
  741.                 number=number%k;
  742.                 k=k/10;
  743.                 }
  744.         }
  745.  
  746. /* return the length of a string */
  747. /* gtf 4/8/80 */
  748. strlen(s)
  749. char *s;
  750. {       
  751.         char *t;
  752.         t = s;
  753.         while(*s)
  754.                 s++;
  755.         return (s-t);
  756.         }
  757.  
  758. /* convert lower case to upper */
  759. /* gtf 6/26/80 */
  760. raise(c)
  761.         char c;
  762.         {
  763.         if((c>='a') & (c<='z'))
  764.                 c = c - 'a' + 'A';
  765.         return (c);
  766.         }
  767.