home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / C / LEX.ZIP / YTAB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  23.8 KB  |  860 lines
  1. /*
  2.  *                   * * *   W A R N I N G    * * *
  3.  *
  4.  * This file has been hand-modified from that which was produced by Yacc
  5.  * from 'lex.y'. If you plan on rebuilding this with Yacc, be SURE to run
  6.  * the virgin supplied 'lex.y' thru Yacc first, do a source compare of it's
  7.  * output 'ytab.c' with this file, and note & understand the manual mods
  8.  * that were made here.
  9.  *                                              Bob Denny
  10.  *
  11.  * Modified 02-Dec-80 Bob Denny -- Conditionalized debug code for smaller size
  12.  *                                 YYSMALL no longer used.
  13.  *                                 Removed hackish accent grave's.
  14.  *                           01    Moved calls do dfa build, min, print and
  15.  *                                  write, and to stat() to lex.c, so this
  16.  *                                  module could be put in overlay region.
  17.  *                                  Moved impure data out into ytdata.c to
  18.  *                                  go to the root.
  19.  *
  20.  *          29-May-81 Bob Denny -- Define yysterm fwd. Remove from LEXLEX.H.
  21.  *                                   for RSX overlaying.
  22.  *          19-Mar-82 Bob Denny -- New compiler and library. Typcasts needed.
  23.  *                                  Conditionally compile remote formats, not
  24.  *                                  supported in VAX C.
  25.  * More     03-May-82 Bob Denny -- Final touches, remove unreferenced autos
  26.  * More        20-Nov-83 Scott Guthery -- Adapt for IBM PC & DeSmet C
  27.  */
  28.  
  29. #include <stdio.h>
  30. #include "ytab.h"
  31. #include "lexlex.h"
  32.  
  33. char *yysterm[] = {
  34. "error",
  35. "NAME",
  36. "CCLASS",
  37. "STRING",
  38. "CONCAT",
  39. 0 };
  40.  
  41. /* char copr[] = "Copyright (c) 1978 Charles H. Forsyth";*/
  42.  
  43. struct des {
  44.         struct nfa *d_start;
  45.         struct nfa *d_final;
  46. };
  47. extern struct nlist {                                           /* 01+ */
  48.         struct  nlist   *nl_next;
  49.         struct  nfa     *nl_base;
  50.         struct  nfa     *nl_end;
  51.         struct  nfa     *nl_start;
  52.         struct  nfa     *nl_final;
  53.         char    *nl_name;
  54. } *nlist;                                                       /* 01- */
  55.  
  56. extern  int     str_length;
  57. extern  struct  nfa     *elem();
  58. extern  struct  des     *newdp();
  59. extern  struct  nlist   *lookup();
  60. extern int yydebug; /* 1 for debugging */                       /* 01+ */
  61. extern int yychar; /* current input token number */
  62. extern int yynerrs ;  /* number of errors */
  63. extern int yyerrflag ;  /* error recovery flag */               /* 01- */
  64.  
  65. #define yyclearin yychar = -1
  66. #define yyerrok yyerrflag = 0
  67.  
  68. #ifndef YYSTYPE
  69. #define YYSTYPE int
  70.  
  71. #endif
  72. #ifndef YYVCOPY
  73. #define YYVCOPY(x,y)    (x)=(y)
  74. #endif
  75.  
  76. extern YYSTYPE yyval;                                           /* 01+ */
  77. extern YYSTYPE *yypv;
  78. extern YYSTYPE yylval;
  79.  
  80. # define YYMAXDEPTH 150
  81. extern YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  82.  
  83. extern int      nlook;
  84. extern int      yyline;
  85. extern char     *breakc;
  86. extern char     *ignore;
  87. extern char     *illeg;                                         /* 01- */
  88.  
  89. yyactr(__np__){
  90.  
  91.         struct nfa *np, *nbase;
  92.         char *cp;
  93.         struct des *dp;
  94.         struct trans *tp;
  95.         struct nlist *nl;
  96.         int i, c;
  97.  
  98. switch(__np__){
  99.  
  100. case 7:
  101. {
  102.                 dp = yypv[3];
  103.                 nl = yypv[1];
  104.                 np = nl->nl_base;
  105.                 nl->nl_start = dp->d_start;
  106.                 nl->nl_final = dp->d_final;
  107.                 nl->nl_end = nfap;
  108. #ifdef DEBUG
  109.                 fprintf(lexlog, "NFA (auxiliary definition) for %s\n",
  110.                                 nl->nl_name);
  111.                 nfaprint(dp->d_start, nl->nl_base);
  112. #endif
  113.                 nbase = lalloc(i = nl->nl_end-nl->nl_base, sizeof(*nbase),
  114.                         "nfa storage");
  115.                 copynfa(nl, nbase, dp);
  116.                 nl->nl_start = dp->d_start;
  117.                 nl->nl_final = dp->d_final;
  118.                 nl->nl_end = nbase+i;
  119.                 nl->nl_base = nbase;
  120.                 nfap = np;
  121.                 spccl(nl->nl_name, "ignore", dp, &ignore);
  122.                 spccl(nl->nl_name, "break", dp, &breakc);
  123.                 spccl(nl->nl_name, "illegal", dp, &illeg);
  124.         } break;
  125. case 8:
  126. { copycode(); } break;
  127. case 9:
  128. {
  129.                 yyval = lookup(yypv[1]);
  130.  
  131.                 ((struct nlist *)yyval)->nl_base = nfap;
  132.                 if (((struct nlist *)yyval)->nl_start)
  133.                         yyerror("%s redefined", ((struct nlist *)yyval)->nl_name);
  134.         } break;
  135. case 10:
  136. { yyval = lookup(yypv[1]); } break;
  137. case 11:
  138. {
  139.                 np = elem(CCL, yypv[1]);
  140.                 yyval = newdp(np, np->n_succ[0] = elem(FIN));
  141.         } break;
  142. case 12:
  143. {
  144.                 cp = yypv[1];
  145.                 if (str_length == 0) {
  146.                         np = elem(EPSILON);
  147.                         yyval = newdp(np, np->n_succ[0] = elem(FIN));
  148.                         return;
  149.                 }
  150.                 yyval = np = elem(*cp++);
  151.                 while (--str_length > 0)
  152.                         np = np->n_succ[0] = elem(*cp++);
  153.                 yyval = newdp(yyval, np->n_succ[0] = elem(FIN));
  154.         } break;
  155. case 13:
  156. {
  157.                 if ((nl = yypv[1])->nl_end == 0) {
  158.                         yyerror("%s not defined", nl->nl_name);
  159.                         nl->nl_base = nl->nl_end = elem(FIN);
  160.                         nl->nl_start = nl->nl_final = nl->nl_base;
  161.                 }
  162.                 yyval = dp = lalloc(1, sizeof(*dp), "dfa input");
  163.                 nbase = nfap;
  164.                 i = nl->nl_end-nl->nl_base;
  165.                 if ((nfap += i) >= &nfa[MAXNFA]) {
  166.                         yyerror("Out of NFA nodes", NULL);
  167.                         exit(1);
  168.                 }
  169.                 copynfa(nl, nbase, dp);
  170.         } break;
  171. case 14:
  172. {
  173.                 yyval = dp = yypv[1];
  174.                 dp->d_start = newnfa(EPSILON, np = dp->d_start, 0);
  175.                 dp->d_final->n_char = EPSILON;
  176.                 dp->d_final->n_succ[0] = np;
  177.                 dp->d_final->n_succ[1] = np = elem(FIN);
  178.                 dp->d_start->n_succ[1] = np;
  179.                 dp->d_final = np;
  180.  
  181.         } break;
  182. case 15:
  183. {
  184.                 yyval = dp = yypv[1];
  185.                 dp->d_start = newnfa(EPSILON, dp->d_start,
  186.                         ((struct des *)yypv[3])->d_start);
  187.                 dp->d_final->n_char = EPSILON;
  188.                 dp->d_final = dp->d_final->n_succ[0] = np = elem(FIN);
  189.                 dp = yypv[3];
  190.                 dp->d_final->n_char = EPSILON;
  191.                 dp->d_final->n_succ[0] = np;
  192.                 free(yypv[3]);
  193.         } break;
  194. case 16:
  195. {
  196.                 yyval = yypv[1];
  197.                 dp = yypv[2];
  198.                 np = ((struct des *)yyval)->d_final;
  199.                 ((struct des *)yyval)->d_final = dp->d_final;
  200.                 np->n_char = dp->d_start->n_char;
  201.                 np->n_ccl = dp->d_start->n_ccl;
  202.                 np->n_succ[0] = dp->d_start->n_succ[0];
  203.                 np->n_succ[1] = dp->d_start->n_succ[1];
  204.                 free(yypv[2]);
  205.         } break;
  206. case 17:
  207. { yyval = yypv[2]; } break;
  208. case 18:
  209. {
  210.                 ending();
  211.         trans1:
  212. #ifdef DEBUG
  213.                 fprintf(lexlog, "\nNFA for complete syntax\n");
  214.                 fprintf(lexlog, "state 0\n");
  215.                 for (tp = trans; tp < transp; tp++)
  216.                         fprintf(lexlog, "\tepsilon\t%d\n", tp->t_start-nfa);
  217.                 for (tp = trans; tp < transp; tp++)
  218.                         nfaprint(tp->t_start, nfa);
  219. #else
  220.                 ;
  221. #endif
  222.                                                                 /* 01 */
  223.         } break;
  224. case 19:
  225. { goto trans1; } break;
  226. case 22:
  227. {
  228.                 llactr();
  229.         } break;
  230. case 23:
  231. { dp = yypv[1];  newtrans(dp->d_start, dp->d_final); } break;
  232. case 24:
  233. { copycode(); } break;
  234. case 25:
  235.  
  236. {
  237.                 ending();
  238.                 while ((c = get()) != EOF)
  239.                         putc(c, llout);
  240.         } break;
  241. case 26:
  242. { action(); } break;
  243. case 27:
  244. {
  245.                 if (nlook >= NBPW)
  246.                         yyerror("More than %d translations with lookahead",
  247.                                         NBPW);
  248.                 yyval = dp = yypv[1];
  249.                 np = dp->d_final;
  250.                 np->n_char = EPSILON;
  251.                 np->n_flag |= LOOK;
  252.                 np->n_succ[0] = ((struct des *)yypv[3])->d_start;
  253.                 dp->d_final = ((struct des *)yypv[3])->d_final;
  254.                 np->n_look = nlook;
  255.                 dp->d_final->n_look = nlook++;
  256.                 dp->d_final->n_flag |= FLOOK;
  257.                 free(yypv[3]);
  258.         } break;
  259. }
  260. }
  261. int yyerrval = 256;
  262.  
  263. /*
  264.  * Lexical analyser
  265.  * (it isn't done with lex...)
  266.  */
  267. extern char     buffer[150];                                    /* 01 */
  268.  
  269. yylex()
  270. {
  271.         register c;
  272.         register char *cp;
  273.         int lno;
  274.  
  275.         if (yyline == 0)
  276.                 yyline++;
  277. loop:
  278.         c = get();
  279.         if (isupper(c)) {
  280.                 name(c);
  281.                 for (cp = yylval; c = *cp; cp++)
  282.                         if (isupper(c))
  283.                                 *cp = tolower(c);
  284.                 return(STRING);
  285.         } else if (islower(c) || c == '_') {
  286.                 name(c);
  287.                 return(NAME);
  288.  
  289.         }
  290.         switch (c) {
  291.         case -1 /*EOF*/:
  292.                 return(0);
  293.  
  294.         case '[':
  295.                 return(cclass());
  296.  
  297.         case '(':
  298.         case ')':
  299.         case '{':
  300.         case '}':
  301.         case '*':
  302.         case '|':
  303.         case '=':
  304.         case ';':
  305.         case '%':
  306.                 return(c);
  307.  
  308.         case '/':
  309.                 if ((c = get()) != '*') {
  310.                         unget(c);
  311.                         return('/');
  312.                 }
  313.                 lno = yyline;
  314.                 for (; c != EOF; c = get())
  315.                         if (c == '*')
  316.                                 if ((c = get()) == '/')
  317.                                         goto loop; else
  318.                                         unget(c);
  319.                 yyline = lno;
  320.                 yyerror("End of file in comment", NULL);
  321.  
  322.         case '\'':
  323.         case '"':
  324.                 yylval = buffer;
  325.                 string(c);
  326.                 return(STRING);
  327.  
  328.         case '\n':
  329.         case '\r':
  330.         case ' ':
  331.         case '\t':
  332.                 goto loop;
  333.  
  334.         default:
  335.                 yylval = buffer;
  336.                 buffer[0] = c;
  337.                 buffer[1] = 0;
  338.                 str_length = 1;
  339.                 return(STRING);
  340.         }
  341. }
  342.  
  343. extern char     ccl[(NCHARS+1)/NBPC];                           /* 01 */
  344.  
  345. cclass()
  346. {
  347.         register c, i, lc;
  348.         int compl;
  349.  
  350.         compl = 0;
  351.         for (i = 0; i < sizeof ccl; i++)
  352.  
  353.                 ccl[i] = 0;
  354.         if ((c = get()) == '^')
  355.                 compl++; else
  356.                 unget(c);
  357.         lc = -1;
  358.         while ((c = mapc(']')) != EOF) {
  359.                 if (c == '-' && lc >= 0) {
  360.                         if ((c = mapc(']')) == EOF)
  361.                                 break;
  362.                         for (i = lc; i <= c; i++)
  363.                                 ccl[i/NBPC] |= 1<<(i%NBPC);
  364.                         lc = -1;
  365.                         continue;
  366.                 }
  367.                 ccl[c/NBPC] |= 1<<(c%NBPC);
  368.                 lc = c;
  369.         }
  370.         if (compl) {
  371.                 for (i = 0; i < sizeof ccl; i++)
  372.                         ccl[i] ^= -1;
  373.                 if (aflag == 0)
  374.                         for (i = 0200; i < (1<<NBPC); i++)
  375.                                 ccl[i/NBPC] &= ~(1 << (i%NBPC));
  376.         }
  377.         yylval = newccl(ccl);
  378.         return(CCLASS);
  379. }
  380.  
  381. string(ec)
  382. {
  383.         register char *cp;
  384.         register c;
  385.  
  386.         for (cp = buffer; (c = mapc(ec)) != EOF;)
  387.                 *cp++ = c;
  388.         *cp = 0;
  389.         str_length = cp-buffer;
  390. }
  391.  
  392. mapc(ec)
  393. {
  394.         register c, v, i;
  395.  
  396.         if ((c = get()) == ec)
  397.                 return(EOF);
  398.         switch(c) {
  399.         case -1 /*EOF*/:
  400.                 yyerror("End of file in string", NULL);
  401.                 return(c);
  402.  
  403.         case '\\':
  404.                 if ((c = get()) >= '0' && c <= '7') {
  405.                         i = 0;
  406.                         for (v = 0; c>='0' && c<='7' && i++<3; c = get())
  407.                                 v = v*010 + c-'0';
  408.                         unget(c);
  409.                         return(v&0377);
  410.                 }
  411.                 switch (c) {
  412.                 case 'n':
  413.                         return('\n');
  414.                 case 't':
  415.                         return('\t');
  416.  
  417.                 case 'b':
  418.                         return('\b');
  419.  
  420.                 case 'r':
  421.                         return('\r');
  422.  
  423.                 case '\n':
  424.                         yyline++;
  425.                         return(mapc(ec));
  426.                 }
  427.  
  428.         default:
  429.                 return(c);
  430.         }
  431. }
  432.  
  433. name(c)
  434. register c;
  435. {
  436.         register char *cp;
  437.  
  438.         for (yylval=cp=buffer; isalpha(c) || isdigit(c) || c=='_'; c=get())
  439.                 *cp++ = c;
  440.         *cp = 0;
  441.         str_length = cp-buffer;
  442.         unget(c);
  443. }
  444.  
  445. /*
  446.  * Miscellaneous functions
  447.  * used only by lex.y
  448.  */
  449. struct nfa *
  450. elem(k, v)
  451. {
  452.         struct nfa *fp;
  453.  
  454.         fp = newnfa(k, 0, 0);
  455.         if (k == CCL)
  456.                 fp->n_ccl = v;
  457.         return(fp);
  458. }
  459.  
  460. struct des *
  461. newdp(st, fi)
  462. struct nfa *st, *fi;
  463. {
  464.         register struct des *dp;
  465.  
  466.         dp = lalloc(1, sizeof(*dp), "dfa input");
  467.         dp->d_start = st;
  468.         dp->d_final = fi;
  469.         return(dp);
  470. }
  471.  
  472. action()
  473. {
  474.         register c;
  475.         int lno, lev;
  476.  
  477.         newcase(transp-trans);
  478.         lno = yyline;
  479.         lev = 0;
  480.         for (; (c = get()) != EOF && (c != '}' || lev); putc(c, llout))
  481.                 if (c == '{')
  482.                         lev++;
  483.                 else if (c == '}')
  484.                         lev--;
  485.                 else if (c == '\'' || c == '"') {
  486.                         putc(c, llout);
  487.                         skipstr(c);
  488.                 }
  489.         fprintf(llout, "\n         break;\n");
  490.         if (c == EOF) {
  491.                 yyline = lno;
  492.                 yyerror("End of file in action", NULL);
  493.         }
  494. }
  495.  
  496. skipstr(ec)
  497. register ec;
  498. {
  499.         register c;
  500.  
  501.         while ((c = get()) != ec && c != EOF) {
  502.                 putc(c, llout);
  503.                 if (c == '\\' && (c = get()) != EOF)
  504.                         putc(c, llout);
  505.         }
  506. }
  507.  
  508. copycode()
  509. {
  510.         int lno;
  511.         register c;
  512.  
  513.         setline();
  514.         lno = yyline;
  515.         for (; (c = get()) != EOF; putc(c, llout))
  516.                 if (c == '%') {
  517.                         if ((c = get()) == '}')
  518.                                 return;
  519.                         unget(c);
  520.                         c = '%';
  521.                 }
  522.         yyline = lno;
  523.         yyerror("Incomplete %{ declaration", NULL);
  524.         exit(1);
  525. }
  526.  
  527. struct nlist *
  528. lookup(s)
  529. register char *s;
  530. {
  531.         register struct nlist *nl;
  532.         register char *cp;
  533.         int i;
  534.         for (nl = nlist; nl; nl = nl->nl_next)
  535.                 if (!strcmp(s, nl->nl_name))
  536.                         return(nl);
  537.  
  538.         nl = lalloc(1, sizeof(*nl), "namelist");
  539.         nl->nl_start = nl->nl_end = nl->nl_base = nl->nl_end = 0;
  540.         nl->nl_next = nlist;
  541.         nlist = nl;
  542.         i = 0;
  543.         nl->nl_name = cp = lalloc(strlen(s) + 1, sizeof(*cp), "namelist");
  544.         strcpy(cp, s);
  545.         return(nl);
  546. }
  547.  
  548. copynfa(nl, nbase, dp)
  549. struct nlist *nl;
  550. struct des *dp;
  551. struct nfa *nbase;
  552. {
  553.         register struct nfa *np, *ob;
  554.         register j;
  555.         int i;
  556.  
  557.         ob = nl->nl_base;
  558.         i = nl->nl_end-ob;
  559.         copy(nbase, ob, sizeof(*np) * i);
  560.         for (np = nbase; i-- > 0; np++) {
  561.                 np->n_flag &= ~NPRT;
  562.                 for (j = 0; j < 2; j++)
  563.                         if (np->n_succ[j])
  564.                                 np->n_succ[j] = (np->n_succ[j]-ob)+nbase;
  565.         }
  566.         dp->d_start = (nl->nl_start-ob)+nbase;
  567.         dp->d_final = (nl->nl_final-ob)+nbase;
  568. }
  569.  
  570. copy(out, in, count)
  571. register char   *out;
  572. register char   *in;
  573. register int    count;
  574. {
  575.         while (--count >= 0)
  576.                 *out++ = *in++;
  577. }
  578.  
  579. spccl(nm, isit, dp, where)
  580. char                    *nm;
  581. char                    *isit;
  582. register struct des     *dp;
  583. char                    **where;
  584. {
  585.  
  586.         if (!strcmp(nm, isit)) {
  587.                 if (*where != 0)
  588.                         yyerror("Redefinition of %s class", isit);
  589.                 if (dp->d_start->n_char == CCL &&
  590.                                 dp->d_start->n_succ[0] == dp->d_final)
  591.                         *where = dp->d_start->n_ccl;
  592.                 else
  593.                         yyerror("Illegal %s class", isit);
  594.         }
  595. }
  596.  
  597. get()
  598. {
  599.         register int c;
  600.  
  601.         if ((c = unix_getc(lexin)) == '\n')
  602.                 yyline++;
  603.         return(c);
  604. }
  605.  
  606. unget(c)
  607. register c;
  608. {
  609.         if (c == '\n')
  610.                 yyline--;
  611.         ungetc(c, lexin);
  612. }
  613.  
  614. yyerror(format, value)
  615. char *format, *value;
  616. {
  617.         char buffer[50];
  618.         if (yyline)
  619.                 fprintf(stderr, "%d: ", yyline);
  620.         fprintf(stderr, format, value);
  621.         if (yychar > 256)
  622.                 fprintf(stderr, " near '%s'", yysterm[yychar-256]);
  623.         else if (yychar < 256 && yychar > 0)
  624.                 fprintf(stderr, " near '%c'", yychar);
  625.         fprintf(stderr, "\n");
  626. }
  627.  
  628. int nterms = 15;
  629. int nnonter = 13;
  630. int nstate = 41;
  631.  
  632. char *yysnter[14] = {
  633. "$accept",
  634. "lexfile",
  635. "auxiliary_section",
  636. "translation_section",
  637. "auxiliaries",
  638. "auxiliary",
  639. "namedef",
  640. "regexp",
  641. "name",
  642. "translations",
  643. "translation",
  644. "llactr",
  645. "pattern",
  646. "action" };
  647.  
  648. int yylast = 245;
  649. yyexcp(s)
  650. int s;
  651. {
  652.         switch(s){
  653.         case 1:
  654.                 if( yychar == 0 ) return( -1 );
  655.                 return( 0 );
  656.         case 2:
  657.                 if( yychar == 0 ) return( 19 );
  658.                 return( 22 );
  659.                 }
  660.         }
  661.  
  662. yyact[] = {
  663.  
  664.   23,  40,  32,  23,  29,  32,  23,  15,  32,  23,
  665.   31,  32,  23,  35,  32,  18,  26,  13,  23,  32,
  666.   34,  23,  37,  11,   4,   5,  16,  28,  17,  12,
  667.   19,  19,  10,   9,  22,   6,  27,  25,   3,   8,
  668.    2,   1,   0,   0,  36,   0,   0,   0,   0,   0,
  669.    0,   0,   0,   0,  38,   0,  39,   0,   0,   0,
  670.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  671.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  672.    0,   0,   0,   0,  33,   0,   0,  33,   0,   0,
  673.   33,   0,   0,  33,   0,   0,  30,   0,   0,   0,
  674.    0,   0,  14,  14,   0,   0,   0,   0,   0,   0,
  675.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  676.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  677.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  678.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  679.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  680.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  681.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  682.  
  683.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  684.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  685.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  686.    0,   0,   0,   0,   0,   0,   0,  24,  20,  21,
  687.   24,  20,  21,  24,  20,  21,  24,  20,  21,  24,
  688.   20,  21,   0,   0,   0,  24,  20,  21,  24,  20,
  689.   21,   0,   0,   7,   7 };
  690. yypact[] = {
  691.  
  692.  -13,-2000,-2000, -14, -20,-1000, -54,-1000,-1000, -22,
  693.  -22, -21,-1000,-1000,-1000, -19,-1000,-119, -27, -34,
  694. -1000,-1000,-1000, -19,-1000,-1000,-1000, -37,-1000,-1000,
  695. -1000,-1000,-1000, -19, -23, -19, -40,-1000, -28, -31,
  696. -1000 };
  697. yypgo[] = {
  698.  
  699.    0,  41,  40,  39,  38,  25,  35,  20,  34,  33,
  700.   26,  32,  28,  27 };
  701. yyr1[] = {
  702.  
  703.    0,   1,   1,   2,   2,   4,   4,   5,   5,   6,
  704.    8,   7,   7,   7,   7,   7,   7,   7,   3,   3,
  705.    9,   9,  11,  10,  10,  10,  13,  12,  12,  -1 };
  706. yyr2[] = {
  707.  
  708.    0,   2,   0,   3,   2,   2,   1,   4,   2,   1,
  709.    1,   1,   1,   1,   2,   3,   2,   3,   1,   0,
  710.    2,   2,   0,   2,   2,   2,   1,   3,   1,  -1 };
  711. yychk[] = {
  712.  
  713.    0,  -1,  -2,  -4,  37,  -5,  -6, 257,  -3,  -9,
  714.  -11,  37,  -5,  37, 123,  61, -10, -12,  37,  -7,
  715.  258, 259,  -8,  40, 257, -10,  37,  -7, -13, 123,
  716.  123,  37,  42, 124,  -7,  47,  -7,  59,  -7,  -7,
  717.   41 };
  718. yydef[] = {
  719.  
  720.    2,  -2,  -2,   0,   0,   6,   0,   9,   1,  18,
  721.    0,   0,   5,   4,   8,   0,  20,   0,   0,  28,
  722.   11,  12,  13,   0,  10,  21,   3,   0,  23,  26,
  723.   24,  25,  14,   0,  16,   0,   0,   7,  15,  27,
  724.   17 };
  725.  
  726. # define YYFLAG1 -1000
  727. # define YYFLAG2 -2000
  728.  
  729. /* test me on cases where there are more than one reduction
  730. per state, leading to the necessity to look ahead, and other
  731. arcane flows of control.
  732. */
  733.  
  734. /*      parser for yacc output  */
  735. /* extern YYSTYPE yyval;        -- defined in the table file
  736.  * extern YYSTYPE yylval;       -- defined in the table file
  737.  * extern YYSTYPE *yypv;        -- defined in the table file
  738.  */
  739.  
  740. #ifdef  DEBUG
  741. #define LOGOUT  lexlog
  742. #endif
  743.  
  744. yyparse() {
  745.    int yys[YYMAXDEPTH];
  746.    int yyj;
  747.    register yyn, yystate, *yyps;
  748.  
  749.    yystate = 0;
  750.    yychar = -1;
  751.    yynerrs = 0;
  752.    yyerrflag = 0;
  753.    yyps= &yys[0]-1;
  754.    yypv= &yyv[0]-1;
  755.  
  756.  yystack:    /* put a state and value onto the stack */
  757.  
  758. #ifdef DEBUG
  759.    if( yydebug  )
  760.         fprintf(LOGOUT, "state %d, value %d, char %d\n",yystate,yyval,yychar);
  761. #endif
  762.  
  763.    *++yyps = yystate;
  764.    *++yypv = yyval;
  765.  
  766.  yynewstate:
  767.  
  768.    yyn = yypact[yystate];
  769.  
  770.    if( yyn<= YYFLAG1 ){ /* simple state */
  771.       if( yyn == YYFLAG2 && yychar<0 ) yychar = yylex();
  772.       goto yydefault;
  773.       }
  774.  
  775.    if( yychar<0 ) yychar = yylex();
  776.    if( (yyn += yychar)<0 || yyn >= yylast ) goto yydefault;
  777.  
  778.    if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  779.       yychar = -1;
  780.       yyval = yylval;
  781.       yystate = yyn;
  782.       if( yyerrflag > 0 ) --yyerrflag;
  783.       goto yystack;
  784.       }
  785.  
  786.  yydefault:
  787.    /* default state action */
  788.  
  789.    if( (yyn=yydef[yystate]) == -2 ) yyn = yyexcp( yystate );
  790.  
  791.   if( yyn == -1 ){ /* accept */
  792.       return( 0 );
  793.  
  794.       }
  795.  
  796.    if( yyn == 0 ){ /* error */
  797.       /* error ... attempt to resume parsing */
  798.  
  799.       switch( yyerrflag ){
  800.  
  801.       case 0:   /* brand new error */
  802.  
  803.          ++yynerrs;
  804.          yyerror("syntax error", NULL);
  805.  
  806.       case 1:
  807.       case 2: /* incompletely recovered error ... try again */
  808.  
  809.          yyerrflag = 3;
  810.  
  811.          /* find a state where "error" is a legal shift action */
  812.  
  813.          while ( yyps >= yys ) {
  814.             yyn = yypact[*yyps] + yyerrval;
  815.             if( yyn>= 0 && yyn < yylast && yychk[yyact[yyn]] == yyerrval ){
  816.                yystate = yyact[yyn];  /* simulate a shift of "error" */
  817.                goto yystack;
  818.                }
  819.             yyn = yypact[*yyps];
  820.  
  821.             /* the current yyps has no shift onn "error", pop stack */
  822.  
  823. #ifdef DEBUG
  824.             if(yydebug)
  825.                 fprintf(LOGOUT, "error recovery pops state %d, uncovers %d\n",
  826.                         *yyps, yyps[-1]);
  827. #endif
  828.             --yyps;
  829.             --yypv;
  830.             }
  831.  
  832.          /* there is no state on the stack with an error shift ... abort */
  833.  
  834.     abort:
  835.          return(1);
  836.  
  837.       case 3:  /* no shift yet; clobber input char */
  838.  
  839. #ifdef DEBUG
  840.          if (yydebug)
  841.                 fprintf(LOGOUT, "error recovery discards char %d\n", yychar );
  842. #endif
  843.  
  844.          if( yychar == 0 ) goto abort; /* don't discard EOF, quit */
  845.          yychar = -1;
  846.          goto yynewstate;   /* try again in the same state */
  847.  
  848.          }
  849.  
  850.       }
  851.  
  852.    /* reduction by production yyn */
  853.  
  854. #ifdef DEBUG
  855.       if(yydebug) fprintf(LOGOUT, "reduce %d\n",yyn);
  856. #endif
  857.  
  858.       yyps -= yyr2[yyn];
  859.       yypv -= yyr2[yyn];
  860. /*    YYVCOPY(yyval,yypv[1]);
  861.  */   yyval = yypv[1];
  862.       yyactr(yyn);
  863.          /* consult goto table to find next state */
  864.       yyn = yyr1[yyn];
  865.       yyj = yypgo[yyn] + *yyps + 1;
  866.       if( yyj>=yylast || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  867.       goto yystack;  /* stack new state and value */
  868.  
  869.    }
  870.