1#ifndef lint
2static char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
3#endif
4#define YYBYACC 1
5#define YYMAJOR 1
6#define YYMINOR 9
7#define yyclearin (yychar=(-1))
8#define yyerrok (yyerrflag=0)
9#define YYRECOVERING (yyerrflag!=0)
10#define YYPREFIX "yy"
11#line 10 "./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 with or without
24 * modification are permitted provided that: (1) source distributions retain
25 * this entire copyright notice and comment, and (2) distributions including
26 * binaries display the following acknowledgement:  ``This product includes
27 * software developed by the University of California, Berkeley and its
28 * contributors'' in the documentation or other materials provided with the
29 * distribution and in all advertising materials mentioning features or use
30 * of this software.  Neither the name of the University nor the names of
31 * its contributors may be used to endorse or promote products derived from
32 * this software without 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/* $Header: /projects/cvsroot/src/router/flex/MISC/parse.c,v 1.1.1.1 2001/04/08 23:53:37 mhuang Exp $ */
39
40
41/* Some versions of bison are broken in that they use alloca() but don't
42 * declare it properly.  The following is the patented (just kidding!)
43 * #ifdef chud to fix the problem, courtesy of Francois Pinard.
44 */
45#ifdef YYBISON
46/* AIX requires this to be the first thing in the file.  What a piece.  */
47# ifdef _AIX
48 #pragma alloca
49# endif
50#endif
51
52#include "flexdef.h"
53
54/* The remainder of the alloca() cruft has to come after including flexdef.h,
55 * so HAVE_ALLOCA_H is (possibly) defined.
56 */
57#ifdef YYBISON
58# ifdef __GNUC__
59#  ifndef alloca
60#   define alloca __builtin_alloca
61#  endif
62# else
63#  if HAVE_ALLOCA_H
64#   include <alloca.h>
65#  else
66#   ifdef __hpux
67void *alloca ();
68#   else
69#    ifdef __TURBOC__
70#     include <malloc.h>
71#    else
72char *alloca ();
73#    endif
74#   endif
75#  endif
76# endif
77#endif
78
79/* Bletch, ^^^^ that was ugly! */
80
81
82int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, rulelen;
83int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
84
85int *scon_stk;
86int scon_stk_ptr;
87
88static int madeany = false;  /* whether we've made the '.' character class */
89int previous_continued_action;	/* whether the previous rule's action was '|' */
90
91/* Expand a POSIX character class expression. */
92#define CCL_EXPR(func) \
93	{ \
94	int c; \
95	for ( c = 0; c < csize; ++c ) \
96		if ( isascii(c) && func(c) ) \
97			ccladd( currccl, c ); \
98	}
99
100/* While POSIX defines isblank(), it's not ANSI C. */
101#define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
102
103/* On some over-ambitious machines, such as DEC Alpha's, the default
104 * token type is "long" instead of "int"; this leads to problems with
105 * declaring yylval in flexdef.h.  But so far, all the yacc's I've seen
106 * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
107 * following should ensure that the default token type is "int".
108 */
109#define YYSTYPE int
110
111#line 112 "y.tab.c"
112#define CHAR 257
113#define NUMBER 258
114#define SECTEND 259
115#define SCDECL 260
116#define XSCDECL 261
117#define NAME 262
118#define PREVCCL 263
119#define EOF_OP 264
120#define OPTION_OP 265
121#define OPT_OUTFILE 266
122#define OPT_PREFIX 267
123#define OPT_YYCLASS 268
124#define CCE_ALNUM 269
125#define CCE_ALPHA 270
126#define CCE_BLANK 271
127#define CCE_CNTRL 272
128#define CCE_DIGIT 273
129#define CCE_GRAPH 274
130#define CCE_LOWER 275
131#define CCE_PRINT 276
132#define CCE_PUNCT 277
133#define CCE_SPACE 278
134#define CCE_UPPER 279
135#define CCE_XDIGIT 280
136#define YYERRCODE 256
137short yylhs[] = {                                        -1,
138    0,    1,    2,    2,    2,    2,    3,    6,    6,    7,
139    7,    7,    8,    9,    9,   10,   10,   10,    4,    4,
140    4,    5,   12,   12,   12,   12,   14,   11,   11,   11,
141   15,   15,   15,   16,   13,   13,   13,   13,   18,   18,
142   17,   19,   19,   20,   20,   20,   20,   20,   20,   20,
143   20,   20,   20,   20,   20,   21,   21,   23,   23,   23,
144   23,   24,   24,   24,   24,   24,   24,   24,   24,   24,
145   24,   24,   24,   22,   22,
146};
147short yylen[] = {                                         2,
148    5,    0,    3,    2,    0,    1,    1,    1,    1,    2,
149    1,    1,    2,    2,    0,    3,    3,    3,    5,    5,
150    0,    0,    2,    1,    1,    1,    0,    4,    3,    0,
151    3,    1,    1,    1,    2,    3,    2,    1,    3,    1,
152    2,    2,    1,    2,    2,    2,    6,    5,    4,    1,
153    1,    1,    3,    3,    1,    3,    4,    4,    2,    2,
154    0,    1,    1,    1,    1,    1,    1,    1,    1,    1,
155    1,    1,    1,    2,    0,
156};
157short yydefred[] = {                                      2,
158    0,    0,    6,    0,    7,    8,    9,   15,   21,    0,
159    4,    0,    0,   12,   11,    0,    0,    0,    0,   14,
160    0,    1,    0,   10,    0,    0,    0,    0,    0,   21,
161    0,   16,   17,   18,   29,   33,   34,    0,   32,    0,
162   26,   55,   52,   25,    0,   50,   75,    0,    0,    0,
163   24,    0,    0,    0,    0,   51,   28,    0,   20,   23,
164    0,    0,   61,    0,   19,    0,   37,    0,   41,    0,
165    0,   44,   45,   46,   31,   74,   53,   54,    0,    0,
166   62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
167   72,   73,   56,   60,   36,    0,    0,   57,    0,   49,
168    0,   58,    0,   48,   47,
169};
170short yydgoto[] = {                                       1,
171    2,    4,    9,   13,   22,   10,   16,   11,   12,   20,
172   23,   50,   51,   29,   38,   39,   52,   53,   54,   55,
173   56,   61,   64,   94,
174};
175short yysindex[] = {                                      0,
176    0, -235,    0, -191,    0,    0,    0,    0,    0, -207,
177    0, -215,  -18,    0,    0, -202,    4,   26,   32,    0,
178   41,    0,  -35,    0, -168, -166, -165,   38, -180,    0,
179  -30,    0,    0,    0,    0,    0,    0,  -16,    0,  -40,
180    0,    0,    0,    0,   -2,    0,    0,   -2,    8,   93,
181    0,   -2,  -25,   -2,   15,    0,    0, -153,    0,    0,
182  -27,  -26,    0,  -88,    0,  -23,    0,   -2,    0,   15,
183 -150,    0,    0,    0,    0,    0,    0,    0,   -3,   65,
184    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
185    0,    0,    0,    0,    0,   -2,  -21,    0, -145,    0,
186 -116,    0,  -12,    0,    0,
187};
188short yyrindex[] = {                                      0,
189    0, -188,    0,    0,    0,    0,    0,    0,    0,    0,
190    0, -154,    1,    0,    0, -140,    0,    0,    0,    0,
191 -176,    0,  -28,    0,    0,    0,    0,    0,    0,    0,
192    0,    0,    0,    0,    0,    0,    0,    0,    0,  -32,
193    0,    0,    0,    0,    0,    0,    0,    0,   22,    0,
194    0,    0,  106,    7,  -10,    0,    0,    0,    0,    0,
195    0,    0,    0,    0,    0,  108,    0,    0,    0,   -7,
196    0,    0,    0,    0,    0,    0,    0,    0,    0,   46,
197    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
198    0,    0,    0,    0,    0,    9,    0,    0,    0,    0,
199    0,    0,    0,    0,    0,
200};
201short yygindex[] = {                                      0,
202    0,    0,    0,   92,  100,    0,    0,    0,    0,    0,
203    0,    0,   81,    0,    0,   69,    0,   27,   60,  -29,
204    0,    0,   66,    0,
205};
206#define YYTABLESIZE 326
207short yytable[] = {                                      43,
208   22,   30,   42,   47,   93,   22,   77,   30,  104,   48,
209   67,   22,   95,   30,   78,   46,   40,   22,   39,   21,
210    3,   69,  101,   43,   70,   43,   42,   58,   42,   43,
211   43,   47,   42,   42,   30,   43,   43,   48,   42,   42,
212   30,   21,   40,   46,   39,   57,   30,   40,   14,   39,
213   17,   18,   19,   40,   15,   39,   72,   73,   30,   24,
214   49,   30,   22,   45,   25,   22,   70,    5,    6,    7,
215    5,    5,    5,    8,   62,   36,    5,   74,   66,   27,
216   43,   37,   28,   42,   59,   27,   26,   30,   49,   98,
217   30,   30,   27,   32,   30,   33,   34,   68,   68,   35,
218   68,   63,   65,  100,   13,   13,   13,   97,   37,   99,
219   13,  102,  105,   43,   61,   38,   42,   35,    3,    3,
220    3,   40,   31,   30,    3,   60,   75,   96,   79,    0,
221   40,    0,   39,    0,    0,    0,    0,   71,   59,    0,
222    0,  103,    0,    0,    0,    0,    0,    0,    0,    0,
223    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
224    0,    0,    0,    0,    0,    0,    0,    0,   80,    0,
225    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
226   81,   82,   83,   84,   85,   86,   87,   88,   89,   90,
227   91,   92,    0,    0,    0,    0,    0,    0,    0,    0,
228    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
229    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
230    0,    0,    0,   30,   30,   41,   42,   22,   22,   76,
231   30,   30,   43,   44,   22,   22,    0,    0,    0,    0,
232    0,    0,    0,    0,    0,    0,   43,    0,    0,   42,
233    0,    0,   43,   80,   42,   42,   30,   30,    0,    0,
234   43,    0,    0,   30,   30,   81,   82,   83,   84,   85,
235   86,   87,   88,   89,   90,   91,   92,    0,   61,    0,
236    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
237   61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
238   61,   61,   59,    0,    0,    0,    0,    0,    0,    0,
239    0,    0,    0,    0,   59,   59,   59,   59,   59,   59,
240   59,   59,   59,   59,   59,   59,
241};
242short yycheck[] = {                                      10,
243    0,   34,   10,   34,   93,   34,   34,   40,  125,   40,
244   36,   40,   36,   46,   41,   46,   10,   46,   10,   60,
245  256,   47,   44,   34,   54,   36,   34,   44,   36,   40,
246   41,   34,   40,   41,   34,   46,   47,   40,   46,   47,
247   40,   60,   36,   46,   36,   62,   46,   41,  256,   41,
248  266,  267,  268,   47,  262,   47,   42,   43,   91,  262,
249   91,   94,   91,   94,   61,   94,   96,  259,  260,  261,
250  259,  260,  261,  265,   48,  256,  265,   63,   52,  256,
251   91,  262,   42,   91,  125,  262,   61,  123,   91,   93,
252  123,   91,   61,  262,   94,  262,  262,  124,  124,   62,
253  124,   94,   10,  125,  259,  260,  261,  258,  262,   45,
254  265,  257,  125,  124,   93,   10,  124,   10,  259,  260,
255  261,   30,   23,  123,  265,   45,   58,   68,   63,   -1,
256  124,   -1,  124,   -1,   -1,   -1,   -1,  123,   93,   -1,
257   -1,  258,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
258   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
259   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,
260   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
261  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
262  279,  280,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
263   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
264   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
265   -1,   -1,   -1,  256,  257,  256,  257,  256,  257,  257,
266  263,  264,  263,  264,  263,  264,   -1,   -1,   -1,   -1,
267   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,   -1,  257,
268   -1,   -1,  263,  257,  257,  263,  256,  257,   -1,   -1,
269  263,   -1,   -1,  263,  264,  269,  270,  271,  272,  273,
270  274,  275,  276,  277,  278,  279,  280,   -1,  257,   -1,
271   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
272  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
273  279,  280,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
274   -1,   -1,   -1,   -1,  269,  270,  271,  272,  273,  274,
275  275,  276,  277,  278,  279,  280,
276};
277#define YYFINAL 1
278#ifndef YYDEBUG
279#define YYDEBUG 0
280#endif
281#define YYMAXTOKEN 280
282#if YYDEBUG
283char *yyname[] = {
284"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2850,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,
2860,0,0,0,0,0,0,0,0,0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2870,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2880,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2890,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2900,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2910,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND",
292"SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
293"OPT_PREFIX","OPT_YYCLASS","CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL",
294"CCE_DIGIT","CCE_GRAPH","CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE",
295"CCE_UPPER","CCE_XDIGIT",
296};
297char *yyrule[] = {
298"$accept : goal",
299"goal : initlex sect1 sect1end sect2 initforrule",
300"initlex :",
301"sect1 : sect1 startconddecl namelist1",
302"sect1 : sect1 options",
303"sect1 :",
304"sect1 : error",
305"sect1end : SECTEND",
306"startconddecl : SCDECL",
307"startconddecl : XSCDECL",
308"namelist1 : namelist1 NAME",
309"namelist1 : NAME",
310"namelist1 : error",
311"options : OPTION_OP optionlist",
312"optionlist : optionlist option",
313"optionlist :",
314"option : OPT_OUTFILE '=' NAME",
315"option : OPT_PREFIX '=' NAME",
316"option : OPT_YYCLASS '=' NAME",
317"sect2 : sect2 scon initforrule flexrule '\\n'",
318"sect2 : sect2 scon '{' sect2 '}'",
319"sect2 :",
320"initforrule :",
321"flexrule : '^' rule",
322"flexrule : rule",
323"flexrule : EOF_OP",
324"flexrule : error",
325"scon_stk_ptr :",
326"scon : '<' scon_stk_ptr namelist2 '>'",
327"scon : '<' '*' '>'",
328"scon :",
329"namelist2 : namelist2 ',' sconname",
330"namelist2 : sconname",
331"namelist2 : error",
332"sconname : NAME",
333"rule : re2 re",
334"rule : re2 re '$'",
335"rule : re '$'",
336"rule : re",
337"re : re '|' series",
338"re : series",
339"re2 : re '/'",
340"series : series singleton",
341"series : singleton",
342"singleton : singleton '*'",
343"singleton : singleton '+'",
344"singleton : singleton '?'",
345"singleton : singleton '{' NUMBER ',' NUMBER '}'",
346"singleton : singleton '{' NUMBER ',' '}'",
347"singleton : singleton '{' NUMBER '}'",
348"singleton : '.'",
349"singleton : fullccl",
350"singleton : PREVCCL",
351"singleton : '\"' string '\"'",
352"singleton : '(' re ')'",
353"singleton : CHAR",
354"fullccl : '[' ccl ']'",
355"fullccl : '[' '^' ccl ']'",
356"ccl : ccl CHAR '-' CHAR",
357"ccl : ccl CHAR",
358"ccl : ccl ccl_expr",
359"ccl :",
360"ccl_expr : CCE_ALNUM",
361"ccl_expr : CCE_ALPHA",
362"ccl_expr : CCE_BLANK",
363"ccl_expr : CCE_CNTRL",
364"ccl_expr : CCE_DIGIT",
365"ccl_expr : CCE_GRAPH",
366"ccl_expr : CCE_LOWER",
367"ccl_expr : CCE_PRINT",
368"ccl_expr : CCE_PUNCT",
369"ccl_expr : CCE_SPACE",
370"ccl_expr : CCE_UPPER",
371"ccl_expr : CCE_XDIGIT",
372"string : string CHAR",
373"string :",
374};
375#endif
376#ifndef YYSTYPE
377typedef int YYSTYPE;
378#endif
379#ifdef YYSTACKSIZE
380#undef YYMAXDEPTH
381#define YYMAXDEPTH YYSTACKSIZE
382#else
383#ifdef YYMAXDEPTH
384#define YYSTACKSIZE YYMAXDEPTH
385#else
386#define YYSTACKSIZE 500
387#define YYMAXDEPTH 500
388#endif
389#endif
390int yydebug;
391int yynerrs;
392int yyerrflag;
393int yychar;
394short *yyssp;
395YYSTYPE *yyvsp;
396YYSTYPE yyval;
397YYSTYPE yylval;
398short yyss[YYSTACKSIZE];
399YYSTYPE yyvs[YYSTACKSIZE];
400#define yystacksize YYSTACKSIZE
401#line 776 "./parse.y"
402
403
404/* build_eof_action - build the "<<EOF>>" action for the active start
405 *                    conditions
406 */
407
408void build_eof_action()
409	{
410	register int i;
411	char action_text[MAXLINE];
412
413	for ( i = 1; i <= scon_stk_ptr; ++i )
414		{
415		if ( sceof[scon_stk[i]] )
416			format_pinpoint_message(
417				"multiple <<EOF>> rules for start condition %s",
418				scname[scon_stk[i]] );
419
420		else
421			{
422			sceof[scon_stk[i]] = true;
423			sprintf( action_text, "case YY_STATE_EOF(%s):\n",
424				scname[scon_stk[i]] );
425			add_action( action_text );
426			}
427		}
428
429	line_directive_out( (FILE *) 0, 1 );
430
431	/* This isn't a normal rule after all - don't count it as
432	 * such, so we don't have any holes in the rule numbering
433	 * (which make generating "rule can never match" warnings
434	 * more difficult.
435	 */
436	--num_rules;
437	++num_eof_rules;
438	}
439
440
441/* format_synerr - write out formatted syntax error */
442
443void format_synerr( msg, arg )
444char msg[], arg[];
445	{
446	char errmsg[MAXLINE];
447
448	(void) sprintf( errmsg, msg, arg );
449	synerr( errmsg );
450	}
451
452
453/* synerr - report a syntax error */
454
455void synerr( str )
456char str[];
457	{
458	syntaxerror = true;
459	pinpoint_message( str );
460	}
461
462
463/* format_warn - write out formatted warning */
464
465void format_warn( msg, arg )
466char msg[], arg[];
467	{
468	char warn_msg[MAXLINE];
469
470	(void) sprintf( warn_msg, msg, arg );
471	warn( warn_msg );
472	}
473
474
475/* warn - report a warning, unless -w was given */
476
477void warn( str )
478char str[];
479	{
480	line_warning( str, linenum );
481	}
482
483/* format_pinpoint_message - write out a message formatted with one string,
484 *			     pinpointing its location
485 */
486
487void format_pinpoint_message( msg, arg )
488char msg[], arg[];
489	{
490	char errmsg[MAXLINE];
491
492	(void) sprintf( errmsg, msg, arg );
493	pinpoint_message( errmsg );
494	}
495
496
497/* pinpoint_message - write out a message, pinpointing its location */
498
499void pinpoint_message( str )
500char str[];
501	{
502	line_pinpoint( str, linenum );
503	}
504
505
506/* line_warning - report a warning at a given line, unless -w was given */
507
508void line_warning( str, line )
509char str[];
510int line;
511	{
512	char warning[MAXLINE];
513
514	if ( ! nowarn )
515		{
516		sprintf( warning, "warning, %s", str );
517		line_pinpoint( warning, line );
518		}
519	}
520
521
522/* line_pinpoint - write out a message, pinpointing it at the given line */
523
524void line_pinpoint( str, line )
525char str[];
526int line;
527	{
528	fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
529	}
530
531
532/* yyerror - eat up an error message from the parser;
533 *	     currently, messages are ignore
534 */
535
536void yyerror( msg )
537char msg[];
538	{
539	}
540#line 541 "y.tab.c"
541#define YYABORT goto yyabort
542#define YYREJECT goto yyabort
543#define YYACCEPT goto yyaccept
544#define YYERROR goto yyerrlab
545int
546yyparse()
547{
548    register int yym, yyn, yystate;
549#if YYDEBUG
550    register char *yys;
551    extern char *getenv();
552
553    if (yys = getenv("YYDEBUG"))
554    {
555        yyn = *yys;
556        if (yyn >= '0' && yyn <= '9')
557            yydebug = yyn - '0';
558    }
559#endif
560
561    yynerrs = 0;
562    yyerrflag = 0;
563    yychar = (-1);
564
565    yyssp = yyss;
566    yyvsp = yyvs;
567    *yyssp = yystate = 0;
568
569yyloop:
570    if (yyn = yydefred[yystate]) goto yyreduce;
571    if (yychar < 0)
572    {
573        if ((yychar = yylex()) < 0) yychar = 0;
574#if YYDEBUG
575        if (yydebug)
576        {
577            yys = 0;
578            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
579            if (!yys) yys = "illegal-symbol";
580            printf("%sdebug: state %d, reading %d (%s)\n",
581                    YYPREFIX, yystate, yychar, yys);
582        }
583#endif
584    }
585    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
586            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
587    {
588#if YYDEBUG
589        if (yydebug)
590            printf("%sdebug: state %d, shifting to state %d\n",
591                    YYPREFIX, yystate, yytable[yyn]);
592#endif
593        if (yyssp >= yyss + yystacksize - 1)
594        {
595            goto yyoverflow;
596        }
597        *++yyssp = yystate = yytable[yyn];
598        *++yyvsp = yylval;
599        yychar = (-1);
600        if (yyerrflag > 0)  --yyerrflag;
601        goto yyloop;
602    }
603    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
604            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
605    {
606        yyn = yytable[yyn];
607        goto yyreduce;
608    }
609    if (yyerrflag) goto yyinrecovery;
610#ifdef lint
611    goto yynewerror;
612#endif
613yynewerror:
614    yyerror("syntax error");
615#ifdef lint
616    goto yyerrlab;
617#endif
618yyerrlab:
619    ++yynerrs;
620yyinrecovery:
621    if (yyerrflag < 3)
622    {
623        yyerrflag = 3;
624        for (;;)
625        {
626            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
627                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
628            {
629#if YYDEBUG
630                if (yydebug)
631                    printf("%sdebug: state %d, error recovery shifting\
632 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
633#endif
634                if (yyssp >= yyss + yystacksize - 1)
635                {
636                    goto yyoverflow;
637                }
638                *++yyssp = yystate = yytable[yyn];
639                *++yyvsp = yylval;
640                goto yyloop;
641            }
642            else
643            {
644#if YYDEBUG
645                if (yydebug)
646                    printf("%sdebug: error recovery discarding state %d\n",
647                            YYPREFIX, *yyssp);
648#endif
649                if (yyssp <= yyss) goto yyabort;
650                --yyssp;
651                --yyvsp;
652            }
653        }
654    }
655    else
656    {
657        if (yychar == 0) goto yyabort;
658#if YYDEBUG
659        if (yydebug)
660        {
661            yys = 0;
662            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
663            if (!yys) yys = "illegal-symbol";
664            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
665                    YYPREFIX, yystate, yychar, yys);
666        }
667#endif
668        yychar = (-1);
669        goto yyloop;
670    }
671yyreduce:
672#if YYDEBUG
673    if (yydebug)
674        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
675                YYPREFIX, yystate, yyn, yyrule[yyn]);
676#endif
677    yym = yylen[yyn];
678    yyval = yyvsp[1-yym];
679    switch (yyn)
680    {
681case 1:
682#line 113 "./parse.y"
683{ /* add default rule */
684			int def_rule;
685
686			pat = cclinit();
687			cclnegate( pat );
688
689			def_rule = mkstate( -pat );
690
691			/* Remember the number of the default rule so we
692			 * don't generate "can't match" warnings for it.
693			 */
694			default_rule = num_rules;
695
696			finish_rule( def_rule, false, 0, 0 );
697
698			for ( i = 1; i <= lastsc; ++i )
699				scset[i] = mkbranch( scset[i], def_rule );
700
701			if ( spprdflt )
702				add_action(
703				"YY_FATAL_ERROR( \"flex scanner jammed\" )" );
704			else
705				add_action( "ECHO" );
706
707			add_action( ";\n\tYY_BREAK\n" );
708			}
709break;
710case 2:
711#line 142 "./parse.y"
712{ /* initialize for processing rules */
713
714			/* Create default DFA start condition. */
715			scinstal( "INITIAL", false );
716			}
717break;
718case 6:
719#line 153 "./parse.y"
720{ synerr( "unknown error processing section 1" ); }
721break;
722case 7:
723#line 157 "./parse.y"
724{
725			check_options();
726			scon_stk = allocate_integer_array( lastsc + 1 );
727			scon_stk_ptr = 0;
728			}
729break;
730case 8:
731#line 165 "./parse.y"
732{ xcluflg = false; }
733break;
734case 9:
735#line 168 "./parse.y"
736{ xcluflg = true; }
737break;
738case 10:
739#line 172 "./parse.y"
740{ scinstal( nmstr, xcluflg ); }
741break;
742case 11:
743#line 175 "./parse.y"
744{ scinstal( nmstr, xcluflg ); }
745break;
746case 12:
747#line 178 "./parse.y"
748{ synerr( "bad start condition list" ); }
749break;
750case 16:
751#line 189 "./parse.y"
752{
753			outfilename = copy_string( nmstr );
754			did_outfilename = 1;
755			}
756break;
757case 17:
758#line 194 "./parse.y"
759{ prefix = copy_string( nmstr ); }
760break;
761case 18:
762#line 196 "./parse.y"
763{ yyclass = copy_string( nmstr ); }
764break;
765case 19:
766#line 200 "./parse.y"
767{ scon_stk_ptr = yyvsp[-3]; }
768break;
769case 20:
770#line 202 "./parse.y"
771{ scon_stk_ptr = yyvsp[-3]; }
772break;
773case 22:
774#line 207 "./parse.y"
775{
776			/* Initialize for a parse of one rule. */
777			trlcontxt = variable_trail_rule = varlength = false;
778			trailcnt = headcnt = rulelen = 0;
779			current_state_type = STATE_NORMAL;
780			previous_continued_action = continued_action;
781			in_rule = true;
782
783			new_rule();
784			}
785break;
786case 23:
787#line 220 "./parse.y"
788{
789			pat = yyvsp[0];
790			finish_rule( pat, variable_trail_rule,
791				headcnt, trailcnt );
792
793			if ( scon_stk_ptr > 0 )
794				{
795				for ( i = 1; i <= scon_stk_ptr; ++i )
796					scbol[scon_stk[i]] =
797						mkbranch( scbol[scon_stk[i]],
798								pat );
799				}
800
801			else
802				{
803				/* Add to all non-exclusive start conditions,
804				 * including the default (0) start condition.
805				 */
806
807				for ( i = 1; i <= lastsc; ++i )
808					if ( ! scxclu[i] )
809						scbol[i] = mkbranch( scbol[i],
810									pat );
811				}
812
813			if ( ! bol_needed )
814				{
815				bol_needed = true;
816
817				if ( performance_report > 1 )
818					pinpoint_message(
819			"'^' operator results in sub-optimal performance" );
820				}
821			}
822break;
823case 24:
824#line 256 "./parse.y"
825{
826			pat = yyvsp[0];
827			finish_rule( pat, variable_trail_rule,
828				headcnt, trailcnt );
829
830			if ( scon_stk_ptr > 0 )
831				{
832				for ( i = 1; i <= scon_stk_ptr; ++i )
833					scset[scon_stk[i]] =
834						mkbranch( scset[scon_stk[i]],
835								pat );
836				}
837
838			else
839				{
840				for ( i = 1; i <= lastsc; ++i )
841					if ( ! scxclu[i] )
842						scset[i] =
843							mkbranch( scset[i],
844								pat );
845				}
846			}
847break;
848case 25:
849#line 280 "./parse.y"
850{
851			if ( scon_stk_ptr > 0 )
852				build_eof_action();
853
854			else
855				{
856				/* This EOF applies to all start conditions
857				 * which don't already have EOF actions.
858				 */
859				for ( i = 1; i <= lastsc; ++i )
860					if ( ! sceof[i] )
861						scon_stk[++scon_stk_ptr] = i;
862
863				if ( scon_stk_ptr == 0 )
864					warn(
865			"all start conditions already have <<EOF>> rules" );
866
867				else
868					build_eof_action();
869				}
870			}
871break;
872case 26:
873#line 303 "./parse.y"
874{ synerr( "unrecognized rule" ); }
875break;
876case 27:
877#line 307 "./parse.y"
878{ yyval = scon_stk_ptr; }
879break;
880case 28:
881#line 311 "./parse.y"
882{ yyval = yyvsp[-2]; }
883break;
884case 29:
885#line 314 "./parse.y"
886{
887			yyval = scon_stk_ptr;
888
889			for ( i = 1; i <= lastsc; ++i )
890				{
891				int j;
892
893				for ( j = 1; j <= scon_stk_ptr; ++j )
894					if ( scon_stk[j] == i )
895						break;
896
897				if ( j > scon_stk_ptr )
898					scon_stk[++scon_stk_ptr] = i;
899				}
900			}
901break;
902case 30:
903#line 331 "./parse.y"
904{ yyval = scon_stk_ptr; }
905break;
906case 33:
907#line 339 "./parse.y"
908{ synerr( "bad start condition list" ); }
909break;
910case 34:
911#line 343 "./parse.y"
912{
913			if ( (scnum = sclookup( nmstr )) == 0 )
914				format_pinpoint_message(
915					"undeclared start condition %s",
916					nmstr );
917			else
918				{
919				for ( i = 1; i <= scon_stk_ptr; ++i )
920					if ( scon_stk[i] == scnum )
921						{
922						format_warn(
923							"<%s> specified twice",
924							scname[scnum] );
925						break;
926						}
927
928				if ( i > scon_stk_ptr )
929					scon_stk[++scon_stk_ptr] = scnum;
930				}
931			}
932break;
933case 35:
934#line 366 "./parse.y"
935{
936			if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON )
937				/* Provide final transition \now/ so it
938				 * will be marked as a trailing context
939				 * state.
940				 */
941				yyvsp[0] = link_machines( yyvsp[0],
942						mkstate( SYM_EPSILON ) );
943
944			mark_beginning_as_normal( yyvsp[0] );
945			current_state_type = STATE_NORMAL;
946
947			if ( previous_continued_action )
948				{
949				/* We need to treat this as variable trailing
950				 * context so that the backup does not happen
951				 * in the action but before the action switch
952				 * statement.  If the backup happens in the
953				 * action, then the rules "falling into" this
954				 * one's action will *also* do the backup,
955				 * erroneously.
956				 */
957				if ( ! varlength || headcnt != 0 )
958					warn(
959		"trailing context made variable due to preceding '|' action" );
960
961				/* Mark as variable. */
962				varlength = true;
963				headcnt = 0;
964				}
965
966			if ( lex_compat || (varlength && headcnt == 0) )
967				{ /* variable trailing context rule */
968				/* Mark the first part of the rule as the
969				 * accepting "head" part of a trailing
970				 * context rule.
971				 *
972				 * By the way, we didn't do this at the
973				 * beginning of this production because back
974				 * then current_state_type was set up for a
975				 * trail rule, and add_accept() can create
976				 * a new state ...
977				 */
978				add_accept( yyvsp[-1],
979					num_rules | YY_TRAILING_HEAD_MASK );
980				variable_trail_rule = true;
981				}
982
983			else
984				trailcnt = rulelen;
985
986			yyval = link_machines( yyvsp[-1], yyvsp[0] );
987			}
988break;
989case 36:
990#line 421 "./parse.y"
991{ synerr( "trailing context used twice" ); }
992break;
993case 37:
994#line 424 "./parse.y"
995{
996			headcnt = 0;
997			trailcnt = 1;
998			rulelen = 1;
999			varlength = false;
1000
1001			current_state_type = STATE_TRAILING_CONTEXT;
1002
1003			if ( trlcontxt )
1004				{
1005				synerr( "trailing context used twice" );
1006				yyval = mkstate( SYM_EPSILON );
1007				}
1008
1009			else if ( previous_continued_action )
1010				{
1011				/* See the comment in the rule for "re2 re"
1012				 * above.
1013				 */
1014				warn(
1015		"trailing context made variable due to preceding '|' action" );
1016
1017				varlength = true;
1018				}
1019
1020			if ( lex_compat || varlength )
1021				{
1022				/* Again, see the comment in the rule for
1023				 * "re2 re" above.
1024				 */
1025				add_accept( yyvsp[-1],
1026					num_rules | YY_TRAILING_HEAD_MASK );
1027				variable_trail_rule = true;
1028				}
1029
1030			trlcontxt = true;
1031
1032			eps = mkstate( SYM_EPSILON );
1033			yyval = link_machines( yyvsp[-1],
1034				link_machines( eps, mkstate( '\n' ) ) );
1035			}
1036break;
1037case 38:
1038#line 467 "./parse.y"
1039{
1040			yyval = yyvsp[0];
1041
1042			if ( trlcontxt )
1043				{
1044				if ( lex_compat || (varlength && headcnt == 0) )
1045					/* Both head and trail are
1046					 * variable-length.
1047					 */
1048					variable_trail_rule = true;
1049				else
1050					trailcnt = rulelen;
1051				}
1052			}
1053break;
1054case 39:
1055#line 485 "./parse.y"
1056{
1057			varlength = true;
1058			yyval = mkor( yyvsp[-2], yyvsp[0] );
1059			}
1060break;
1061case 40:
1062#line 491 "./parse.y"
1063{ yyval = yyvsp[0]; }
1064break;
1065case 41:
1066#line 496 "./parse.y"
1067{
1068			/* This rule is written separately so the
1069			 * reduction will occur before the trailing
1070			 * series is parsed.
1071			 */
1072
1073			if ( trlcontxt )
1074				synerr( "trailing context used twice" );
1075			else
1076				trlcontxt = true;
1077
1078			if ( varlength )
1079				/* We hope the trailing context is
1080				 * fixed-length.
1081				 */
1082				varlength = false;
1083			else
1084				headcnt = rulelen;
1085
1086			rulelen = 0;
1087
1088			current_state_type = STATE_TRAILING_CONTEXT;
1089			yyval = yyvsp[-1];
1090			}
1091break;
1092case 42:
1093#line 523 "./parse.y"
1094{
1095			/* This is where concatenation of adjacent patterns
1096			 * gets done.
1097			 */
1098			yyval = link_machines( yyvsp[-1], yyvsp[0] );
1099			}
1100break;
1101case 43:
1102#line 531 "./parse.y"
1103{ yyval = yyvsp[0]; }
1104break;
1105case 44:
1106#line 535 "./parse.y"
1107{
1108			varlength = true;
1109
1110			yyval = mkclos( yyvsp[-1] );
1111			}
1112break;
1113case 45:
1114#line 542 "./parse.y"
1115{
1116			varlength = true;
1117			yyval = mkposcl( yyvsp[-1] );
1118			}
1119break;
1120case 46:
1121#line 548 "./parse.y"
1122{
1123			varlength = true;
1124			yyval = mkopt( yyvsp[-1] );
1125			}
1126break;
1127case 47:
1128#line 554 "./parse.y"
1129{
1130			varlength = true;
1131
1132			if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 )
1133				{
1134				synerr( "bad iteration values" );
1135				yyval = yyvsp[-5];
1136				}
1137			else
1138				{
1139				if ( yyvsp[-3] == 0 )
1140					{
1141					if ( yyvsp[-1] <= 0 )
1142						{
1143						synerr(
1144						"bad iteration values" );
1145						yyval = yyvsp[-5];
1146						}
1147					else
1148						yyval = mkopt(
1149							mkrep( yyvsp[-5], 1, yyvsp[-1] ) );
1150					}
1151				else
1152					yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] );
1153				}
1154			}
1155break;
1156case 48:
1157#line 582 "./parse.y"
1158{
1159			varlength = true;
1160
1161			if ( yyvsp[-2] <= 0 )
1162				{
1163				synerr( "iteration value must be positive" );
1164				yyval = yyvsp[-4];
1165				}
1166
1167			else
1168				yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITY );
1169			}
1170break;
1171case 49:
1172#line 596 "./parse.y"
1173{
1174			/* The singleton could be something like "(foo)",
1175			 * in which case we have no idea what its length
1176			 * is, so we punt here.
1177			 */
1178			varlength = true;
1179
1180			if ( yyvsp[-1] <= 0 )
1181				{
1182				synerr( "iteration value must be positive" );
1183				yyval = yyvsp[-3];
1184				}
1185
1186			else
1187				yyval = link_machines( yyvsp[-3],
1188						copysingl( yyvsp[-3], yyvsp[-1] - 1 ) );
1189			}
1190break;
1191case 50:
1192#line 615 "./parse.y"
1193{
1194			if ( ! madeany )
1195				{
1196				/* Create the '.' character class. */
1197				anyccl = cclinit();
1198				ccladd( anyccl, '\n' );
1199				cclnegate( anyccl );
1200
1201				if ( useecs )
1202					mkeccl( ccltbl + cclmap[anyccl],
1203						ccllen[anyccl], nextecm,
1204						ecgroup, csize, csize );
1205
1206				madeany = true;
1207				}
1208
1209			++rulelen;
1210
1211			yyval = mkstate( -anyccl );
1212			}
1213break;
1214case 51:
1215#line 637 "./parse.y"
1216{
1217			if ( ! cclsorted )
1218				/* Sort characters for fast searching.  We
1219				 * use a shell sort since this list could
1220				 * be large.
1221				 */
1222				cshell( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], true );
1223
1224			if ( useecs )
1225				mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]],
1226					nextecm, ecgroup, csize, csize );
1227
1228			++rulelen;
1229
1230			yyval = mkstate( -yyvsp[0] );
1231			}
1232break;
1233case 52:
1234#line 655 "./parse.y"
1235{
1236			++rulelen;
1237
1238			yyval = mkstate( -yyvsp[0] );
1239			}
1240break;
1241case 53:
1242#line 662 "./parse.y"
1243{ yyval = yyvsp[-1]; }
1244break;
1245case 54:
1246#line 665 "./parse.y"
1247{ yyval = yyvsp[-1]; }
1248break;
1249case 55:
1250#line 668 "./parse.y"
1251{
1252			++rulelen;
1253
1254			if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
1255				yyvsp[0] = clower( yyvsp[0] );
1256
1257			yyval = mkstate( yyvsp[0] );
1258			}
1259break;
1260case 56:
1261#line 679 "./parse.y"
1262{ yyval = yyvsp[-1]; }
1263break;
1264case 57:
1265#line 682 "./parse.y"
1266{
1267			cclnegate( yyvsp[-1] );
1268			yyval = yyvsp[-1];
1269			}
1270break;
1271case 58:
1272#line 689 "./parse.y"
1273{
1274			if ( caseins )
1275				{
1276				if ( yyvsp[-2] >= 'A' && yyvsp[-2] <= 'Z' )
1277					yyvsp[-2] = clower( yyvsp[-2] );
1278				if ( yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
1279					yyvsp[0] = clower( yyvsp[0] );
1280				}
1281
1282			if ( yyvsp[-2] > yyvsp[0] )
1283				synerr( "negative range in character class" );
1284
1285			else
1286				{
1287				for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i )
1288					ccladd( yyvsp[-3], i );
1289
1290				/* Keep track if this ccl is staying in
1291				 * alphabetical order.
1292				 */
1293				cclsorted = cclsorted && (yyvsp[-2] > lastchar);
1294				lastchar = yyvsp[0];
1295				}
1296
1297			yyval = yyvsp[-3];
1298			}
1299break;
1300case 59:
1301#line 717 "./parse.y"
1302{
1303			if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
1304				yyvsp[0] = clower( yyvsp[0] );
1305
1306			ccladd( yyvsp[-1], yyvsp[0] );
1307			cclsorted = cclsorted && (yyvsp[0] > lastchar);
1308			lastchar = yyvsp[0];
1309			yyval = yyvsp[-1];
1310			}
1311break;
1312case 60:
1313#line 728 "./parse.y"
1314{
1315			/* Too hard to properly maintain cclsorted. */
1316			cclsorted = false;
1317			yyval = yyvsp[-1];
1318			}
1319break;
1320case 61:
1321#line 735 "./parse.y"
1322{
1323			cclsorted = true;
1324			lastchar = 0;
1325			currccl = yyval = cclinit();
1326			}
1327break;
1328case 62:
1329#line 742 "./parse.y"
1330{ CCL_EXPR(isalnum) }
1331break;
1332case 63:
1333#line 743 "./parse.y"
1334{ CCL_EXPR(isalpha) }
1335break;
1336case 64:
1337#line 744 "./parse.y"
1338{ CCL_EXPR(IS_BLANK) }
1339break;
1340case 65:
1341#line 745 "./parse.y"
1342{ CCL_EXPR(iscntrl) }
1343break;
1344case 66:
1345#line 746 "./parse.y"
1346{ CCL_EXPR(isdigit) }
1347break;
1348case 67:
1349#line 747 "./parse.y"
1350{ CCL_EXPR(isgraph) }
1351break;
1352case 68:
1353#line 748 "./parse.y"
1354{ CCL_EXPR(islower) }
1355break;
1356case 69:
1357#line 749 "./parse.y"
1358{ CCL_EXPR(isprint) }
1359break;
1360case 70:
1361#line 750 "./parse.y"
1362{ CCL_EXPR(ispunct) }
1363break;
1364case 71:
1365#line 751 "./parse.y"
1366{ CCL_EXPR(isspace) }
1367break;
1368case 72:
1369#line 752 "./parse.y"
1370{
1371				if ( caseins )
1372					CCL_EXPR(islower)
1373				else
1374					CCL_EXPR(isupper)
1375				}
1376break;
1377case 73:
1378#line 758 "./parse.y"
1379{ CCL_EXPR(isxdigit) }
1380break;
1381case 74:
1382#line 762 "./parse.y"
1383{
1384			if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
1385				yyvsp[0] = clower( yyvsp[0] );
1386
1387			++rulelen;
1388
1389			yyval = link_machines( yyvsp[-1], mkstate( yyvsp[0] ) );
1390			}
1391break;
1392case 75:
1393#line 772 "./parse.y"
1394{ yyval = mkstate( SYM_EPSILON ); }
1395break;
1396#line 1397 "y.tab.c"
1397    }
1398    yyssp -= yym;
1399    yystate = *yyssp;
1400    yyvsp -= yym;
1401    yym = yylhs[yyn];
1402    if (yystate == 0 && yym == 0)
1403    {
1404#if YYDEBUG
1405        if (yydebug)
1406            printf("%sdebug: after reduction, shifting from state 0 to\
1407 state %d\n", YYPREFIX, YYFINAL);
1408#endif
1409        yystate = YYFINAL;
1410        *++yyssp = YYFINAL;
1411        *++yyvsp = yyval;
1412        if (yychar < 0)
1413        {
1414            if ((yychar = yylex()) < 0) yychar = 0;
1415#if YYDEBUG
1416            if (yydebug)
1417            {
1418                yys = 0;
1419                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
1420                if (!yys) yys = "illegal-symbol";
1421                printf("%sdebug: state %d, reading %d (%s)\n",
1422                        YYPREFIX, YYFINAL, yychar, yys);
1423            }
1424#endif
1425        }
1426        if (yychar == 0) goto yyaccept;
1427        goto yyloop;
1428    }
1429    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
1430            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
1431        yystate = yytable[yyn];
1432    else
1433        yystate = yydgoto[yym];
1434#if YYDEBUG
1435    if (yydebug)
1436        printf("%sdebug: after reduction, shifting from state %d \
1437to state %d\n", YYPREFIX, *yyssp, yystate);
1438#endif
1439    if (yyssp >= yyss + yystacksize - 1)
1440    {
1441        goto yyoverflow;
1442    }
1443    *++yyssp = yystate;
1444    *++yyvsp = yyval;
1445    goto yyloop;
1446yyoverflow:
1447    yyerror("yacc stack overflow");
1448yyabort:
1449    return (1);
1450yyaccept:
1451    return (0);
1452}
1453