home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / prog_c / flex704.lha / src.lha / parse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-22  |  31.4 KB  |  1,304 lines
  1. # define CHAR 257
  2. # define NUMBER 258
  3. # define SECTEND 259
  4. # define SCDECL 260
  5. # define XSCDECL 261
  6. # define WHITESPACE 262
  7. # define NAME 263
  8. # define PREVCCL 264
  9. # define EOF_OP 265
  10.  
  11. # line 7 "parse.y"
  12. /*-
  13.  * Copyright (c) 1990 The Regents of the University of California.
  14.  * All rights reserved.
  15.  *
  16.  * This code is derived from software contributed to Berkeley by
  17.  * Vern Paxson.
  18.  * 
  19.  * The United States Government has rights in this work pursuant
  20.  * to contract no. DE-AC03-76SF00098 between the United States
  21.  * Department of Energy and the University of California.
  22.  *
  23.  * Redistribution and use in source and binary forms are permitted provided
  24.  * that: (1) source distributions retain this entire copyright notice and
  25.  * comment, and (2) distributions including binaries display the following
  26.  * acknowledgement:  ``This product includes software developed by the
  27.  * University of California, Berkeley and its contributors'' in the
  28.  * documentation or other materials provided with the distribution and in
  29.  * all advertising materials mentioning features or use of this software.
  30.  * Neither the name of the University nor the names of its contributors may
  31.  * be used to endorse or promote products derived from this software without
  32.  * specific prior written permission.
  33.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  34.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  35.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  36.  */
  37.  
  38. #ifndef lint
  39. static char rcsid[] =
  40.     "@(#) $Header: /usr/fsys/odin/a/vern/flex/RCS/parse.y,v 2.7 90/06/27 23:48:31 vern Exp $ (LBL)";
  41. #endif
  42.  
  43. #include "flexdef.h"
  44.  
  45. int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, actvp, rulelen;
  46. int trlcontxt, xcluflg, cclsorted, varlength, variable_trail_rule;
  47. Char clower();
  48.  
  49. static int madeany = false;  /* whether we've made the '.' character class */
  50. int previous_continued_action;    /* whether the previous rule's action was '|' */
  51.  
  52. #define yyclearin yychar = -1
  53. #define yyerrok yyerrflag = 0
  54. extern int yychar;
  55. extern int yyerrflag;
  56. #ifndef YYMAXDEPTH
  57. #define YYMAXDEPTH 150
  58. #endif
  59. #ifndef YYSTYPE
  60. #define YYSTYPE int
  61. #endif
  62. YYSTYPE yylval, yyval;
  63. # define YYERRCODE 256
  64.  
  65. # line 627 "parse.y"
  66.  
  67.  
  68.  
  69. /* build_eof_action - build the "<<EOF>>" action for the active start
  70.  *                    conditions
  71.  */
  72.  
  73. void build_eof_action()
  74.  
  75.     {
  76.     register int i;
  77.  
  78.     for ( i = 1; i <= actvp; ++i )
  79.     {
  80.     if ( sceof[actvsc[i]] )
  81.         format_pinpoint_message(
  82.         "multiple <<EOF>> rules for start condition %s",
  83.             scname[actvsc[i]] );
  84.  
  85.     else
  86.         {
  87.         sceof[actvsc[i]] = true;
  88.         fprintf( temp_action_file, "case YY_STATE_EOF(%s):\n",
  89.              scname[actvsc[i]] );
  90.         }
  91.     }
  92.  
  93.     line_directive_out( temp_action_file );
  94.     }
  95.  
  96.  
  97. /* synerr - report a syntax error */
  98.  
  99. void synerr( str )
  100. char str[];
  101.  
  102.     {
  103.     syntaxerror = true;
  104.     pinpoint_message( str );
  105.     }
  106.  
  107.  
  108. /* format_pinpoint_message - write out a message formatted with one string,
  109.  *                 pinpointing its location
  110.  */
  111.  
  112. void format_pinpoint_message( msg, arg )
  113. char msg[], arg[];
  114.  
  115.     {
  116.     char errmsg[MAXLINE];
  117.  
  118.     (void) sprintf( errmsg, msg, arg );
  119.     pinpoint_message( errmsg );
  120.     }
  121.  
  122.  
  123. /* pinpoint_message - write out a message, pinpointing its location */
  124.  
  125. void pinpoint_message( str )
  126. char str[];
  127.  
  128.     {
  129.     fprintf( stderr, "\"%s\", line %d: %s\n", infilename, linenum, str );
  130.     }
  131.  
  132.  
  133. /* yyerror - eat up an error message from the parser;
  134.  *         currently, messages are ignore
  135.  */
  136.  
  137. void yyerror( msg )
  138. char msg[];
  139.  
  140.     {
  141.     }
  142. int yyexca[] ={
  143. -1, 1,
  144.     0, -1,
  145.     -2, 0,
  146. -1, 2,
  147.     259, 4,
  148.     260, 4,
  149.     261, 4,
  150.     -2, 0,
  151. -1, 13,
  152.     0, 1,
  153.     -2, 0,
  154.     };
  155. # define YYNPROD 54
  156. # define YYLAST 258
  157. int yyact[]={
  158.  
  159.     31,    71,    31,    58,    31,    35,    32,    12,    32,    77,
  160.     32,    44,    28,    16,    28,    75,    28,    68,    43,    65,
  161.     15,     7,     8,     9,    64,    78,    23,     4,    72,    50,
  162.     51,    79,    46,    67,    62,    57,    27,    61,    56,    26,
  163.     37,    25,    74,    48,    10,    20,    54,    29,    24,    42,
  164.     52,    18,    17,    14,     6,    60,    13,    34,    11,    34,
  165.     19,    34,    38,    49,    39,    41,    45,     5,     3,     2,
  166.      1,     0,     0,     0,    55,     0,     0,     0,     0,     0,
  167.      0,     0,     0,     0,    59,     0,     0,    63,     0,     0,
  168.      0,     0,     0,     0,     0,     0,    70,     0,     0,     0,
  169.     49,     0,     0,     0,     0,     0,     0,     0,     0,    73,
  170.     53,     0,     0,     0,     0,     0,    47,     0,     0,     0,
  171.     47,     0,    47,     0,     0,     0,     0,     0,     0,     0,
  172.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  173.      0,     0,    76,     0,     0,     0,     0,     0,     0,     0,
  174.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  175.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  176.      0,     0,     0,     0,     0,     0,     0,     0,     0,    69,
  177.      0,    69,     0,     0,     0,     0,     0,     0,     0,     0,
  178.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  179.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  180.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  181.      0,     0,    22,    33,     0,    33,     0,    33,     0,     0,
  182.     30,    21,    30,    40,    30,     0,     0,     0,     0,     0,
  183.      0,     0,    66,     0,     0,     0,     0,     0,     0,     0,
  184.      0,     0,     0,     0,     0,     0,     0,    36 };
  185. int yypact[]={
  186.  
  187.  -1000, -1000,  -229,  -238,    34, -1000,  -255, -1000, -1000, -1000,
  188.  -1000, -1000,  -243,   -34,    -5, -1000, -1000,    30,   -32,   -30,
  189.  -1000, -1000, -1000,  -245,   -30,    -4,   -30,   -13, -1000, -1000,
  190.  -1000, -1000,   -30, -1000,   -59, -1000,  -260, -1000,   -30, -1000,
  191.  -1000, -1000,    -7, -1000, -1000,    -2, -1000,   -30, -1000,   -13,
  192.  -1000, -1000, -1000,  -234,   -15,    -8,   -76, -1000, -1000, -1000,
  193.  -1000,  -262, -1000,   -30,   -16, -1000, -1000, -1000, -1000,    -3,
  194.    -78, -1000,  -116, -1000,  -232, -1000,   -94, -1000, -1000, -1000 };
  195. int yypgo[]={
  196.  
  197.      0,    70,    69,    68,    67,    58,    56,    54,    53,    52,
  198.     51,    45,    49,    48,    41,    39,    36,    47,    46,    38 };
  199. int yyr1[]={
  200.  
  201.      0,     1,     2,     3,     3,     3,     4,     7,     7,     8,
  202.      8,     8,     5,     5,     6,     9,     9,     9,     9,     9,
  203.      9,     9,    10,    12,    12,    12,    11,    11,    11,    11,
  204.     14,    14,    13,    15,    15,    16,    16,    16,    16,    16,
  205.     16,    16,    16,    16,    16,    16,    16,    17,    17,    19,
  206.     19,    19,    18,    18 };
  207. int yyr2[]={
  208.  
  209.      0,    11,     1,    10,     0,     5,     2,     3,     3,     7,
  210.      3,     3,     8,     0,     1,     7,     5,     5,     3,     5,
  211.      3,     3,     6,     7,     3,     3,     5,     7,     5,     3,
  212.      7,     3,     5,     5,     3,     5,     5,     5,    13,    11,
  213.      9,     3,     3,     3,     7,     7,     3,     7,     9,     9,
  214.      5,     1,     5,     1 };
  215. int yychk[]={
  216.  
  217.  -1000,    -1,    -2,    -3,   256,    -4,    -7,   259,   260,   261,
  218.     10,    -5,   262,    -6,    -8,   263,   256,    -9,   -10,    94,
  219.    -11,   265,   256,    60,   -13,   -14,   -15,   -16,    46,   -17,
  220.    264,    34,    40,   257,    91,    10,   262,    10,    94,   -11,
  221.    265,   -11,   -12,   263,   256,   -14,    36,   124,    47,   -16,
  222.     42,    43,    63,   123,   -18,   -14,   -19,    94,   263,   -11,
  223.     62,    44,    36,   -15,   258,    34,   257,    41,    93,   257,
  224.    -19,   263,    44,   125,    45,    93,   258,   125,   257,   125 };
  225. int yydef[]={
  226.  
  227.      2,    -2,    -2,     0,     0,    13,     0,     6,     7,     8,
  228.      5,    14,     0,    -2,     0,    10,    11,     0,     0,     0,
  229.     18,    20,    21,     0,     0,    29,    31,    34,    41,    42,
  230.     43,    53,     0,    46,    51,     3,     0,    12,     0,    16,
  231.     19,    17,     0,    24,    25,    26,    28,     0,    32,    33,
  232.     35,    36,    37,     0,     0,     0,     0,    51,     9,    15,
  233.     22,     0,    27,    30,     0,    44,    52,    45,    47,    50,
  234.      0,    23,     0,    40,     0,    48,     0,    39,    49,    38 };
  235. typedef struct { char *t_name; int t_val; } yytoktype;
  236. #ifndef YYDEBUG
  237. #    define YYDEBUG    0    /* don't allow debugging */
  238. #endif
  239.  
  240. #if YYDEBUG
  241.  
  242. yytoktype yytoks[] =
  243. {
  244.     "CHAR",    257,
  245.     "NUMBER",    258,
  246.     "SECTEND",    259,
  247.     "SCDECL",    260,
  248.     "XSCDECL",    261,
  249.     "WHITESPACE",    262,
  250.     "NAME",    263,
  251.     "PREVCCL",    264,
  252.     "EOF_OP",    265,
  253.     "-unknown-",    -1    /* ends search */
  254. };
  255.  
  256. char * yyreds[] =
  257. {
  258.     "-no such reduction-",
  259.     "goal : initlex sect1 sect1end sect2 initforrule",
  260.     "initlex : /* empty */",
  261.     "sect1 : sect1 startconddecl WHITESPACE namelist1 '\n'",
  262.     "sect1 : /* empty */",
  263.     "sect1 : error '\n'",
  264.     "sect1end : SECTEND",
  265.     "startconddecl : SCDECL",
  266.     "startconddecl : XSCDECL",
  267.     "namelist1 : namelist1 WHITESPACE NAME",
  268.     "namelist1 : NAME",
  269.     "namelist1 : error",
  270.     "sect2 : sect2 initforrule flexrule '\n'",
  271.     "sect2 : /* empty */",
  272.     "initforrule : /* empty */",
  273.     "flexrule : scon '^' rule",
  274.     "flexrule : scon rule",
  275.     "flexrule : '^' rule",
  276.     "flexrule : rule",
  277.     "flexrule : scon EOF_OP",
  278.     "flexrule : EOF_OP",
  279.     "flexrule : error",
  280.     "scon : '<' namelist2 '>'",
  281.     "namelist2 : namelist2 ',' NAME",
  282.     "namelist2 : NAME",
  283.     "namelist2 : error",
  284.     "rule : re2 re",
  285.     "rule : re2 re '$'",
  286.     "rule : re '$'",
  287.     "rule : re",
  288.     "re : re '|' series",
  289.     "re : series",
  290.     "re2 : re '/'",
  291.     "series : series singleton",
  292.     "series : singleton",
  293.     "singleton : singleton '*'",
  294.     "singleton : singleton '+'",
  295.     "singleton : singleton '?'",
  296.     "singleton : singleton '{' NUMBER ',' NUMBER '}'",
  297.     "singleton : singleton '{' NUMBER ',' '}'",
  298.     "singleton : singleton '{' NUMBER '}'",
  299.     "singleton : '.'",
  300.     "singleton : fullccl",
  301.     "singleton : PREVCCL",
  302.     "singleton : '"' string '"'",
  303.     "singleton : '(' re ')'",
  304.     "singleton : CHAR",
  305.     "fullccl : '[' ccl ']'",
  306.     "fullccl : '[' '^' ccl ']'",
  307.     "ccl : ccl CHAR '-' CHAR",
  308.     "ccl : ccl CHAR",
  309.     "ccl : /* empty */",
  310.     "string : string CHAR",
  311.     "string : /* empty */",
  312. };
  313. #endif /* YYDEBUG */
  314. #line 1 "/usr/lib/yaccpar"
  315. /*    @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10    */
  316.  
  317. /*
  318. ** Skeleton parser driver for yacc output
  319. */
  320.  
  321. /*
  322. ** yacc user known macros and defines
  323. */
  324. #define YYERROR        goto yyerrlab
  325. #define YYACCEPT    { free(yys); free(yyv); return(0); }
  326. #define YYABORT        { free(yys); free(yyv); return(1); }
  327. #define YYBACKUP( newtoken, newvalue )\
  328. {\
  329.     if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
  330.     {\
  331.         yyerror( "syntax error - cannot backup" );\
  332.         goto yyerrlab;\
  333.     }\
  334.     yychar = newtoken;\
  335.     yystate = *yyps;\
  336.     yylval = newvalue;\
  337.     goto yynewstate;\
  338. }
  339. #define YYRECOVERING()    (!!yyerrflag)
  340. #ifndef YYDEBUG
  341. #    define YYDEBUG    1    /* make debugging available */
  342. #endif
  343.  
  344. /*
  345. ** user known globals
  346. */
  347. int yydebug;            /* set to 1 to get debugging */
  348.  
  349. /*
  350. ** driver internal defines
  351. */
  352. #define YYFLAG        (-1000)
  353.  
  354. /*
  355. ** static variables used by the parser
  356. */
  357. static YYSTYPE *yyv;            /* value stack */
  358. static int *yys;            /* state stack */
  359.  
  360. static YYSTYPE *yypv;            /* top of value stack */
  361. static int *yyps;            /* top of state stack */
  362.  
  363. static int yystate;            /* current state */
  364. static int yytmp;            /* extra var (lasts between blocks) */
  365.  
  366. int yynerrs;            /* number of errors */
  367.  
  368. int yyerrflag;            /* error recovery flag */
  369. int yychar;            /* current input token number */
  370.  
  371.  
  372. /*
  373. ** yyparse - return 0 if worked, 1 if syntax error not recovered from
  374. */
  375. int
  376. yyparse()
  377. {
  378.     register YYSTYPE *yypvt;    /* top of value stack for $vars */
  379.     unsigned yymaxdepth = YYMAXDEPTH;
  380.  
  381.     /*
  382.     ** Initialize externals - yyparse may be called more than once
  383.     */
  384.     yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
  385.     yys = (int*)malloc(yymaxdepth*sizeof(int));
  386.     if (!yyv || !yys)
  387.     {
  388.         yyerror( "out of memory" );
  389.         return(1);
  390.     }
  391.     yypv = &yyv[-1];
  392.     yyps = &yys[-1];
  393.     yystate = 0;
  394.     yytmp = 0;
  395.     yynerrs = 0;
  396.     yyerrflag = 0;
  397.     yychar = -1;
  398.  
  399.     goto yystack;
  400.     {
  401.         register YYSTYPE *yy_pv;    /* top of value stack */
  402.         register int *yy_ps;        /* top of state stack */
  403.         register int yy_state;        /* current state */
  404.         register int  yy_n;        /* internal state number info */
  405.  
  406.         /*
  407.         ** get globals into registers.
  408.         ** branch to here only if YYBACKUP was called.
  409.         */
  410.     yynewstate:
  411.         yy_pv = yypv;
  412.         yy_ps = yyps;
  413.         yy_state = yystate;
  414.         goto yy_newstate;
  415.  
  416.         /*
  417.         ** get globals into registers.
  418.         ** either we just started, or we just finished a reduction
  419.         */
  420.     yystack:
  421.         yy_pv = yypv;
  422.         yy_ps = yyps;
  423.         yy_state = yystate;
  424.  
  425.         /*
  426.         ** top of for (;;) loop while no reductions done
  427.         */
  428.     yy_stack:
  429.         /*
  430.         ** put a state and value onto the stacks
  431.         */
  432. #if YYDEBUG
  433.         /*
  434.         ** if debugging, look up token value in list of value vs.
  435.         ** name pairs.  0 and negative (-1) are special values.
  436.         ** Note: linear search is used since time is not a real
  437.         ** consideration while debugging.
  438.         */
  439.         if ( yydebug )
  440.         {
  441.             register int yy_i;
  442.  
  443.             (void)printf( "State %d, token ", yy_state );
  444.             if ( yychar == 0 )
  445.                 (void)printf( "end-of-file\n" );
  446.             else if ( yychar < 0 )
  447.                 (void)printf( "-none-\n" );
  448.             else
  449.             {
  450.                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  451.                     yy_i++ )
  452.                 {
  453.                     if ( yytoks[yy_i].t_val == yychar )
  454.                         break;
  455.                 }
  456.                 (void)printf( "%s\n", yytoks[yy_i].t_name );
  457.             }
  458.         }
  459. #endif /* YYDEBUG */
  460.         if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
  461.         {
  462.             /*
  463.             ** reallocate and recover.  Note that pointers
  464.             ** have to be reset, or bad things will happen
  465.             */
  466.             int yyps_index = (yy_ps - yys);
  467.             int yypv_index = (yy_pv - yyv);
  468.             int yypvt_index = (yypvt - yyv);
  469.             yymaxdepth += YYMAXDEPTH;
  470.             yyv = (YYSTYPE*)realloc((char*)yyv,
  471.                 yymaxdepth * sizeof(YYSTYPE));
  472.             yys = (int*)realloc((char*)yys,
  473.                 yymaxdepth * sizeof(int));
  474.             if (!yyv || !yys)
  475.             {
  476.                 yyerror( "yacc stack overflow" );
  477.                 return(1);
  478.             }
  479.             yy_ps = yys + yyps_index;
  480.             yy_pv = yyv + yypv_index;
  481.             yypvt = yyv + yypvt_index;
  482.         }
  483.         *yy_ps = yy_state;
  484.         *++yy_pv = yyval;
  485.  
  486.         /*
  487.         ** we have a new state - find out what to do
  488.         */
  489.     yy_newstate:
  490.         if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
  491.             goto yydefault;        /* simple state */
  492. #if YYDEBUG
  493.         /*
  494.         ** if debugging, need to mark whether new token grabbed
  495.         */
  496.         yytmp = yychar < 0;
  497. #endif
  498.         if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  499.             yychar = 0;        /* reached EOF */
  500. #if YYDEBUG
  501.         if ( yydebug && yytmp )
  502.         {
  503.             register int yy_i;
  504.  
  505.             (void)printf( "Received token " );
  506.             if ( yychar == 0 )
  507.                 (void)printf( "end-of-file\n" );
  508.             else if ( yychar < 0 )
  509.                 (void)printf( "-none-\n" );
  510.             else
  511.             {
  512.                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  513.                     yy_i++ )
  514.                 {
  515.                     if ( yytoks[yy_i].t_val == yychar )
  516.                         break;
  517.                 }
  518.                 (void)printf( "%s\n", yytoks[yy_i].t_name );
  519.             }
  520.         }
  521. #endif /* YYDEBUG */
  522.         if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
  523.             goto yydefault;
  524.         if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )    /*valid shift*/
  525.         {
  526.             yychar = -1;
  527.             yyval = yylval;
  528.             yy_state = yy_n;
  529.             if ( yyerrflag > 0 )
  530.                 yyerrflag--;
  531.             goto yy_stack;
  532.         }
  533.  
  534.     yydefault:
  535.         if ( ( yy_n = yydef[ yy_state ] ) == -2 )
  536.         {
  537. #if YYDEBUG
  538.             yytmp = yychar < 0;
  539. #endif
  540.             if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  541.                 yychar = 0;        /* reached EOF */
  542. #if YYDEBUG
  543.             if ( yydebug && yytmp )
  544.             {
  545.                 register int yy_i;
  546.  
  547.                 (void)printf( "Received token " );
  548.                 if ( yychar == 0 )
  549.                     (void)printf( "end-of-file\n" );
  550.                 else if ( yychar < 0 )
  551.                     (void)printf( "-none-\n" );
  552.                 else
  553.                 {
  554.                     for ( yy_i = 0;
  555.                         yytoks[yy_i].t_val >= 0;
  556.                         yy_i++ )
  557.                     {
  558.                         if ( yytoks[yy_i].t_val
  559.                             == yychar )
  560.                         {
  561.                             break;
  562.                         }
  563.                     }
  564.                     (void)printf( "%s\n", yytoks[yy_i].t_name );
  565.                 }
  566.             }
  567. #endif /* YYDEBUG */
  568.             /*
  569.             ** look through exception table
  570.             */
  571.             {
  572.                 register int *yyxi = yyexca;
  573.  
  574.                 while ( ( *yyxi != -1 ) ||
  575.                     ( yyxi[1] != yy_state ) )
  576.                 {
  577.                     yyxi += 2;
  578.                 }
  579.                 while ( ( *(yyxi += 2) >= 0 ) &&
  580.                     ( *yyxi != yychar ) )
  581.                     ;
  582.                 if ( ( yy_n = yyxi[1] ) < 0 )
  583.                     YYACCEPT;
  584.             }
  585.         }
  586.  
  587.         /*
  588.         ** check for syntax error
  589.         */
  590.         if ( yy_n == 0 )    /* have an error */
  591.         {
  592.             /* no worry about speed here! */
  593.             switch ( yyerrflag )
  594.             {
  595.             case 0:        /* new error */
  596.                 yyerror( "syntax error" );
  597.                 goto skip_init;
  598.             yyerrlab:
  599.                 /*
  600.                 ** get globals into registers.
  601.                 ** we have a user generated syntax type error
  602.                 */
  603.                 yy_pv = yypv;
  604.                 yy_ps = yyps;
  605.                 yy_state = yystate;
  606.                 yynerrs++;
  607.             skip_init:
  608.             case 1:
  609.             case 2:        /* incompletely recovered error */
  610.                     /* try again... */
  611.                 yyerrflag = 3;
  612.                 /*
  613.                 ** find state where "error" is a legal
  614.                 ** shift action
  615.                 */
  616.                 while ( yy_ps >= yys )
  617.                 {
  618.                     yy_n = yypact[ *yy_ps ] + YYERRCODE;
  619.                     if ( yy_n >= 0 && yy_n < YYLAST &&
  620.                         yychk[yyact[yy_n]] == YYERRCODE)                    {
  621.                         /*
  622.                         ** simulate shift of "error"
  623.                         */
  624.                         yy_state = yyact[ yy_n ];
  625.                         goto yy_stack;
  626.                     }
  627.                     /*
  628.                     ** current state has no shift on
  629.                     ** "error", pop stack
  630.                     */
  631. #if YYDEBUG
  632. #    define _POP_ "Error recovery pops state %d, uncovers state %d\n"
  633.                     if ( yydebug )
  634.                         (void)printf( _POP_, *yy_ps,
  635.                             yy_ps[-1] );
  636. #    undef _POP_
  637. #endif
  638.                     yy_ps--;
  639.                     yy_pv--;
  640.                 }
  641.                 /*
  642.                 ** there is no state on stack with "error" as
  643.                 ** a valid shift.  give up.
  644.                 */
  645.                 YYABORT;
  646.             case 3:        /* no shift yet; eat a token */
  647. #if YYDEBUG
  648.                 /*
  649.                 ** if debugging, look up token in list of
  650.                 ** pairs.  0 and negative shouldn't occur,
  651.                 ** but since timing doesn't matter when
  652.                 ** debugging, it doesn't hurt to leave the
  653.                 ** tests here.
  654.                 */
  655.                 if ( yydebug )
  656.                 {
  657.                     register int yy_i;
  658.  
  659.                     (void)printf( "Error recovery discards " );
  660.                     if ( yychar == 0 )
  661.                         (void)printf( "token end-of-file\n" );
  662.                     else if ( yychar < 0 )
  663.                         (void)printf( "token -none-\n" );
  664.                     else
  665.                     {
  666.                         for ( yy_i = 0;
  667.                             yytoks[yy_i].t_val >= 0;
  668.                             yy_i++ )
  669.                         {
  670.                             if ( yytoks[yy_i].t_val
  671.                                 == yychar )
  672.                             {
  673.                                 break;
  674.                             }
  675.                         }
  676.                         (void)printf( "token %s\n",
  677.                             yytoks[yy_i].t_name );
  678.                     }
  679.                 }
  680. #endif /* YYDEBUG */
  681.                 if ( yychar == 0 )    /* reached EOF. quit */
  682.                     YYABORT;
  683.                 yychar = -1;
  684.                 goto yy_newstate;
  685.             }
  686.         }/* end if ( yy_n == 0 ) */
  687.         /*
  688.         ** reduction by production yy_n
  689.         ** put stack tops, etc. so things right after switch
  690.         */
  691. #if YYDEBUG
  692.         /*
  693.         ** if debugging, print the string that is the user's
  694.         ** specification of the reduction which is just about
  695.         ** to be done.
  696.         */
  697.         if ( yydebug )
  698.             (void)printf( "Reduce by (%d) \"%s\"\n",
  699.                 yy_n, yyreds[ yy_n ] );
  700. #endif
  701.         yytmp = yy_n;            /* value to switch over */
  702.         yypvt = yy_pv;            /* $vars top of value stack */
  703.         /*
  704.         ** Look in goto table for next state
  705.         ** Sorry about using yy_state here as temporary
  706.         ** register variable, but why not, if it works...
  707.         ** If yyr2[ yy_n ] doesn't have the low order bit
  708.         ** set, then there is no action to be done for
  709.         ** this reduction.  So, no saving & unsaving of
  710.         ** registers done.  The only difference between the
  711.         ** code just after the if and the body of the if is
  712.         ** the goto yy_stack in the body.  This way the test
  713.         ** can be made before the choice of what to do is needed.
  714.         */
  715.         {
  716.             /* length of production doubled with extra bit */
  717.             register int yy_len = yyr2[ yy_n ];
  718.  
  719.             if ( !( yy_len & 01 ) )
  720.             {
  721.                 yy_len >>= 1;
  722.                 yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  723.                 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  724.                     *( yy_ps -= yy_len ) + 1;
  725.                 if ( yy_state >= YYLAST ||
  726.                     yychk[ yy_state =
  727.                     yyact[ yy_state ] ] != -yy_n )
  728.                 {
  729.                     yy_state = yyact[ yypgo[ yy_n ] ];
  730.                 }
  731.                 goto yy_stack;
  732.             }
  733.             yy_len >>= 1;
  734.             yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  735.             yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  736.                 *( yy_ps -= yy_len ) + 1;
  737.             if ( yy_state >= YYLAST ||
  738.                 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
  739.             {
  740.                 yy_state = yyact[ yypgo[ yy_n ] ];
  741.             }
  742.         }
  743.                     /* save until reenter driver code */
  744.         yystate = yy_state;
  745.         yyps = yy_ps;
  746.         yypv = yy_pv;
  747.     }
  748.     /*
  749.     ** code supplied by user is placed in this switch
  750.     */
  751.     switch( yytmp )
  752.     {
  753.         
  754. case 1:
  755. # line 51 "parse.y"
  756. { /* add default rule */
  757.             int def_rule;
  758.  
  759.             pat = cclinit();
  760.             cclnegate( pat );
  761.  
  762.             def_rule = mkstate( -pat );
  763.  
  764.             finish_rule( def_rule, false, 0, 0 );
  765.  
  766.             for ( i = 1; i <= lastsc; ++i )
  767.                 scset[i] = mkbranch( scset[i], def_rule );
  768.  
  769.             if ( spprdflt )
  770.                 fputs( "YY_FATAL_ERROR( \"flex scanner jammed\" )",
  771.                    temp_action_file );
  772.             else
  773.                 fputs( "ECHO", temp_action_file );
  774.  
  775.             fputs( ";\n\tYY_BREAK\n", temp_action_file );
  776.             } break;
  777. case 2:
  778. # line 75 "parse.y"
  779. {
  780.             /* initialize for processing rules */
  781.  
  782.             /* create default DFA start condition */
  783.             scinstal( "INITIAL", false );
  784.             } break;
  785. case 5:
  786. # line 86 "parse.y"
  787. { synerr( "unknown error processing section 1" ); } break;
  788. case 7:
  789. # line 93 "parse.y"
  790. {
  791.             /* these productions are separate from the s1object
  792.              * rule because the semantics must be done before
  793.              * we parse the remainder of an s1object
  794.              */
  795.  
  796.             xcluflg = false;
  797.             } break;
  798. case 8:
  799. # line 103 "parse.y"
  800. { xcluflg = true; } break;
  801. case 9:
  802. # line 107 "parse.y"
  803. { scinstal( nmstr, xcluflg ); } break;
  804. case 10:
  805. # line 110 "parse.y"
  806. { scinstal( nmstr, xcluflg ); } break;
  807. case 11:
  808. # line 113 "parse.y"
  809. { synerr( "bad start condition list" ); } break;
  810. case 14:
  811. # line 121 "parse.y"
  812. {
  813.             /* initialize for a parse of one rule */
  814.             trlcontxt = variable_trail_rule = varlength = false;
  815.             trailcnt = headcnt = rulelen = 0;
  816.             current_state_type = STATE_NORMAL;
  817.             previous_continued_action = continued_action;
  818.             new_rule();
  819.             } break;
  820. case 15:
  821. # line 132 "parse.y"
  822. {
  823.             pat = yypvt[-0];
  824.             finish_rule( pat, variable_trail_rule,
  825.                      headcnt, trailcnt );
  826.  
  827.             for ( i = 1; i <= actvp; ++i )
  828.                 scbol[actvsc[i]] =
  829.                 mkbranch( scbol[actvsc[i]], pat );
  830.  
  831.             if ( ! bol_needed )
  832.                 {
  833.                 bol_needed = true;
  834.  
  835.                 if ( performance_report )
  836.                 pinpoint_message( 
  837.                 "'^' operator results in sub-optimal performance" );
  838.                 }
  839.             } break;
  840. case 16:
  841. # line 152 "parse.y"
  842. {
  843.             pat = yypvt[-0];
  844.             finish_rule( pat, variable_trail_rule,
  845.                      headcnt, trailcnt );
  846.  
  847.             for ( i = 1; i <= actvp; ++i )
  848.                 scset[actvsc[i]] =
  849.                 mkbranch( scset[actvsc[i]], pat );
  850.             } break;
  851. case 17:
  852. # line 163 "parse.y"
  853. {
  854.             pat = yypvt[-0];
  855.             finish_rule( pat, variable_trail_rule,
  856.                      headcnt, trailcnt );
  857.  
  858.             /* add to all non-exclusive start conditions,
  859.              * including the default (0) start condition
  860.              */
  861.  
  862.             for ( i = 1; i <= lastsc; ++i )
  863.                 if ( ! scxclu[i] )
  864.                 scbol[i] = mkbranch( scbol[i], pat );
  865.  
  866.             if ( ! bol_needed )
  867.                 {
  868.                 bol_needed = true;
  869.  
  870.                 if ( performance_report )
  871.                 pinpoint_message(
  872.                 "'^' operator results in sub-optimal performance" );
  873.                 }
  874.             } break;
  875. case 18:
  876. # line 187 "parse.y"
  877. {
  878.             pat = yypvt[-0];
  879.             finish_rule( pat, variable_trail_rule,
  880.                      headcnt, trailcnt );
  881.  
  882.             for ( i = 1; i <= lastsc; ++i )
  883.                 if ( ! scxclu[i] )
  884.                 scset[i] = mkbranch( scset[i], pat );
  885.             } break;
  886. case 19:
  887. # line 198 "parse.y"
  888. { build_eof_action(); } break;
  889. case 20:
  890. # line 201 "parse.y"
  891. {
  892.             /* this EOF applies to all start conditions
  893.              * which don't already have EOF actions
  894.              */
  895.             actvp = 0;
  896.  
  897.             for ( i = 1; i <= lastsc; ++i )
  898.                 if ( ! sceof[i] )
  899.                 actvsc[++actvp] = i;
  900.  
  901.             if ( actvp == 0 )
  902.                 pinpoint_message(
  903.         "warning - all start conditions already have <<EOF>> rules" );
  904.  
  905.             else
  906.                 build_eof_action();
  907.             } break;
  908. case 21:
  909. # line 220 "parse.y"
  910. { synerr( "unrecognized rule" ); } break;
  911. case 23:
  912. # line 227 "parse.y"
  913. {
  914.             if ( (scnum = sclookup( nmstr )) == 0 )
  915.                 format_pinpoint_message(
  916.                 "undeclared start condition %s", nmstr );
  917.  
  918.             else
  919.                 actvsc[++actvp] = scnum;
  920.             } break;
  921. case 24:
  922. # line 237 "parse.y"
  923. {
  924.             if ( (scnum = sclookup( nmstr )) == 0 )
  925.                 format_pinpoint_message(
  926.                 "undeclared start condition %s", nmstr );
  927.             else
  928.                 actvsc[actvp = 1] = scnum;
  929.             } break;
  930. case 25:
  931. # line 246 "parse.y"
  932. { synerr( "bad start condition list" ); } break;
  933. case 26:
  934. # line 250 "parse.y"
  935. {
  936.             if ( transchar[lastst[yypvt[-0]]] != SYM_EPSILON )
  937.                 /* provide final transition \now/ so it
  938.                  * will be marked as a trailing context
  939.                  * state
  940.                  */
  941.                 yypvt[-0] = link_machines( yypvt[-0], mkstate( SYM_EPSILON ) );
  942.  
  943.             mark_beginning_as_normal( yypvt[-0] );
  944.             current_state_type = STATE_NORMAL;
  945.  
  946.             if ( previous_continued_action )
  947.                 {
  948.                 /* we need to treat this as variable trailing
  949.                  * context so that the backup does not happen
  950.                  * in the action but before the action switch
  951.                  * statement.  If the backup happens in the
  952.                  * action, then the rules "falling into" this
  953.                  * one's action will *also* do the backup,
  954.                  * erroneously.
  955.                  */
  956.                 if ( ! varlength || headcnt != 0 )
  957.                 {
  958.                 fprintf( stderr,
  959.     "%s: warning - trailing context rule at line %d made variable because\n",
  960.                      program_name, linenum );
  961.                 fprintf( stderr,
  962.                      "      of preceding '|' action\n" );
  963.                 }
  964.  
  965.                 /* mark as variable */
  966.                 varlength = true;
  967.                 headcnt = 0;
  968.                 }
  969.  
  970.             if ( varlength && headcnt == 0 )
  971.                 { /* variable trailing context rule */
  972.                 /* mark the first part of the rule as the accepting
  973.                  * "head" part of a trailing context rule
  974.                  */
  975.                 /* by the way, we didn't do this at the beginning
  976.                  * of this production because back then
  977.                  * current_state_type was set up for a trail
  978.                  * rule, and add_accept() can create a new
  979.                  * state ...
  980.                  */
  981.                 add_accept( yypvt[-1], num_rules | YY_TRAILING_HEAD_MASK );
  982.                 variable_trail_rule = true;
  983.                 }
  984.             
  985.             else
  986.                 trailcnt = rulelen;
  987.  
  988.             yyval = link_machines( yypvt[-1], yypvt[-0] );
  989.             } break;
  990. case 27:
  991. # line 307 "parse.y"
  992. { synerr( "trailing context used twice" ); } break;
  993. case 28:
  994. # line 310 "parse.y"
  995. {
  996.             if ( trlcontxt )
  997.                 {
  998.                 synerr( "trailing context used twice" );
  999.                 yyval = mkstate( SYM_EPSILON );
  1000.                 }
  1001.  
  1002.             else if ( previous_continued_action )
  1003.                 {
  1004.                 /* see the comment in the rule for "re2 re"
  1005.                  * above
  1006.                  */
  1007.                 if ( ! varlength || headcnt != 0 )
  1008.                 {
  1009.                 fprintf( stderr,
  1010.     "%s: warning - trailing context rule at line %d made variable because\n",
  1011.                      program_name, linenum );
  1012.                 fprintf( stderr,
  1013.                      "      of preceding '|' action\n" );
  1014.                 }
  1015.  
  1016.                 /* mark as variable */
  1017.                 varlength = true;
  1018.                 headcnt = 0;
  1019.                 }
  1020.  
  1021.             trlcontxt = true;
  1022.  
  1023.             if ( ! varlength )
  1024.                 headcnt = rulelen;
  1025.  
  1026.             ++rulelen;
  1027.             trailcnt = 1;
  1028.  
  1029.             eps = mkstate( SYM_EPSILON );
  1030.             yyval = link_machines( yypvt[-1],
  1031.                  link_machines( eps, mkstate( '\n' ) ) );
  1032.             } break;
  1033. case 29:
  1034. # line 350 "parse.y"
  1035. {
  1036.                 yyval = yypvt[-0];
  1037.  
  1038.             if ( trlcontxt )
  1039.                 {
  1040.                 if ( varlength && headcnt == 0 )
  1041.                 /* both head and trail are variable-length */
  1042.                 variable_trail_rule = true;
  1043.                 else
  1044.                 trailcnt = rulelen;
  1045.                 }
  1046.                 } break;
  1047. case 30:
  1048. # line 366 "parse.y"
  1049. {
  1050.             varlength = true;
  1051.             yyval = mkor( yypvt[-2], yypvt[-0] );
  1052.             } break;
  1053. case 31:
  1054. # line 372 "parse.y"
  1055. { yyval = yypvt[-0]; } break;
  1056. case 32:
  1057. # line 377 "parse.y"
  1058. {
  1059.             /* this rule is written separately so
  1060.              * the reduction will occur before the trailing
  1061.              * series is parsed
  1062.              */
  1063.  
  1064.             if ( trlcontxt )
  1065.                 synerr( "trailing context used twice" );
  1066.             else
  1067.                 trlcontxt = true;
  1068.  
  1069.             if ( varlength )
  1070.                 /* we hope the trailing context is fixed-length */
  1071.                 varlength = false;
  1072.             else
  1073.                 headcnt = rulelen;
  1074.  
  1075.             rulelen = 0;
  1076.  
  1077.             current_state_type = STATE_TRAILING_CONTEXT;
  1078.             yyval = yypvt[-1];
  1079.             } break;
  1080. case 33:
  1081. # line 402 "parse.y"
  1082. {
  1083.             /* this is where concatenation of adjacent patterns
  1084.              * gets done
  1085.              */
  1086.             yyval = link_machines( yypvt[-1], yypvt[-0] );
  1087.             } break;
  1088. case 34:
  1089. # line 410 "parse.y"
  1090. { yyval = yypvt[-0]; } break;
  1091. case 35:
  1092. # line 414 "parse.y"
  1093. {
  1094.             varlength = true;
  1095.  
  1096.             yyval = mkclos( yypvt[-1] );
  1097.             } break;
  1098. case 36:
  1099. # line 421 "parse.y"
  1100. {
  1101.             varlength = true;
  1102.  
  1103.             yyval = mkposcl( yypvt[-1] );
  1104.             } break;
  1105. case 37:
  1106. # line 428 "parse.y"
  1107. {
  1108.             varlength = true;
  1109.  
  1110.             yyval = mkopt( yypvt[-1] );
  1111.             } break;
  1112. case 38:
  1113. # line 435 "parse.y"
  1114. {
  1115.             varlength = true;
  1116.  
  1117.             if ( yypvt[-3] > yypvt[-1] || yypvt[-3] < 0 )
  1118.                 {
  1119.                 synerr( "bad iteration values" );
  1120.                 yyval = yypvt[-5];
  1121.                 }
  1122.             else
  1123.                 {
  1124.                 if ( yypvt[-3] == 0 )
  1125.                 yyval = mkopt( mkrep( yypvt[-5], yypvt[-3], yypvt[-1] ) );
  1126.                 else
  1127.                 yyval = mkrep( yypvt[-5], yypvt[-3], yypvt[-1] );
  1128.                 }
  1129.             } break;
  1130. case 39:
  1131. # line 453 "parse.y"
  1132. {
  1133.             varlength = true;
  1134.  
  1135.             if ( yypvt[-2] <= 0 )
  1136.                 {
  1137.                 synerr( "iteration value must be positive" );
  1138.                 yyval = yypvt[-4];
  1139.                 }
  1140.  
  1141.             else
  1142.                 yyval = mkrep( yypvt[-4], yypvt[-2], INFINITY );
  1143.             } break;
  1144. case 40:
  1145. # line 467 "parse.y"
  1146. {
  1147.             /* the singleton could be something like "(foo)",
  1148.              * in which case we have no idea what its length
  1149.              * is, so we punt here.
  1150.              */
  1151.             varlength = true;
  1152.  
  1153.             if ( yypvt[-1] <= 0 )
  1154.                 {
  1155.                 synerr( "iteration value must be positive" );
  1156.                 yyval = yypvt[-3];
  1157.                 }
  1158.  
  1159.             else
  1160.                 yyval = link_machines( yypvt[-3], copysingl( yypvt[-3], yypvt[-1] - 1 ) );
  1161.             } break;
  1162. case 41:
  1163. # line 485 "parse.y"
  1164. {
  1165.             if ( ! madeany )
  1166.                 {
  1167.                 /* create the '.' character class */
  1168.                 anyccl = cclinit();
  1169.                 ccladd( anyccl, '\n' );
  1170.                 cclnegate( anyccl );
  1171.  
  1172.                 if ( useecs )
  1173.                 mkeccl( ccltbl + cclmap[anyccl],
  1174.                     ccllen[anyccl], nextecm,
  1175.                     ecgroup, csize, csize );
  1176.  
  1177.                 madeany = true;
  1178.                 }
  1179.  
  1180.             ++rulelen;
  1181.  
  1182.             yyval = mkstate( -anyccl );
  1183.             } break;
  1184. case 42:
  1185. # line 507 "parse.y"
  1186. {
  1187.             if ( ! cclsorted )
  1188.                 /* sort characters for fast searching.  We use a
  1189.                  * shell sort since this list could be large.
  1190.                  */
  1191.                 cshell( ccltbl + cclmap[yypvt[-0]], ccllen[yypvt[-0]], true );
  1192.  
  1193.             if ( useecs )
  1194.                 mkeccl( ccltbl + cclmap[yypvt[-0]], ccllen[yypvt[-0]],
  1195.                     nextecm, ecgroup, csize, csize );
  1196.  
  1197.             ++rulelen;
  1198.  
  1199.             yyval = mkstate( -yypvt[-0] );
  1200.             } break;
  1201. case 43:
  1202. # line 524 "parse.y"
  1203. {
  1204.             ++rulelen;
  1205.  
  1206.             yyval = mkstate( -yypvt[-0] );
  1207.             } break;
  1208. case 44:
  1209. # line 531 "parse.y"
  1210. { yyval = yypvt[-1]; } break;
  1211. case 45:
  1212. # line 534 "parse.y"
  1213. { yyval = yypvt[-1]; } break;
  1214. case 46:
  1215. # line 537 "parse.y"
  1216. {
  1217.             ++rulelen;
  1218.  
  1219.             if ( caseins && yypvt[-0] >= 'A' && yypvt[-0] <= 'Z' )
  1220.                 yypvt[-0] = clower( yypvt[-0] );
  1221.  
  1222.             yyval = mkstate( yypvt[-0] );
  1223.             } break;
  1224. case 47:
  1225. # line 548 "parse.y"
  1226. { yyval = yypvt[-1]; } break;
  1227. case 48:
  1228. # line 551 "parse.y"
  1229. {
  1230.             /* *Sigh* - to be compatible Unix lex, negated ccls
  1231.              * match newlines
  1232.              */
  1233. #ifdef NOTDEF
  1234.             ccladd( yypvt[-1], '\n' ); /* negated ccls don't match '\n' */
  1235.             cclsorted = false; /* because we added the newline */
  1236. #endif
  1237.             cclnegate( yypvt[-1] );
  1238.             yyval = yypvt[-1];
  1239.             } break;
  1240. case 49:
  1241. # line 565 "parse.y"
  1242. {
  1243.             if ( yypvt[-2] > yypvt[-0] )
  1244.                 synerr( "negative range in character class" );
  1245.  
  1246.             else
  1247.                 {
  1248.                 if ( caseins )
  1249.                 {
  1250.                 if ( yypvt[-2] >= 'A' && yypvt[-2] <= 'Z' )
  1251.                     yypvt[-2] = clower( yypvt[-2] );
  1252.                 if ( yypvt[-0] >= 'A' && yypvt[-0] <= 'Z' )
  1253.                     yypvt[-0] = clower( yypvt[-0] );
  1254.                 }
  1255.  
  1256.                 for ( i = yypvt[-2]; i <= yypvt[-0]; ++i )
  1257.                     ccladd( yypvt[-3], i );
  1258.  
  1259.                 /* keep track if this ccl is staying in alphabetical
  1260.                  * order
  1261.                  */
  1262.                 cclsorted = cclsorted && (yypvt[-2] > lastchar);
  1263.                 lastchar = yypvt[-0];
  1264.                 }
  1265.  
  1266.             yyval = yypvt[-3];
  1267.             } break;
  1268. case 50:
  1269. # line 593 "parse.y"
  1270. {
  1271.             if ( caseins )
  1272.                 if ( yypvt[-0] >= 'A' && yypvt[-0] <= 'Z' )
  1273.                 yypvt[-0] = clower( yypvt[-0] );
  1274.  
  1275.             ccladd( yypvt[-1], yypvt[-0] );
  1276.             cclsorted = cclsorted && (yypvt[-0] > lastchar);
  1277.             lastchar = yypvt[-0];
  1278.             yyval = yypvt[-1];
  1279.             } break;
  1280. case 51:
  1281. # line 605 "parse.y"
  1282. {
  1283.             cclsorted = true;
  1284.             lastchar = 0;
  1285.             yyval = cclinit();
  1286.             } break;
  1287. case 52:
  1288. # line 613 "parse.y"
  1289. {
  1290.             if ( caseins )
  1291.                 if ( yypvt[-0] >= 'A' && yypvt[-0] <= 'Z' )
  1292.                 yypvt[-0] = clower( yypvt[-0] );
  1293.  
  1294.             ++rulelen;
  1295.  
  1296.             yyval = link_machines( yypvt[-1], mkstate( yypvt[-0] ) );
  1297.             } break;
  1298. case 53:
  1299. # line 624 "parse.y"
  1300. { yyval = mkstate( SYM_EPSILON ); } break;
  1301.     }
  1302.     goto yystack;        /* reset registers in driver code */
  1303. }
  1304.