home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / src / cmd / lex / sub1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1979-01-10  |  11.9 KB  |  683 lines

  1. # include "ldefs.c"
  2. getl(p)    /* return next line of input, throw away trailing '\n' */
  3.     /* returns 0 if eof is had immediately */
  4.   char *p;
  5.     {
  6.     register int c;
  7.     register char *s, *t;
  8.     t = s = p;
  9.     while(((c = gch()) != 0) && c != '\n')
  10.         *t++ = c;
  11.     *t = 0;
  12.     if(c == 0 && s == t) return(0);
  13.     prev = '\n';
  14.     pres = '\n';
  15.     return(s);
  16.     }
  17. space(ch)
  18.     {
  19.     switch(ch)
  20.         {
  21.         case ' ':
  22.         case '\t':
  23.         case '\n':
  24.             return(1);
  25.         }
  26.     return(0);
  27.     }
  28.  
  29. digit(c)
  30. {
  31.     return(c>='0' && c <= '9');
  32. }
  33. error(s,p,d)
  34.     {
  35.     if(!eof)fprintf(errorf,"%d: ",yyline);
  36.     fprintf(errorf,"(Error) ");
  37.     fprintf(errorf,s,p,d);
  38.     putc('\n',errorf);
  39. # ifdef DEBUG
  40.     if(debug && sect != ENDSECTION) {
  41.         sect1dump();
  42.         sect2dump();
  43.     }
  44. # endif
  45.     if(
  46. # ifdef DEBUG
  47.         debug ||
  48. # endif
  49.         report == 1) statistics();
  50.     exit(1);    /* error return code */
  51.     }
  52.  
  53. warning(s,p,d)
  54.     {
  55.     if(!eof)fprintf(errorf,"%d: ",yyline);
  56.     fprintf(errorf,"(Warning) ");
  57.     fprintf(errorf,s,p,d);
  58.     putc('\n',errorf);
  59.     fflush(errorf);
  60.     fflush(fout);
  61.     fflush(stdout);
  62.     }
  63. index(a,s)
  64.     char *s;
  65. {
  66.     register int k;
  67.     for(k=0; s[k]; k++)
  68.         if (s[k]== a)
  69.             return(k);
  70.     return(-1);
  71.     }
  72.  
  73. alpha(c)
  74.   int c; {
  75. # ifdef ASCII
  76. return('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z');
  77. # endif
  78. # ifdef EBCDIC
  79. return(index(c,"abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") >= 0);
  80. # endif
  81. }
  82. printable(c)
  83. {
  84. # ifdef ASCII
  85. return( c>040 && c < 0177);
  86. # endif
  87. # ifdef EBCDIC
  88. return(index(c, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,;:><+*)('&%!-=\"")>=0);
  89. # endif
  90. }
  91. lgate()
  92. {
  93.     char fname[20];
  94.     if (lgatflg) return;
  95.     lgatflg=1;
  96.     if(fout == NULL){
  97.         sprintf(fname, "lex.yy.%c", ratfor ? 'r' : 'c' );
  98.         fout = fopen(fname, "w");
  99.         }
  100.     if(fout == NULL) error("Can't open %s",fname);
  101.     if(ratfor) fprintf( fout, "#\n");
  102.     phead1();
  103.     }
  104. /* scopy(ptr to str, ptr to str) - copy first arg str to second */
  105. /* returns ptr to second arg */
  106. scopy(s,t)
  107.   char *s, *t; {
  108.     register char *i;
  109.     i = t;
  110.     while(*i++ = *s++);
  111.     return;
  112.     }
  113. siconv(t)    /* convert string t, return integer value */
  114.   char *t; {
  115.     register int i,sw;
  116.     register char *s;
  117.     s = t;
  118.     while(!(('0' <= *s && *s <= '9') || *s == '-') && *s) s++;
  119.     sw = 0;
  120.     if(*s == '-'){    /* neg */
  121.         sw = 1;
  122.         s++;
  123.         }
  124.     i = 0;
  125.     while('0' <= *s && *s <= '9')
  126.         i = i * 10 + (*(s++)-'0');
  127.     return(sw ? -i : i);
  128.     }
  129. /* slength(ptr to str) - return integer length of string arg */
  130. /* excludes '\0' terminator */
  131. slength(s)
  132.   char *s; {
  133.     register int n;
  134.     register char *t;
  135.     t = s;
  136.     for (n = 0; *t++; n++);
  137.     return(n);
  138.     }
  139. /* scomp(x,y) - return -1 if x < y,
  140.         0 if x == y,
  141.         return 1 if x > y, all lexicographically */
  142. scomp(x,y)
  143.   char *x,*y; {
  144.     register char *a,*d;
  145.     a = x;
  146.     d = y;
  147.     while(*a || *d){
  148.         if(*a > *d)
  149.             return(1);    /* greater */
  150.         if(*a < *d)
  151.             return(-1);    /* less */
  152.         a++;
  153.         d++;
  154.         }
  155.     return(0);    /* equal */
  156.     }
  157. ctrans(ss)
  158.     char **ss;
  159. {
  160.     register int c, k;
  161.     if ((c = **ss) != '\\')
  162.         return(c);
  163.     switch(c= *++*ss)
  164.     {
  165.     case 'n': c = '\n'; break;
  166.     case 't': c = '\t'; break;
  167.     case 'r': c = '\r'; break;
  168.     case 'b': c = '\b'; break;
  169.     case 'f': c = 014; break;        /* form feed for ascii */
  170.     case '\\': c = '\\'; break;
  171.     case '0': case '1': case '2': case '3':
  172.     case '4': case '5': case '6': case '7':
  173.         c =- '0';
  174.         while ((k = *(*ss+1)) >= '0' && k <= '7')
  175.             {
  176.             c = c*8 + k - '0';
  177.             (*ss)++;
  178.             }
  179.         break;
  180.     }
  181.     return(c);
  182. }
  183. cclinter(sw)
  184.   int sw; {
  185.         /* sw = 1 ==> ccl */
  186.     register int i, j, k;
  187.     int m;
  188.     if(!sw){        /* is NCCL */
  189.         for(i=1;i<NCH;i++)
  190.             symbol[i] =^ 1;            /* reverse value */
  191.         }
  192.     for(i=1;i<NCH;i++)
  193.         if(symbol[i]) break;
  194.     if(i >= NCH) return;
  195.     i = cindex[i];
  196.     /* see if ccl is already in our table */
  197.     j = 0;
  198.     if(i){
  199.         for(j=1;j<NCH;j++){
  200.             if((symbol[j] && cindex[j] != i) ||
  201.                (!symbol[j] && cindex[j] == i)) break;
  202.             }
  203.         }
  204.     if(j >= NCH) return;        /* already in */
  205.     m = 0;
  206.     k = 0;
  207.     for(i=1;i<NCH;i++)
  208.         if(symbol[i]){
  209.             if(!cindex[i]){
  210.                 cindex[i] = ccount;
  211.                 symbol[i] = 0;
  212.                 m = 1;
  213.                 }
  214.             else k = 1;
  215.             }
  216.             /* m == 1 implies last value of ccount has been used */
  217.     if(m)ccount++;
  218.     if(k == 0) return;    /* is now in as ccount wholly */
  219.     /* intersection must be computed */
  220.     for(i=1;i<NCH;i++){
  221.         if(symbol[i]){
  222.             m = 0;
  223.             j = cindex[i];    /* will be non-zero */
  224.             for(k=1;k<NCH;k++){
  225.                 if(cindex[k] == j){
  226.                     if(symbol[k]) symbol[k] = 0;
  227.                     else {
  228.                         cindex[k] = ccount;
  229.                         m = 1;
  230.                         }
  231.                     }
  232.                 }
  233.             if(m)ccount++;
  234.             }
  235.         }
  236.     return;
  237.     }
  238. usescape(c)
  239.   int c; {
  240.     register char d;
  241.     switch(c){
  242.     case 'n': c = '\n'; break;
  243.     case 'r': c = '\r'; break;
  244.     case 't': c = '\t'; break;
  245.     case 'b': c = '\b'; break;
  246.     case 'f': c = 014; break;        /* form feed for ascii */
  247.     case '0': case '1': case '2': case '3':
  248.     case '4': case '5': case '6': case '7':
  249.         c =- '0';
  250.         while('0' <= (d=gch()) && d <= '7'){
  251.             c = c * 8 + (d-'0');
  252.             if(!('0' <= peek && peek <= '7')) break;
  253.             }
  254.         break;
  255.     }
  256.     return(c);
  257.     }
  258. lookup(s,t)
  259.   char *s;
  260.   char **t; {
  261.     register int i;
  262.     i = 0;
  263.     while(*t){
  264.         if(scomp(s,*t) == 0)
  265.             return(i);
  266.         i++;
  267.         t++;
  268.         }
  269.     return(-1);
  270.     }
  271. cpyact(){ /* copy C action to the next ; or closing } */
  272.     register int brac, c, mth;
  273.     int savline, sw;
  274.  
  275.     brac = 0;
  276.     sw = TRUE;
  277.  
  278. while(!eof){
  279.     c = gch();
  280. swt:
  281.     switch( c ){
  282.  
  283. case '|':    if(brac == 0 && sw == TRUE){
  284.             if(peek == '|')gch();        /* eat up an extra '|' */
  285.             return(0);
  286.             }
  287.         break;
  288.  
  289. case ';':
  290.         if( brac == 0 ){
  291.             putc(c,fout);
  292.             putc('\n',fout);
  293.             return(1);
  294.             }
  295.         break;
  296.  
  297. case '{':
  298.         brac++;
  299.         savline=yyline;
  300.         break;
  301.  
  302. case '}':
  303.         brac--;
  304.         if( brac == 0 ){
  305.             putc(c,fout);
  306.             putc('\n',fout);
  307.             return(1);
  308.             }
  309.         break;
  310.  
  311. case '/':    /* look for comments */
  312.         putc(c,fout);
  313.         c = gch();
  314.         if( c != '*' ) goto swt;
  315.  
  316.         /* it really is a comment */
  317.  
  318.         putc(c,fout);
  319.         savline=yyline;
  320.         while( c=gch() ){
  321.             if( c=='*' ){
  322.                 putc(c,fout);
  323.                 if( (c=gch()) == '/' ) goto loop;
  324.                 }
  325.             putc(c,fout);
  326.             }
  327.         yyline=savline;
  328.         error( "EOF inside comment" );
  329.  
  330. case '\'':    /* character constant */
  331.         mth = '\'';
  332.         goto string;
  333.  
  334. case '"':    /* character string */
  335.         mth = '"';
  336.  
  337.     string:
  338.  
  339.         putc(c,fout);
  340.         while( c=gch() ){
  341.             if( c=='\\' ){
  342.                 putc(c,fout);
  343.                 c=gch();
  344.                 }
  345.             else if( c==mth ) goto loop;
  346.             putc(c,fout);
  347.             if (c == '\n')
  348.                 {
  349.                 yyline--;
  350.                 error( "Non-terminated string or character constant");
  351.                 }
  352.             }
  353.         error( "EOF in string or character constant" );
  354.  
  355. case '\0':
  356.         yyline = savline;
  357.         error("Action does not terminate");
  358. default:
  359.         break;        /* usual character */
  360.         }
  361. loop:
  362.     if(c != ' ' && c != '\t' && c != '\n') sw = FALSE;
  363.     putc(c,fout);
  364.     }
  365. error("Premature EOF");
  366. }
  367. gch(){
  368.     register int c;
  369.     prev = pres;
  370.     c = pres = peek;
  371.     peek = pushptr > pushc ? *--pushptr : getc(fin);
  372.     if(peek == EOF && sargc > 1){
  373.         fclose(fin);
  374.         fin = fopen(sargv[++fptr],"r");
  375.         if(fin == NULL)
  376.             error("Cannot open file %s",sargv[fptr]);
  377.         peek = getc(fin);
  378.         sargc--;
  379.         sargv++;
  380.         }
  381.     if(c == EOF) {
  382.         eof = TRUE;
  383.         fclose(fin);
  384.         return(0);
  385.         }
  386.     if(c == '\n')yyline++;
  387.     return(c);
  388.     }
  389. mn2(a,d,c)
  390.   int a,d,c;
  391.     {
  392.     name[tptr] = a;
  393.     left[tptr] = d;
  394.     right[tptr] = c;
  395.     parent[tptr] = 0;
  396.     nullstr[tptr] = 0;
  397.     switch(a){
  398.     case RSTR:
  399.         parent[d] = tptr;
  400.         break;
  401.     case BAR:
  402.     case RNEWE:
  403.         if(nullstr[d] || nullstr[c]) nullstr[tptr] = TRUE;
  404.         parent[d] = parent[c] = tptr;
  405.         break;
  406.     case RCAT:
  407.     case DIV:
  408.         if(nullstr[d] && nullstr[c])nullstr[tptr] = TRUE;
  409.         parent[d] = parent[c] = tptr;
  410.         break;
  411.     case RSCON:
  412.         parent[d] = tptr;
  413.         nullstr[tptr] = nullstr[d];
  414.         break;
  415. # ifdef DEBUG
  416.     default:
  417.         warning("bad switch mn2 %d %d",a,d);
  418.         break;
  419. # endif
  420.         }
  421.     if(tptr > treesize)
  422.         error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
  423.     return(tptr++);
  424.     }
  425. mn1(a,d)
  426.   int a,d;
  427.     {
  428.     name[tptr] = a;
  429.     left[tptr] = d;
  430.     parent[tptr] = 0;
  431.     nullstr[tptr] = 0;
  432.     switch(a){
  433.     case RCCL:
  434.     case RNCCL:
  435.         if(slength(d) == 0) nullstr[tptr] = TRUE;
  436.         break;
  437.     case STAR:
  438.     case QUEST:
  439.         nullstr[tptr] = TRUE;
  440.         parent[d] = tptr;
  441.         break;
  442.     case PLUS:
  443.     case CARAT:
  444.         nullstr[tptr] = nullstr[d];
  445.         parent[d] = tptr;
  446.         break;
  447.     case S2FINAL:
  448.         nullstr[tptr] = TRUE;
  449.         break;
  450. # ifdef DEBUG
  451.     case FINAL:
  452.     case S1FINAL:
  453.         break;
  454.     default:
  455.         warning("bad switch mn1 %d %d",a,d);
  456.         break;
  457. # endif
  458.         }
  459.     if(tptr > treesize)
  460.         error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
  461.     return(tptr++);
  462.     }
  463. mn0(a)
  464.   int a;
  465.     {
  466.     name[tptr] = a;
  467.     parent[tptr] = 0;
  468.     nullstr[tptr] = 0;
  469.     if(a >= NCH) switch(a){
  470.     case RNULLS: nullstr[tptr] = TRUE; break;
  471. # ifdef DEBUG
  472.     default:
  473.         warning("bad switch mn0 %d",a);
  474.         break;
  475. # endif
  476.     }
  477.     if(tptr > treesize)
  478.         error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
  479.     return(tptr++);
  480.     }
  481. munput(t,p)    /* implementation dependent */
  482.   char *p;
  483.   int t; {
  484.     register int i,j;
  485.     if(t == 'c'){
  486.         *pushptr++ = peek;        /* watch out for this */
  487.         peek = p;
  488.         }
  489.     else if(t == 's'){
  490.         *pushptr++ = peek;
  491.         peek = p[0];
  492.         i = slength(p);
  493.         for(j = i-1; j>=1; j--)
  494.             *pushptr++ = p[j];
  495.         }
  496. # ifdef DEBUG
  497.     else error("Unrecognized munput option %c",t);
  498. # endif
  499.     if(pushptr >= pushc+TOKENSIZE)
  500.         error("Too many characters pushed");
  501.     return;
  502.     }
  503.  
  504. dupl(n)
  505.   int n; {
  506.     /* duplicate the subtree whose root is n, return ptr to it */
  507.     register int i;
  508.     i = name[n];
  509.     if(i < NCH) return(mn0(i));
  510.     switch(i){
  511.     case RNULLS:
  512.         return(mn0(i));
  513.     case RCCL: case RNCCL: case FINAL: case S1FINAL: case S2FINAL:
  514.         return(mn1(i,left[n]));
  515.     case STAR: case QUEST: case PLUS: case CARAT:
  516.         return(mn1(i,dupl(left[n])));
  517.     case RSTR: case RSCON:
  518.         return(mn2(i,dupl(left[n]),right[n]));
  519.     case BAR: case RNEWE: case RCAT: case DIV:
  520.         return(mn2(i,dupl(left[n]),dupl(right[n])));
  521. # ifdef DEBUG
  522.     default:
  523.         warning("bad switch dupl %d",n);
  524. # endif
  525.     }
  526.     return(0);
  527.     }
  528. # ifdef DEBUG
  529. allprint(c)
  530.   char c; {
  531.     switch(c){
  532.         case 014:
  533.             printf("\\f");
  534.             charc++;
  535.             break;
  536.         case '\n':
  537.             printf("\\n");
  538.             charc++;
  539.             break;
  540.         case '\t':
  541.             printf("\\t");
  542.             charc++;
  543.             break;
  544.         case '\b':
  545.             printf("\\b");
  546.             charc++;
  547.             break;
  548.         case ' ':
  549.             printf("\\\bb");
  550.             break;
  551.         default:
  552.             if(!printable(c)){
  553.                 printf("\\%-3o",c);
  554.                 charc =+ 3;
  555.                 }
  556.             else 
  557.                 putchar(c);
  558.             break;
  559.         }
  560.     charc++;
  561.     return;
  562.     }
  563. strpt(s)
  564.   char *s; {
  565.     charc = 0;
  566.     while(*s){
  567.         allprint(*s++);
  568.         if(charc > LINESIZE){
  569.             charc = 0;
  570.             printf("\n\t");
  571.             }
  572.         }
  573.     return;
  574.     }
  575. sect1dump(){
  576.     register int i;
  577.     printf("Sect 1:\n");
  578.     if(def[0]){
  579.         printf("str    trans\n");
  580.         i = -1;
  581.         while(def[++i])
  582.             printf("%s\t%s\n",def[i],subs[i]);
  583.         }
  584.     if(sname[0]){
  585.         printf("start names\n");
  586.         i = -1;
  587.         while(sname[++i])
  588.             printf("%s\n",sname[i]);
  589.         }
  590.     if(chset == TRUE){
  591.         printf("char set changed\n");
  592.         for(i=1;i<NCH;i++){
  593.             if(i != ctable[i]){
  594.                 allprint(i);
  595.                 putchar(' ');
  596.                 printable(ctable[i]) ? putchar(ctable[i]) : printf("%d",ctable[i]);
  597.                 putchar('\n');
  598.                 }
  599.             }
  600.         }
  601.     }
  602. sect2dump(){
  603.     printf("Sect 2:\n");
  604.     treedump();
  605.     }
  606. treedump()
  607.     {
  608.     register int t;
  609.     register char *p;
  610.     printf("treedump %d nodes:\n",tptr);
  611.     for(t=0;t<tptr;t++){
  612.         printf("%4d ",t);
  613.         parent[t] ? printf("p=%4d",parent[t]) : printf("      ");
  614.         printf("  ");
  615.         if(name[t] < NCH) {
  616.                 allprint(name[t]);
  617.                 }
  618.         else switch(name[t]){
  619.             case RSTR:
  620.                 printf("%d ",left[t]);
  621.                 allprint(right[t]);
  622.                 break;
  623.             case RCCL:
  624.                 printf("ccl ");
  625.                 strpt(left[t]);
  626.                 break;
  627.             case RNCCL:
  628.                 printf("nccl ");
  629.                 strpt(left[t]);
  630.                 break;
  631.             case DIV:
  632.                 printf("/ %d %d",left[t],right[t]);
  633.                 break;
  634.             case BAR:
  635.                 printf("| %d %d",left[t],right[t]);
  636.                 break;
  637.             case RCAT:
  638.                 printf("cat %d %d",left[t],right[t]);
  639.                 break;
  640.             case PLUS:
  641.                 printf("+ %d",left[t]);
  642.                 break;
  643.             case STAR:
  644.                 printf("* %d",left[t]);
  645.                 break;
  646.             case CARAT:
  647.                 printf("^ %d",left[t]);
  648.                 break;
  649.             case QUEST:
  650.                 printf("? %d",left[t]);
  651.                 break;
  652.             case RNULLS:
  653.                 printf("nullstring");
  654.                 break;
  655.             case FINAL:
  656.                 printf("final %d",left[t]);
  657.                 break;
  658.             case S1FINAL:
  659.                 printf("s1final %d",left[t]);    
  660.                 break;
  661.             case S2FINAL:
  662.                 printf("s2final %d",left[t]);
  663.                 break;
  664.             case RNEWE:
  665.                 printf("new %d %d",left[t],right[t]);
  666.                 break;
  667.             case RSCON:
  668.                 p = right[t];
  669.                 printf("start %s",sname[*p++-1]);
  670.                 while(*p)
  671.                     printf(", %s",sname[*p++-1]);
  672.                 printf(" %d",left[t]);
  673.                 break;
  674.             default:
  675.                 printf("unknown %d %d %d",name[t],left[t],right[t]);
  676.                 break;
  677.             }
  678.         if(nullstr[t])printf("\t(null poss.)");
  679.         putchar('\n');
  680.         }
  681.     }
  682. # endif
  683.