home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / src / cmd / lex / parser.y < prev    next >
Encoding:
Text File  |  1979-01-10  |  15.1 KB  |  711 lines

  1. %token CHAR CCL NCCL STR DELIM SCON ITER NEWE NULLS
  2. %left SCON '/' NEWE
  3. %left '|'
  4. %left '$' '^'
  5. %left CHAR CCL NCCL '(' '.' STR NULLS
  6. %left ITER
  7. %left CAT
  8. %left '*' '+' '?'
  9.  
  10. %{
  11. # include "ldefs.c"
  12. %}
  13. %%
  14. %{
  15. int i;
  16. int j,k;
  17. int g;
  18. char *p;
  19. %}
  20. acc    :    lexinput
  21.     ={    
  22. # ifdef DEBUG
  23.         if(debug) sect2dump();
  24. # endif
  25.     }
  26.     ;
  27. lexinput:    defns delim prods end
  28.     |    defns delim end
  29.     ={
  30.         if(!funcflag)phead2();
  31.         funcflag = TRUE;
  32.     }
  33.     | error
  34.     ={
  35. # ifdef DEBUG
  36.         if(debug) {
  37.             sect1dump();
  38.             sect2dump();
  39.             }
  40. # endif
  41.         }
  42.     ;
  43. end:        delim | ;
  44. defns:    defns STR STR
  45.     ={    scopy($2,dp);
  46.         def[dptr] = dp;
  47.         dp =+ slength($2) + 1;
  48.         scopy($3,dp);
  49.         subs[dptr++] = dp;
  50.         if(dptr >= DEFSIZE)
  51.             error("Too many definitions");
  52.         dp =+ slength($3) + 1;
  53.         if(dp >= dchar+DEFCHAR)
  54.             error("Definitions too long");
  55.         subs[dptr]=def[dptr]=0;    /* for lookup - require ending null */
  56.     }
  57.     |
  58.     ;
  59. delim:    DELIM
  60.     ={
  61. # ifdef DEBUG
  62.         if(sect == DEFSECTION && debug) sect1dump();
  63. # endif
  64.         sect++;
  65.         }
  66.     ;
  67. prods:    prods pr
  68.     ={    $$ = mn2(RNEWE,$1,$2);
  69.         }
  70.     |    pr
  71.     ={    $$ = $1;}
  72.     ;
  73. pr:    r NEWE
  74.     ={
  75.         if(divflg == TRUE)
  76.             i = mn1(S1FINAL,casecount);
  77.         else i = mn1(FINAL,casecount);
  78.         $$ = mn2(RCAT,$1,i);
  79.         divflg = FALSE;
  80.         casecount++;
  81.         }
  82.     | error NEWE
  83.     ={
  84. # ifdef DEBUG
  85.         if(debug) sect2dump();
  86. # endif
  87.         }
  88. r:    CHAR
  89.     ={    $$ = mn0($1); }
  90.     | STR
  91.     ={
  92.         p = $1;
  93.         i = mn0(*p++);
  94.         while(*p)
  95.             i = mn2(RSTR,i,*p++);
  96.         $$ = i;
  97.         }
  98.     | '.'
  99.     ={    symbol['\n'] = 0;
  100.         if(psave == FALSE){
  101.             p = ccptr;
  102.             psave = ccptr;
  103.             for(i=1;i<'\n';i++){
  104.                 symbol[i] = 1;
  105.                 *ccptr++ = i;
  106.                 }
  107.             for(i='\n'+1;i<NCH;i++){
  108.                 symbol[i] = 1;
  109.                 *ccptr++ = i;
  110.                 }
  111.             *ccptr++ = 0;
  112.             if(ccptr > ccl+CCLSIZE)
  113.                 error("Too many large character classes");
  114.             }
  115.         else
  116.             p = psave;
  117.         $$ = mn1(RCCL,p);
  118.         cclinter(1);
  119.         }
  120.     | CCL
  121.     ={    $$ = mn1(RCCL,$1); }
  122.     | NCCL
  123.     ={    $$ = mn1(RNCCL,$1); }
  124.     | r '*'
  125.     ={    $$ = mn1(STAR,$1); }
  126.     | r '+'
  127.     ={    $$ = mn1(PLUS,$1); }
  128.     | r '?'
  129.     ={    $$ = mn1(QUEST,$1); }
  130.     | r '|' r
  131.     ={    $$ = mn2(BAR,$1,$3); }
  132.     | r r %prec CAT
  133.     ={    $$ = mn2(RCAT,$1,$2); }
  134.     | r '/' r
  135.     ={    if(!divflg){
  136.             j = mn1(S2FINAL,-casecount);
  137.             i = mn2(RCAT,$1,j);
  138.             $$ = mn2(DIV,i,$3);
  139.             }
  140.         else {
  141.             $$ = mn2(RCAT,$1,$3);
  142.             warning("Extra slash removed");
  143.             }
  144.         divflg = TRUE;
  145.         }
  146.     | r ITER ',' ITER '}'
  147.     ={    if($2 > $4){
  148.             i = $2;
  149.             $2 = $4;
  150.             $4 = i;
  151.             }
  152.         if($4 <= 0)
  153.             warning("Iteration range must be positive");
  154.         else {
  155.             j = $1;
  156.             for(k = 2; k<=$2;k++)
  157.                 j = mn2(RCAT,j,dupl($1));
  158.             for(i = $2+1; i<=$4; i++){
  159.                 g = dupl($1);
  160.                 for(k=2;k<=i;k++)
  161.                     g = mn2(RCAT,g,dupl($1));
  162.                 j = mn2(BAR,j,g);
  163.                 }
  164.             $$ = j;
  165.             }
  166.     }
  167.     | r ITER '}'
  168.     ={
  169.         if($2 < 0)warning("Can't have negative iteration");
  170.         else if($2 == 0) $$ = mn0(RNULLS);
  171.         else {
  172.             j = $1;
  173.             for(k=2;k<=$2;k++)
  174.                 j = mn2(RCAT,j,dupl($1));
  175.             $$ = j;
  176.             }
  177.         }
  178.     | r ITER ',' '}'
  179.     ={
  180.                 /* from n to infinity */
  181.         if($2 < 0)warning("Can't have negative iteration");
  182.         else if($2 == 0) $$ = mn1(STAR,$1);
  183.         else if($2 == 1)$$ = mn1(PLUS,$1);
  184.         else {        /* >= 2 iterations minimum */
  185.             j = $1;
  186.             for(k=2;k<$2;k++)
  187.                 j = mn2(RCAT,j,dupl($1));
  188.             k = mn1(PLUS,dupl($1));
  189.             $$ = mn2(RCAT,j,k);
  190.             }
  191.         }
  192.     | SCON r
  193.     ={    $$ = mn2(RSCON,$2,$1); }
  194.     | '^' r
  195.     ={    $$ = mn1(CARAT,$2); }
  196.     | r '$'
  197.     ={    i = mn0('\n');
  198.         if(!divflg){
  199.             j = mn1(S2FINAL,-casecount);
  200.             k = mn2(RCAT,$1,j);
  201.             $$ = mn2(DIV,k,i);
  202.             }
  203.         else $$ = mn2(RCAT,$1,i);
  204.         divflg = TRUE;
  205.         }
  206.     | '(' r ')'
  207.     ={    $$ = $2; }
  208.     |    NULLS
  209.     ={    $$ = mn0(RNULLS); }
  210.     ;
  211. %%
  212. yylex(){
  213.     register char *p;
  214.     register int c, i;
  215.     char  *t, *xp;
  216.     int n, j, k, x;
  217.     static int sectbegin;
  218.     static char token[TOKENSIZE];
  219.     static int iter;
  220.  
  221. # ifdef DEBUG
  222.     yylval = 0;
  223. # endif
  224.  
  225.     if(sect == DEFSECTION) {        /* definitions section */
  226.         while(!eof) {
  227.             if(prev == '\n'){        /* next char is at beginning of line */
  228.                 getl(p=buf);
  229.                 switch(*p){
  230.                 case '%':
  231.                     switch(c= *(p+1)){
  232.                     case '%':
  233.                         lgate();
  234.                         if(!ratfor)fprintf(fout,"# ");
  235.                         fprintf(fout,"define YYNEWLINE %d\n",ctable['\n']);
  236.                         if(!ratfor)fprintf(fout,"yylex(){\nint nstr; extern int yyprevious;\n");
  237.                         sectbegin = TRUE;
  238.                         i = treesize*(sizeof(*name)+sizeof(*left)+
  239.                             sizeof(*right)+sizeof(*nullstr)+sizeof(*parent))+ALITTLEEXTRA;
  240.                         c = myalloc(i,1);
  241.                         if(c == 0)
  242.                             error("Too little core for parse tree");
  243.                         p = c;
  244.                         cfree(p,i,1);
  245.                         name = myalloc(treesize,sizeof(*name));
  246.                         left = myalloc(treesize,sizeof(*left));
  247.                         right = myalloc(treesize,sizeof(*right));
  248.                         nullstr = myalloc(treesize,sizeof(*nullstr));
  249.                         parent = myalloc(treesize,sizeof(*parent));
  250.                         if(name == 0 || left == 0 || right == 0 || parent == 0 || nullstr == 0)
  251.                             error("Too little core for parse tree");
  252.                         return(freturn(DELIM));
  253.                     case 'p': case 'P':    /* has overridden number of positions */
  254.                         while(*p && !digit(*p))p++;
  255.                         maxpos = siconv(p);
  256. # ifdef DEBUG
  257.                         if (debug) printf("positions (%%p) now %d\n",maxpos);
  258. # endif
  259.                         if(report == 2)report = 1;
  260.                         continue;
  261.                     case 'n': case 'N':    /* has overridden number of states */
  262.                         while(*p && !digit(*p))p++;
  263.                         nstates = siconv(p);
  264. # ifdef DEBUG
  265.                         if(debug)printf( " no. states (%%n) now %d\n",nstates);
  266. # endif
  267.                         if(report == 2)report = 1;
  268.                         continue;
  269.                     case 'e': case 'E':        /* has overridden number of tree nodes */
  270.                         while(*p && !digit(*p))p++;
  271.                         treesize = siconv(p);
  272. # ifdef DEBUG
  273.                         if (debug) printf("treesize (%%e) now %d\n",treesize);
  274. # endif
  275.                         if(report == 2)report = 1;
  276.                         continue;
  277.                     case 'o': case 'O':
  278.                         while (*p && !digit(*p))p++;
  279.                         outsize = siconv(p);
  280.                         if (report ==2) report=1;
  281.                         continue;
  282.                     case 'a': case 'A':        /* has overridden number of transitions */
  283.                         while(*p && !digit(*p))p++;
  284.                         if(report == 2)report = 1;
  285.                         ntrans = siconv(p);
  286. # ifdef DEBUG
  287.                         if (debug)printf("N. trans (%%a) now %d\n",ntrans);
  288. # endif
  289.                         continue;
  290.                     case 'k': case 'K': /* overriden packed char classes */
  291.                         while (*p && !digit(*p))p++;
  292.                         if (report==2) report=1;
  293.                         cfree(pchar, pchlen, sizeof(*pchar));
  294.                         pchlen = siconv(p);
  295. # ifdef DEBUG
  296.                         if (debug) printf( "Size classes (%%k) now %d\n",pchlen);
  297. # endif
  298.                         pchar=pcptr=myalloc(pchlen, sizeof(*pchar));
  299.                         continue;
  300.                     case 't': case 'T':     /* character set specifier */
  301.                         ZCH = atoi(p+2);
  302.                         if (ZCH < NCH) ZCH = NCH;
  303.                         if (ZCH > 2*NCH) error("ch table needs redeclaration");
  304.                         chset = TRUE;
  305.                         for(i = 0; i<ZCH; i++)
  306.                             ctable[i] = 0;
  307.                         while(getl(p) && scomp(p,"%T") != 0 && scomp(p,"%t") != 0){
  308.                             if((n = siconv(p)) <= 0 || n > ZCH){
  309.                                 warning("Character value %d out of range",n);
  310.                                 continue;
  311.                                 }
  312.                             while(!space(*p) && *p) p++;
  313.                             while(space(*p)) p++;
  314.                             t = p;
  315.                             while(*t){
  316.                                 c = ctrans(&t);
  317.                                 if(ctable[c]){
  318.                                     if (printable(c))
  319.                                         warning("Character '%c' used twice",c);
  320.                                     else
  321.                                         warning("Character %o used twice",c);
  322.                                     }
  323.                                 else ctable[c] = n;
  324.                                 t++;
  325.                                 }
  326.                             p = buf;
  327.                             }
  328.                         {
  329.                         char chused[2*NCH]; int kr;
  330.                         for(i=0; i<ZCH; i++)
  331.                             chused[i]=0;
  332.                         for(i=0; i<NCH; i++)
  333.                             chused[ctable[i]]=1;
  334.                         for(kr=i=1; i<NCH; i++)
  335.                             if (ctable[i]==0)
  336.                                 {
  337.                                 while (chused[kr] == 0)
  338.                                     kr++;
  339.                                 ctable[i]=kr;
  340.                                 chused[kr]=1;
  341.                                 }
  342.                         }
  343.                         lgate();
  344.                         continue;
  345.                     case 'r': case 'R':
  346.                         c = 'r';
  347.                     case 'c': case 'C':
  348.                         if(lgatflg)
  349.                             error("Too late for language specifier");
  350.                         ratfor = (c == 'r');
  351.                         continue;
  352.                     case '{':
  353.                         lgate();
  354.                         while(getl(p) && scomp(p,"%}") != 0)
  355.                             fprintf(fout, "%s\n",p);
  356.                         if(p[0] == '%') continue;
  357.                         error("Premature eof");
  358.                     case 's': case 'S':        /* start conditions */
  359.                         lgate();
  360.                         while(*p && index(*p," \t,") < 0) p++;
  361.                         n = TRUE;
  362.                         while(n){
  363.                             while(*p && index(*p," \t,") >= 0) p++;
  364.                             t = p;
  365.                             while(*p && index(*p," \t,") < 0)p++;
  366.                             if(!*p) n = FALSE;
  367.                             *p++ = 0;
  368.                             if (*t == 0) continue;
  369.                             i = sptr*2;
  370.                             if(!ratfor)fprintf(fout,"# ");
  371.                             fprintf(fout,"define %s %d\n",t,i);
  372.                             scopy(t,sp);
  373.                             sname[sptr++] = sp;
  374.                             sname[sptr] = 0;    /* required by lookup */
  375.                             if(sptr >= STARTSIZE)
  376.                                 error("Too many start conditions");
  377.                             sp =+ slength(sp) + 1;
  378.                             if(sp >= schar+STARTCHAR)
  379.                                 error("Start conditions too long");
  380.                             }
  381.                         continue;
  382.                     default:
  383.                         warning("Invalid request %s",p);
  384.                         continue;
  385.                         }    /* end of switch after seeing '%' */
  386.                 case ' ': case '\t':        /* must be code */
  387.                     lgate();
  388.                     fprintf(fout, "%s\n",p);
  389.                     continue;
  390.                 default:        /* definition */
  391.                     while(*p && !space(*p)) p++;
  392.                     if(*p == 0)
  393.                         continue;
  394.                     prev = *p;
  395.                     *p = 0;
  396.                     bptr = p+1;
  397.                     yylval = buf;
  398.                     if(digit(buf[0]))
  399.                         warning("Substitution strings may not begin with digits");
  400.                     return(freturn(STR));
  401.                     }
  402.                 }
  403.             /* still sect 1, but prev != '\n' */
  404.             else {
  405.                 p = bptr;
  406.                 while(*p && space(*p)) p++;
  407.                 if(*p == 0)
  408.                     warning("No translation given - null string assumed");
  409.                 scopy(p,token);
  410.                 yylval = token;
  411.                 prev = '\n';
  412.                 return(freturn(STR));
  413.                 }
  414.             }
  415.         /* end of section one processing */
  416.         }
  417.     else if(sect == RULESECTION){        /* rules and actions */
  418.         while(!eof){
  419.             switch(c=gch()){
  420.             case '\0':
  421.                 return(freturn(0));
  422.             case '\n':
  423.                 if(prev == '\n') continue;
  424.                 x = NEWE;
  425.                 break;
  426.             case ' ':
  427.             case '\t':
  428.                 if(sectbegin == TRUE){
  429.                     cpyact();
  430.                     while((c=gch()) && c != '\n');
  431.                     continue;
  432.                     }
  433.                 if(!funcflag)phead2();
  434.                 funcflag = TRUE;
  435.                 if(ratfor)fprintf(fout,"%d\n",30000+casecount);
  436.                 else fprintf(fout,"case %d:\n",casecount);
  437.                 if(cpyact()){
  438.                     if(ratfor)fprintf(fout,"goto 30997\n");
  439.                     else fprintf(fout,"break;\n");
  440.                     }
  441.                 while((c=gch()) && c != '\n');
  442.                 if(peek == ' ' || peek == '\t' || sectbegin == TRUE){
  443.                     warning("Executable statements should occur right after %%");
  444.                     continue;
  445.                     }
  446.                 x = NEWE;
  447.                 break;
  448.             case '%':
  449.                 if(prev != '\n') goto character;
  450.                 if(peek == '{'){    /* included code */
  451.                     getl(buf);
  452.                     while(!eof && getl(buf) && scomp("%}",buf) != 0)
  453.                         fprintf(fout,"%s\n",buf);
  454.                     continue;
  455.                     }
  456.                 if(peek == '%'){
  457.                     c = gch();
  458.                     c = gch();
  459.                     x = DELIM;
  460.                     break;
  461.                     }
  462.                 goto character;
  463.             case '|':
  464.                 if(peek == ' ' || peek == '\t' || peek == '\n'){
  465.                     if(ratfor)fprintf(fout,"%d\n",30000+casecount++);
  466.                     else fprintf(fout,"case %d:\n",casecount++);
  467.                     continue;
  468.                     }
  469.                 x = '|';
  470.                 break;
  471.             case '$':
  472.                 if(peek == '\n' || peek == ' ' || peek == '\t' || peek == '|' || peek == '/'){
  473.                     x = c;
  474.                     break;
  475.                     }
  476.                 goto character;
  477.             case '^':
  478.                 if(prev != '\n' && scon != TRUE) goto character;    /* valid only at line begin */
  479.                 x = c;
  480.                 break;
  481.             case '?':
  482.             case '+':
  483.             case '.':
  484.             case '*':
  485.             case '(':
  486.             case ')':
  487.             case ',':
  488.             case '/':
  489.                 x = c;
  490.                 break;
  491.             case '}':
  492.                 iter = FALSE;
  493.                 x = c;
  494.                 break;
  495.             case '{':    /* either iteration or definition */
  496.                 if(digit(c=gch())){    /* iteration */
  497.                     iter = TRUE;
  498.                 ieval:
  499.                     i = 0;
  500.                     while(digit(c)){
  501.                         token[i++] = c;
  502.                         c = gch();
  503.                         }
  504.                     token[i] = 0;
  505.                     yylval = siconv(token);
  506.                     munput('c',c);
  507.                     x = ITER;
  508.                     break;
  509.                     }
  510.                 else {        /* definition */
  511.                     i = 0;
  512.                     while(c && c!='}'){
  513.                         token[i++] = c;
  514.                         c = gch();
  515.                         }
  516.                     token[i] = 0;
  517.                     i = lookup(token,def);
  518.                     if(i < 0)
  519.                         warning("Definition %s not found",token);
  520.                     else
  521.                         munput('s',subs[i]);
  522.                     continue;
  523.                     }
  524.             case '<':        /* start condition ? */
  525.                 if(prev != '\n')        /* not at line begin, not start */
  526.                     goto character;
  527.                 t = slptr;
  528.                 do {
  529.                     i = 0;
  530.                     c = gch();
  531.                     while(c != ',' && c && c != '>'){
  532.                         token[i++] = c;
  533.                         c = gch();
  534.                         }
  535.                     token[i] = 0;
  536.                     if(i == 0)
  537.                         goto character;
  538.                     i = lookup(token,sname);
  539.                     if(i < 0) {
  540.                         warning("Undefined start condition %s",token);
  541.                         continue;
  542.                         }
  543.                     *slptr++ = i+1;
  544.                     } while(c && c != '>');
  545.                 *slptr++ = 0;
  546.                 /* check if previous value re-usable */
  547.                 for (xp=slist; xp<t; )
  548.                     {
  549.                     if (strcmp(xp, t)==0)
  550.                         break;
  551.                     while (*xp++);
  552.                     }
  553.                 if (xp<t)
  554.                     {
  555.                     /* re-use previous pointer to string */
  556.                     slptr=t;
  557.                     t=xp;
  558.                     }
  559.                 if(slptr > slist+STARTSIZE)        /* note not packed ! */
  560.                     error("Too many start conditions used");
  561.                 yylval = t;
  562.                 x = SCON;
  563.                 break;
  564.             case '"':
  565.                 i = 0;
  566.                 while((c=gch()) && c != '"' && c != '\n'){
  567.                     if(c == '\\') c = usescape(c=gch());
  568.                     token[i++] = c;
  569.                     if(i > TOKENSIZE){
  570.                         warning("String too long");
  571.                         i = TOKENSIZE-1;
  572.                         break;
  573.                         }
  574.                     }
  575.                 if(c == '\n') {
  576.                     yyline--;
  577.                     warning("Non-terminated string");
  578.                     yyline++;
  579.                     }
  580.                 token[i] = 0;
  581.                 if(i == 0)x = NULLS;
  582.                 else if(i == 1){
  583.                     yylval = token[0];
  584.                     x = CHAR;
  585.                     }
  586.                 else {
  587.                     yylval = token;
  588.                     x = STR;
  589.                     }
  590.                 break;
  591.             case '[':
  592.                 for(i=1;i<NCH;i++) symbol[i] = 0;
  593.                 x = CCL;
  594.                 if((c = gch()) == '^'){
  595.                     x = NCCL;
  596.                     c = gch();
  597.                     }
  598.                 while(c != ']' && c){
  599.                     if(c == '\\') c = usescape(c=gch());
  600.                     symbol[c] = 1;
  601.                     j = c;
  602.                     if((c=gch()) == '-' && peek != ']'){        /* range specified */
  603.                         c = gch();
  604.                         if(c == '\\') c = usescape(c=gch());
  605.                         k = c;
  606.                         if(j > k) {
  607.                             n = j;
  608.                             j = k;
  609.                             k = n;
  610.                             }
  611.                         if(!(('A' <= j && k <= 'Z') ||
  612.                              ('a' <= j && k <= 'z') ||
  613.                              ('0' <= j && k <= '9')))
  614.                             warning("Non-portable Character Class");
  615.                         for(n=j+1;n<=k;n++)
  616.                             symbol[n] = 1;        /* implementation dependent */
  617.                         c = gch();
  618.                         }
  619.                     }
  620.                 /* try to pack ccl's */
  621.                 i = 0;
  622.                 for(j=0;j<NCH;j++)
  623.                     if(symbol[j])token[i++] = j;
  624.                 token[i] = 0;
  625.                 p = ccptr;
  626.                 if(optim){
  627.                     p = ccl;
  628.                     while(p <ccptr && scomp(token,p) != 0)p++;
  629.                     }
  630.                 if(p < ccptr)    /* found it */
  631.                     yylval = p;
  632.                 else {
  633.                     yylval = ccptr;
  634.                     scopy(token,ccptr);
  635.                     ccptr =+ slength(token) + 1;
  636.                     if(ccptr >= ccl+CCLSIZE)
  637.                         error("Too many large character classes");
  638.                     }
  639.                 cclinter(x==CCL);
  640.                 break;
  641.             case '\\':
  642.                 c = usescape(c=gch());
  643.             default:
  644.             character:
  645.                 if(iter){    /* second part of an iteration */
  646.                     iter = FALSE;
  647.                     if('0' <= c && c <= '9')
  648.                         goto ieval;
  649.                     }
  650.                 if(alpha(peek)){
  651.                     i = 0;
  652.                     yylval = token;
  653.                     token[i++] = c;
  654.                     while(alpha(peek))
  655.                         token[i++] = gch();
  656.                     if(peek == '?' || peek == '*' || peek == '+')
  657.                         munput('c',token[--i]);
  658.                     token[i] = 0;
  659.                     if(i == 1){
  660.                         yylval = token[0];
  661.                         x = CHAR;
  662.                         }
  663.                     else x = STR;
  664.                     }
  665.                 else {
  666.                     yylval = c;
  667.                     x = CHAR;
  668.                     }
  669.                 }
  670.             scon = FALSE;
  671.             if(x == SCON)scon = TRUE;
  672.             sectbegin = FALSE;
  673.             return(freturn(x));
  674.             }
  675.         }
  676.     /* section three */
  677.     ptail();
  678. # ifdef DEBUG
  679.     if(debug)
  680.         fprintf(fout,"\n/*this comes from section three - debug */\n");
  681. # endif
  682.     while(getl(buf) && !eof)
  683.         fprintf(fout,"%s\n",buf);
  684.     return(freturn(0));
  685.     }
  686. /* end of yylex */
  687. # ifdef DEBUG
  688. freturn(i)
  689.   int i; {
  690.     if(yydebug) {
  691.         printf("now return ");
  692.         if(i < NCH) allprint(i);
  693.         else printf("%d",i);
  694.         printf("   yylval = ");
  695.         switch(i){
  696.             case STR: case CCL: case NCCL:
  697.                 strpt(yylval);
  698.                 break;
  699.             case CHAR:
  700.                 allprint(yylval);
  701.                 break;
  702.             default:
  703.                 printf("%d",yylval);
  704.                 break;
  705.             }
  706.         putchar('\n');
  707.         }
  708.     return(i);
  709.     }
  710. # endif
  711.