#ifndef lint
static char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
#endif
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define yyclearin (yychar=(-1))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING (yyerrflag!=0)
#define YYPREFIX "yy"
#line 10 "./parse.y"
/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Vern Paxson.
 * 
 * The United States Government has rights in this work pursuant
 * to contract no. DE-AC03-76SF00098 between the United States
 * Department of Energy and the University of California.
 *
 * Redistribution and use in source and binary forms are permitted provided
 * that: (1) source distributions retain this entire copyright notice and
 * comment, and (2) distributions including binaries display the following
 * acknowledgement:  ``This product includes software developed by the
 * University of California, Berkeley and its contributors'' in the
 * documentation or other materials provided with the distribution and in
 * all advertising materials mentioning features or use of this software.
 * Neither the name of the University nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

/* $Header: /home/daffy/u0/vern/flex/RCS/parse.y,v 2.28 95/04/21 11:51:51 vern Exp $ */


/* Some versions of bison are broken in that they use alloca() but don't
 * declare it properly.  The following is the patented (just kidding!)
 * #ifdef chud to fix the problem, courtesy of Francois Pinard.
 */
#ifdef YYBISON
/* AIX requires this to be the first thing in the file.  What a piece.  */
# ifdef _AIX
 #pragma alloca
# endif
#endif

#include "flexdef.h"

/* The remainder of the alloca() cruft has to come after including flexdef.h,
 * so HAVE_ALLOCA_H is (possibly) defined.
 */
#ifdef YYBISON
# ifdef __GNUC__
#  ifndef alloca
#   define alloca __builtin_alloca
#  endif
# else
#  if HAVE_ALLOCA_H
#   include <alloca.h>
#  else
#   ifdef __hpux
void *alloca ();
#   else
#    ifdef __TURBOC__
#     include <malloc.h>
#    else
char *alloca ();
#    endif
#   endif
#  endif
# endif
#endif

/* Bletch, ^^^^ that was ugly! */


int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, rulelen;
int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;

int *scon_stk;
int scon_stk_ptr;

static int madeany = false;  /* whether we've made the '.' character class */
int previous_continued_action;	/* whether the previous rule's action was '|' */

/* Expand a POSIX character class expression. */
#define CCL_EXPR(func) \
	{ \
	int c; \
	for ( c = 0; c < csize; ++c ) \
		if ( isascii(c) && func(c) ) \
			ccladd( currccl, c ); \
	}

/* While POSIX defines isblank(), it's not ANSI C. */
#define IS_BLANK(c) ((c) == ' ' || (c) == '\t')

/* On some over-ambitious machines, such as DEC Alpha's, the default
 * token type is "long" instead of "int"; this leads to problems with
 * declaring yylval in flexdef.h.  But so far, all the yacc's I've seen
 * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
 * following should ensure that the default token type is "int".
 */
#define YYSTYPE int

#line 112 "y.tab.c"
#define CHAR 257
#define NUMBER 258
#define SECTEND 259
#define SCDECL 260
#define XSCDECL 261
#define NAME 262
#define PREVCCL 263
#define EOF_OP 264
#define OPTION_OP 265
#define OPT_OUTFILE 266
#define OPT_PREFIX 267
#define OPT_YYCLASS 268
#define CCE_ALNUM 269
#define CCE_ALPHA 270
#define CCE_BLANK 271
#define CCE_CNTRL 272
#define CCE_DIGIT 273
#define CCE_GRAPH 274
#define CCE_LOWER 275
#define CCE_PRINT 276
#define CCE_PUNCT 277
#define CCE_SPACE 278
#define CCE_UPPER 279
#define CCE_XDIGIT 280
#define YYERRCODE 256
short yylhs[] = {                                        -1,
    0,    1,    2,    2,    2,    2,    3,    6,    6,    7,
    7,    7,    8,    9,    9,   10,   10,   10,    4,    4,
    4,    5,   12,   12,   12,   12,   14,   11,   11,   11,
   15,   15,   15,   16,   13,   13,   13,   13,   18,   18,
   17,   19,   19,   20,   20,   20,   20,   20,   20,   20,
   20,   20,   20,   20,   20,   21,   21,   23,   23,   23,
   23,   24,   24,   24,   24,   24,   24,   24,   24,   24,
   24,   24,   24,   22,   22,
};
short yylen[] = {                                         2,
    5,    0,    3,    2,    0,    1,    1,    1,    1,    2,
    1,    1,    2,    2,    0,    3,    3,    3,    5,    5,
    0,    0,    2,    1,    1,    1,    0,    4,    3,    0,
    3,    1,    1,    1,    2,    3,    2,    1,    3,    1,
    2,    2,    1,    2,    2,    2,    6,    5,    4,    1,
    1,    1,    3,    3,    1,    3,    4,    4,    2,    2,
    0,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    2,    0,
};
short yydefred[] = {                                      2,
    0,    0,    6,    0,    7,    8,    9,   15,   21,    0,
    4,    0,    0,   12,   11,    0,    0,    0,    0,   14,
    0,    1,    0,   10,    0,    0,    0,    0,    0,   21,
    0,   16,   17,   18,   29,   33,   34,    0,   32,    0,
   26,   55,   52,   25,    0,   50,   75,    0,    0,    0,
   24,    0,    0,    0,    0,   51,   28,    0,   20,   23,
    0,    0,   61,    0,   19,    0,   37,    0,   41,    0,
    0,   44,   45,   46,   31,   74,   53,   54,    0,    0,
   62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
   72,   73,   56,   60,   36,    0,    0,   57,    0,   49,
    0,   58,    0,   48,   47,
};
short yydgoto[] = {                                       1,
    2,    4,    9,   13,   22,   10,   16,   11,   12,   20,
   23,   50,   51,   29,   38,   39,   52,   53,   54,   55,
   56,   61,   64,   94,
};
short yysindex[] = {                                      0,
    0, -235,    0, -191,    0,    0,    0,    0,    0, -207,
    0, -215,  -18,    0,    0, -202,    4,   26,   32,    0,
   41,    0,  -35,    0, -168, -166, -165,   38, -180,    0,
  -30,    0,    0,    0,    0,    0,    0,  -16,    0,  -40,
    0,    0,    0,    0,   -2,    0,    0,   -2,    8,   93,
    0,   -2,  -25,   -2,   15,    0,    0, -153,    0,    0,
  -27,  -26,    0,  -88,    0,  -23,    0,   -2,    0,   15,
 -150,    0,    0,    0,    0,    0,    0,    0,   -3,   65,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,   -2,  -21,    0, -145,    0,
 -116,    0,  -12,    0,    0,
};
short yyrindex[] = {                                      0,
    0, -188,    0,    0,    0,    0,    0,    0,    0,    0,
    0, -154,    1,    0,    0, -140,    0,    0,    0,    0,
 -176,    0,  -28,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,  -32,
    0,    0,    0,    0,    0,    0,    0,    0,   22,    0,
    0,    0,  106,    7,  -10,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  108,    0,    0,    0,   -7,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   46,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    9,    0,    0,    0,    0,
    0,    0,    0,    0,    0,
};
short yygindex[] = {                                      0,
    0,    0,    0,   92,  100,    0,    0,    0,    0,    0,
    0,    0,   81,    0,    0,   69,    0,   27,   60,  -29,
    0,    0,   66,    0,
};
#define YYTABLESIZE 326
short yytable[] = {                                      43,
   22,   30,   42,   47,   93,   22,   77,   30,  104,   48,
   67,   22,   95,   30,   78,   46,   40,   22,   39,   21,
    3,   69,  101,   43,   70,   43,   42,   58,   42,   43,
   43,   47,   42,   42,   30,   43,   43,   48,   42,   42,
   30,   21,   40,   46,   39,   57,   30,   40,   14,   39,
   17,   18,   19,   40,   15,   39,   72,   73,   30,   24,
   49,   30,   22,   45,   25,   22,   70,    5,    6,    7,
    5,    5,    5,    8,   62,   36,    5,   74,   66,   27,
   43,   37,   28,   42,   59,   27,   26,   30,   49,   98,
   30,   30,   27,   32,   30,   33,   34,   68,   68,   35,
   68,   63,   65,  100,   13,   13,   13,   97,   37,   99,
   13,  102,  105,   43,   61,   38,   42,   35,    3,    3,
    3,   40,   31,   30,    3,   60,   75,   96,   79,    0,
   40,    0,   39,    0,    0,    0,    0,   71,   59,    0,
    0,  103,    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,   80,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   81,   82,   83,   84,   85,   86,   87,   88,   89,   90,
   91,   92,    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,   30,   30,   41,   42,   22,   22,   76,
   30,   30,   43,   44,   22,   22,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,   43,    0,    0,   42,
    0,    0,   43,   80,   42,   42,   30,   30,    0,    0,
   43,    0,    0,   30,   30,   81,   82,   83,   84,   85,
   86,   87,   88,   89,   90,   91,   92,    0,   61,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
   61,   61,   59,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,   59,   59,   59,   59,   59,   59,
   59,   59,   59,   59,   59,   59,
};
short yycheck[] = {                                      10,
    0,   34,   10,   34,   93,   34,   34,   40,  125,   40,
   36,   40,   36,   46,   41,   46,   10,   46,   10,   60,
  256,   47,   44,   34,   54,   36,   34,   44,   36,   40,
   41,   34,   40,   41,   34,   46,   47,   40,   46,   47,
   40,   60,   36,   46,   36,   62,   46,   41,  256,   41,
  266,  267,  268,   47,  262,   47,   42,   43,   91,  262,
   91,   94,   91,   94,   61,   94,   96,  259,  260,  261,
  259,  260,  261,  265,   48,  256,  265,   63,   52,  256,
   91,  262,   42,   91,  125,  262,   61,  123,   91,   93,
  123,   91,   61,  262,   94,  262,  262,  124,  124,   62,
  124,   94,   10,  125,  259,  260,  261,  258,  262,   45,
  265,  257,  125,  124,   93,   10,  124,   10,  259,  260,
  261,   30,   23,  123,  265,   45,   58,   68,   63,   -1,
  124,   -1,  124,   -1,   -1,   -1,   -1,  123,   93,   -1,
   -1,  258,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  279,  280,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  256,  257,  256,  257,  256,  257,  257,
  263,  264,  263,  264,  263,  264,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,   -1,  257,
   -1,   -1,  263,  257,  257,  263,  256,  257,   -1,   -1,
  263,   -1,   -1,  263,  264,  269,  270,  271,  272,  273,
  274,  275,  276,  277,  278,  279,  280,   -1,  257,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  279,  280,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,  269,  270,  271,  272,  273,  274,
  275,  276,  277,  278,  279,  280,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 280
#if YYDEBUG
char *yyname[] = {
"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,
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,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,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,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,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,0,0,0,0,0,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND",
"SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
"OPT_PREFIX","OPT_YYCLASS","CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL",
"CCE_DIGIT","CCE_GRAPH","CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE",
"CCE_UPPER","CCE_XDIGIT",
};
char *yyrule[] = {
"$accept : goal",
"goal : initlex sect1 sect1end sect2 initforrule",
"initlex :",
"sect1 : sect1 startconddecl namelist1",
"sect1 : sect1 options",
"sect1 :",
"sect1 : error",
"sect1end : SECTEND",
"startconddecl : SCDECL",
"startconddecl : XSCDECL",
"namelist1 : namelist1 NAME",
"namelist1 : NAME",
"namelist1 : error",
"options : OPTION_OP optionlist",
"optionlist : optionlist option",
"optionlist :",
"option : OPT_OUTFILE '=' NAME",
"option : OPT_PREFIX '=' NAME",
"option : OPT_YYCLASS '=' NAME",
"sect2 : sect2 scon initforrule flexrule '\\n'",
"sect2 : sect2 scon '{' sect2 '}'",
"sect2 :",
"initforrule :",
"flexrule : '^' rule",
"flexrule : rule",
"flexrule : EOF_OP",
"flexrule : error",
"scon_stk_ptr :",
"scon : '<' scon_stk_ptr namelist2 '>'",
"scon : '<' '*' '>'",
"scon :",
"namelist2 : namelist2 ',' sconname",
"namelist2 : sconname",
"namelist2 : error",
"sconname : NAME",
"rule : re2 re",
"rule : re2 re '$'",
"rule : re '$'",
"rule : re",
"re : re '|' series",
"re : series",
"re2 : re '/'",
"series : series singleton",
"series : singleton",
"singleton : singleton '*'",
"singleton : singleton '+'",
"singleton : singleton '?'",
"singleton : singleton '{' NUMBER ',' NUMBER '}'",
"singleton : singleton '{' NUMBER ',' '}'",
"singleton : singleton '{' NUMBER '}'",
"singleton : '.'",
"singleton : fullccl",
"singleton : PREVCCL",
"singleton : '\"' string '\"'",
"singleton : '(' re ')'",
"singleton : CHAR",
"fullccl : '[' ccl ']'",
"fullccl : '[' '^' ccl ']'",
"ccl : ccl CHAR '-' CHAR",
"ccl : ccl CHAR",
"ccl : ccl ccl_expr",
"ccl :",
"ccl_expr : CCE_ALNUM",
"ccl_expr : CCE_ALPHA",
"ccl_expr : CCE_BLANK",
"ccl_expr : CCE_CNTRL",
"ccl_expr : CCE_DIGIT",
"ccl_expr : CCE_GRAPH",
"ccl_expr : CCE_LOWER",
"ccl_expr : CCE_PRINT",
"ccl_expr : CCE_PUNCT",
"ccl_expr : CCE_SPACE",
"ccl_expr : CCE_UPPER",
"ccl_expr : CCE_XDIGIT",
"string : string CHAR",
"string :",
};
#endif
#ifndef YYSTYPE
typedef int YYSTYPE;
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH 500
#endif
#endif
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short yyss[YYSTACKSIZE];
YYSTYPE yyvs[YYSTACKSIZE];
#define yystacksize YYSTACKSIZE
#line 776 "./parse.y"


/* build_eof_action - build the "<<EOF>>" action for the active start
 *                    conditions
 */

void build_eof_action()
	{
	register int i;
	char action_text[MAXLINE];

	for ( i = 1; i <= scon_stk_ptr; ++i )
		{
		if ( sceof[scon_stk[i]] )
			format_pinpoint_message(
				"multiple <<EOF>> rules for start condition %s",
				scname[scon_stk[i]] );

		else
			{
			sceof[scon_stk[i]] = true;
			sprintf( action_text, "case YY_STATE_EOF(%s):\n",
				scname[scon_stk[i]] );
			add_action( action_text );
			}
		}

	line_directive_out( (FILE *) 0, 1 );

	/* This isn't a normal rule after all - don't count it as
	 * such, so we don't have any holes in the rule numbering
	 * (which make generating "rule can never match" warnings
	 * more difficult.
	 */
	--num_rules;
	++num_eof_rules;
	}


/* format_synerr - write out formatted syntax error */

void format_synerr( msg, arg )
char msg[], arg[];
	{
	char errmsg[MAXLINE];

	(void) sprintf( errmsg, msg, arg );
	synerr( errmsg );
	}


/* synerr - report a syntax error */

void synerr( str )
char str[];
	{
	syntaxerror = true;
	pinpoint_message( str );
	}


/* format_warn - write out formatted warning */

void format_warn( msg, arg )
char msg[], arg[];
	{
	char warn_msg[MAXLINE];

	(void) sprintf( warn_msg, msg, arg );
	warn( warn_msg );
	}


/* warn - report a warning, unless -w was given */

void warn( str )
char str[];
	{
	line_warning( str, linenum );
	}

/* format_pinpoint_message - write out a message formatted with one string,
 *			     pinpointing its location
 */