sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/commands/flex-2.5.4/MISC/parse.c

1453 lines
35 KiB
C
Raw Normal View History

Flex-2.5.4.
2005-07-11 14:54:10 +02:00
#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 with or without
* modification 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$ */
/* 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
*/
void format_pinpoint_message( msg, arg )
char msg[], arg[];
{
char errmsg[MAXLINE];
(void) sprintf( errmsg, msg, arg );
pinpoint_message( errmsg );
}
/* pinpoint_message - write out a message, pinpointing its location */
void pinpoint_message( str )
char str[];
{
line_pinpoint( str, linenum );
}
/* line_warning - report a warning at a given line, unless -w was given */
void line_warning( str, line )
char str[];
int line;
{
char warning[MAXLINE];
if ( ! nowarn )
{
sprintf( warning, "warning, %s", str );
line_pinpoint( warning, line );
}
}
/* line_pinpoint - write out a message, pinpointing it at the given line */
void line_pinpoint( str, line )
char str[];
int line;
{
fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
}
/* yyerror - eat up an error message from the parser;
* currently, messages are ignore
*/
void yyerror( msg )
char msg[];
{
}
#line 541 "y.tab.c"
#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse()
{
register int yym, yyn, yystate;
#if YYDEBUG
register char *yys;
extern char *getenv();
if (yys = getenv("YYDEBUG"))
{
yyn = *yys;
if (yyn >= '0' && yyn <= '9')
yydebug = yyn - '0';
}
#endif
yynerrs = 0;
yyerrflag = 0;
yychar = (-1);
yyssp = yyss;
yyvsp = yyvs;
*yyssp = yystate = 0;
yyloop:
if (yyn = yydefred[yystate]) goto yyreduce;
if (yychar < 0)
{
if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, reading %d (%s)\n",
YYPREFIX, yystate, yychar, yys);
}
#endif
}
if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, shifting to state %d\n",
YYPREFIX, yystate, yytable[yyn]);
#endif
if (yyssp >= yyss + yystacksize - 1)
{
goto yyoverflow;
}
*++yyssp = yystate = yytable[yyn];
*++yyvsp = yylval;
yychar = (-1);
if (yyerrflag > 0) --yyerrflag;
goto yyloop;
}
if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
{
yyn = yytable[yyn];
goto yyreduce;
}
if (yyerrflag) goto yyinrecovery;
#ifdef lint
goto yynewerror;
#endif
yynewerror:
yyerror("syntax error");
#ifdef lint
goto yyerrlab;
#endif
yyerrlab:
++yynerrs;
yyinrecovery:
if (yyerrflag < 3)
{
yyerrflag = 3;
for (;;)
{
if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, error recovery shifting\
to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
if (yyssp >= yyss + yystacksize - 1)
{
goto yyoverflow;
}
*++yyssp = yystate = yytable[yyn];
*++yyvsp = yylval;
goto yyloop;
}
else
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: error recovery discarding state %d\n",
YYPREFIX, *yyssp);
#endif
if (yyssp <= yyss) goto yyabort;
--yyssp;
--yyvsp;
}
}
}
else
{
if (yychar == 0) goto yyabort;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
YYPREFIX, yystate, yychar, yys);
}
#endif
yychar = (-1);
goto yyloop;
}
yyreduce:
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, reducing by rule %d (%s)\n",
YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
yym = yylen[yyn];
yyval = yyvsp[1-yym];
switch (yyn)
{
case 1:
#line 113 "./parse.y"
{ /* add default rule */
int def_rule;
pat = cclinit();
cclnegate( pat );
def_rule = mkstate( -pat );
/* Remember the number of the default rule so we
* don't generate "can't match" warnings for it.
*/
default_rule = num_rules;
finish_rule( def_rule, false, 0, 0 );
for ( i = 1; i <= lastsc; ++i )
scset[i] = mkbranch( scset[i], def_rule );
if ( spprdflt )
add_action(
"YY_FATAL_ERROR( \"flex scanner jammed\" )" );
else
add_action( "ECHO" );
add_action( ";\n\tYY_BREAK\n" );
}
break;
case 2:
#line 142 "./parse.y"
{ /* initialize for processing rules */
/* Create default DFA start condition. */
scinstal( "INITIAL", false );
}
break;
case 6:
#line 153 "./parse.y"
{ synerr( "unknown error processing section 1" ); }
break;
case 7:
#line 157 "./parse.y"
{
check_options();
scon_stk = allocate_integer_array( lastsc + 1 );
scon_stk_ptr = 0;
}
break;
case 8:
#line 165 "./parse.y"
{ xcluflg = false; }
break;
case 9:
#line 168 "./parse.y"
{ xcluflg = true; }
break;
case 10:
#line 172 "./parse.y"
{ scinstal( nmstr, xcluflg ); }
break;
case 11:
#line 175 "./parse.y"
{ scinstal( nmstr, xcluflg ); }
break;
case 12:
#line 178 "./parse.y"
{ synerr( "bad start condition list" ); }
break;
case 16:
#line 189 "./parse.y"
{
outfilename = copy_string( nmstr );
did_outfilename = 1;
}
break;
case 17:
#line 194 "./parse.y"
{ prefix = copy_string( nmstr ); }
break;
case 18:
#line 196 "./parse.y"
{ yyclass = copy_string( nmstr ); }
break;
case 19:
#line 200 "./parse.y"
{ scon_stk_ptr = yyvsp[-3]; }
break;
case 20:
#line 202 "./parse.y"
{ scon_stk_ptr = yyvsp[-3]; }
break;
case 22:
#line 207 "./parse.y"
{
/* Initialize for a parse of one rule. */
trlcontxt = variable_trail_rule = varlength = false;
trailcnt = headcnt = rulelen = 0;
current_state_type = STATE_NORMAL;
previous_continued_action = continued_action;
in_rule = true;
new_rule();
}
break;
case 23:
#line 220 "./parse.y"
{
pat = yyvsp[0];
finish_rule( pat, variable_trail_rule,
headcnt, trailcnt );
if ( scon_stk_ptr > 0 )
{
for ( i = 1; i <= scon_stk_ptr; ++i )
scbol[scon_stk[i]] =
mkbranch( scbol[scon_stk[i]],
pat );
}
else
{
/* Add to all non-exclusive start conditions,
* including the default (0) start condition.
*/
for ( i = 1; i <= lastsc; ++i )
if ( ! scxclu[i] )
scbol[i] = mkbranch( scbol[i],
pat );
}
if ( ! bol_needed )
{
bol_needed = true;
if ( performance_report > 1 )
pinpoint_message(
"'^' operator results in sub-optimal performance" );
}
}
break;
case 24:
#line 256 "./parse.y"
{
pat = yyvsp[0];
finish_rule( pat, variable_trail_rule,
headcnt, trailcnt );
if ( scon_stk_ptr > 0 )
{
for ( i = 1; i <= scon_stk_ptr; ++i )
scset[scon_stk[i]] =
mkbranch( scset[scon_stk[i]],
pat );
}
else
{
for ( i = 1; i <= lastsc; ++i )
if ( ! scxclu[i] )
scset[i] =
mkbranch( scset[i],
pat );
}
}
break;
case 25:
#line 280 "./parse.y"
{
if ( scon_stk_ptr > 0 )
build_eof_action();
else
{
/* This EOF applies to all start conditions
* which don't already have EOF actions.
*/
for ( i = 1; i <= lastsc; ++i )
if ( ! sceof[i] )
scon_stk[++scon_stk_ptr] = i;
if ( scon_stk_ptr == 0 )
warn(
"all start conditions already have <<EOF>> rules" );
else
build_eof_action();
}
}
break;
case 26:
#line 303 "./parse.y"
{ synerr( "unrecognized rule" ); }
break;
case 27:
#line 307 "./parse.y"
{ yyval = scon_stk_ptr; }
break;
case 28:
#line 311 "./parse.y"
{ yyval = yyvsp[-2]; }
break;
case 29:
#line 314 "./parse.y"
{
yyval = scon_stk_ptr;
for ( i = 1; i <= lastsc; ++i )
{
int j;
for ( j = 1; j <= scon_stk_ptr; ++j )
if ( scon_stk[j] == i )
break;
if ( j > scon_stk_ptr )
scon_stk[++scon_stk_ptr] = i;
}
}
break;
case 30:
#line 331 "./parse.y"
{ yyval = scon_stk_ptr; }
break;
case 33:
#line 339 "./parse.y"
{ synerr( "bad start condition list" ); }
break;
case 34:
#line 343 "./parse.y"
{
if ( (scnum = sclookup( nmstr )) == 0 )
format_pinpoint_message(
"undeclared start condition %s",
nmstr );
else
{
for ( i = 1; i <= scon_stk_ptr; ++i )
if ( scon_stk[i] == scnum )
{
format_warn(
"<%s> specified twice",
scname[scnum] );
break;
}
if ( i > scon_stk_ptr )
scon_stk[++scon_stk_ptr] = scnum;
}
}
break;
case 35:
#line 366 "./parse.y"
{
if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON )
/* Provide final transition \now/ so it
* will be marked as a trailing context
* state.
*/
yyvsp[0] = link_machines( yyvsp[0],
mkstate( SYM_EPSILON ) );
mark_beginning_as_normal( yyvsp[0] );
current_state_type = STATE_NORMAL;
if ( previous_continued_action )
{
/* We need to treat this as variable trailing
* context so that the backup does not happen
* in the action but before the action switch
* statement. If the backup happens in the
* action, then the rules "falling into" this
* one's action will *also* do the backup,
* erroneously.
*/
if ( ! varlength || headcnt != 0 )
warn(
"trailing context made variable due to preceding '|' action" );
/* Mark as variable. */
varlength = true;
headcnt = 0;
}
if ( lex_compat || (varlength && headcnt == 0) )
{ /* variable trailing context rule */
/* Mark the first part of the rule as the
* accepting "head" part of a trailing
* context rule.
*
* By the way, we didn't do this at the
* beginning of this production because back
* then current_state_type was set up for a
* trail rule, and add_accept() can create
* a new state ...
*/
add_accept( yyvsp[-1],
num_rules | YY_TRAILING_HEAD_MASK );
variable_trail_rule = true;
}
else
trailcnt = rulelen;
yyval = link_machines( yyvsp[-1], yyvsp[0] );
}
break;
case 36:
#line 421 "./parse.y"
{ synerr( "trailing context used twice" ); }
break;
case 37:
#line 424 "./parse.y"
{
headcnt = 0;
trailcnt = 1;
rulelen = 1;
varlength = false;
current_state_type = STATE_TRAILING_CONTEXT;
if ( trlcontxt )
{
synerr( "trailing context used twice" );
yyval = mkstate( SYM_EPSILON );
}
else if ( previous_continued_action )
{
/* See the comment in the rule for "re2 re"
* above.
*/
warn(
"trailing context made variable due to preceding '|' action" );
varlength = true;
}
if ( lex_compat || varlength )
{
/* Again, see the comment in the rule for
* "re2 re" above.
*/
add_accept( yyvsp[-1],
num_rules | YY_TRAILING_HEAD_MASK );
variable_trail_rule = true;
}
trlcontxt = true;
eps = mkstate( SYM_EPSILON );
yyval = link_machines( yyvsp[-1],
link_machines( eps, mkstate( '\n' ) ) );
}
break;
case 38:
#line 467 "./parse.y"
{
yyval = yyvsp[0];
if ( trlcontxt )
{
if ( lex_compat || (varlength && headcnt == 0) )
/* Both head and trail are
* variable-length.
*/
variable_trail_rule = true;
else
trailcnt = rulelen;
}
}
break;
case 39:
#line 485 "./parse.y"
{
varlength = true;
yyval = mkor( yyvsp[-2], yyvsp[0] );
}
break;
case 40:
#line 491 "./parse.y"
{ yyval = yyvsp[0]; }
break;
case 41:
#line 496 "./parse.y"
{
/* This rule is written separately so the
* reduction will occur before the trailing
* series is parsed.
*/
if ( trlcontxt )
synerr( "trailing context used twice" );
else
trlcontxt = true;
if ( varlength )
/* We hope the trailing context is
* fixed-length.
*/
varlength = false;
else
headcnt = rulelen;
rulelen = 0;
current_state_type = STATE_TRAILING_CONTEXT;
yyval = yyvsp[-1];
}
break;
case 42:
#line 523 "./parse.y"
{
/* This is where concatenation of adjacent patterns
* gets done.
*/
yyval = link_machines( yyvsp[-1], yyvsp[0] );
}
break;
case 43:
#line 531 "./parse.y"
{ yyval = yyvsp[0]; }
break;
case 44:
#line 535 "./parse.y"
{
varlength = true;
yyval = mkclos( yyvsp[-1] );
}
break;
case 45:
#line 542 "./parse.y"
{
varlength = true;
yyval = mkposcl( yyvsp[-1] );
}
break;
case 46:
#line 548 "./parse.y"
{
varlength = true;
yyval = mkopt( yyvsp[-1] );
}
break;
case 47:
#line 554 "./parse.y"
{
varlength = true;
if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 )
{
synerr( "bad iteration values" );
yyval = yyvsp[-5];
}
else
{
if ( yyvsp[-3] == 0 )
{
if ( yyvsp[-1] <= 0 )
{
synerr(
"bad iteration values" );
yyval = yyvsp[-5];
}
else
yyval = mkopt(
mkrep( yyvsp[-5], 1, yyvsp[-1] ) );
}
else
yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] );
}
}
break;
case 48:
#line 582 "./parse.y"
{
varlength = true;
if ( yyvsp[-2] <= 0 )
{
synerr( "iteration value must be positive" );
yyval = yyvsp[-4];
}
else
yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITY );
}
break;
case 49:
#line 596 "./parse.y"
{
/* The singleton could be something like "(foo)",
* in which case we have no idea what its length
* is, so we punt here.
*/
varlength = true;
if ( yyvsp[-1] <= 0 )
{
synerr( "iteration value must be positive" );
yyval = yyvsp[-3];
}
else
yyval = link_machines( yyvsp[-3],
copysingl( yyvsp[-3], yyvsp[-1] - 1 ) );
}
break;
case 50:
#line 615 "./parse.y"
{
if ( ! madeany )
{
/* Create the '.' character class. */
anyccl = cclinit();
ccladd( anyccl, '\n' );
cclnegate( anyccl );
if ( useecs )
mkeccl( ccltbl + cclmap[anyccl],
ccllen[anyccl], nextecm,
ecgroup, csize, csize );
madeany = true;
}
++rulelen;
yyval = mkstate( -anyccl );
}
break;
case 51:
#line 637 "./parse.y"
{
if ( ! cclsorted )
/* Sort characters for fast searching. We
* use a shell sort since this list could
* be large.
*/
cshell( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], true );
if ( useecs )
mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]],
nextecm, ecgroup, csize, csize );
++rulelen;
yyval = mkstate( -yyvsp[0] );
}
break;
case 52:
#line 655 "./parse.y"
{
++rulelen;
yyval = mkstate( -yyvsp[0] );
}
break;
case 53:
#line 662 "./parse.y"
{ yyval = yyvsp[-1]; }
break;
case 54:
#line 665 "./parse.y"
{ yyval = yyvsp[-1]; }
break;
case 55:
#line 668 "./parse.y"
{
++rulelen;
if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
yyvsp[0] = clower( yyvsp[0] );
yyval = mkstate( yyvsp[0] );
}
break;
case 56:
#line 679 "./parse.y"
{ yyval = yyvsp[-1]; }
break;
case 57:
#line 682 "./parse.y"
{
cclnegate( yyvsp[-1] );
yyval = yyvsp[-1];
}
break;
case 58:
#line 689 "./parse.y"
{
if ( caseins )
{
if ( yyvsp[-2] >= 'A' && yyvsp[-2] <= 'Z' )
yyvsp[-2] = clower( yyvsp[-2] );
if ( yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
yyvsp[0] = clower( yyvsp[0] );
}
if ( yyvsp[-2] > yyvsp[0] )
synerr( "negative range in character class" );
else
{
for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i )
ccladd( yyvsp[-3], i );
/* Keep track if this ccl is staying in
* alphabetical order.
*/
cclsorted = cclsorted && (yyvsp[-2] > lastchar);
lastchar = yyvsp[0];
}
yyval = yyvsp[-3];
}
break;
case 59:
#line 717 "./parse.y"
{
if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
yyvsp[0] = clower( yyvsp[0] );
ccladd( yyvsp[-1], yyvsp[0] );
cclsorted = cclsorted && (yyvsp[0] > lastchar);
lastchar = yyvsp[0];
yyval = yyvsp[-1];
}
break;
case 60:
#line 728 "./parse.y"
{
/* Too hard to properly maintain cclsorted. */
cclsorted = false;
yyval = yyvsp[-1];
}
break;
case 61:
#line 735 "./parse.y"
{
cclsorted = true;
lastchar = 0;
currccl = yyval = cclinit();
}
break;
case 62:
#line 742 "./parse.y"
{ CCL_EXPR(isalnum) }
break;
case 63:
#line 743 "./parse.y"
{ CCL_EXPR(isalpha) }
break;
case 64:
#line 744 "./parse.y"
{ CCL_EXPR(IS_BLANK) }
break;
case 65:
#line 745 "./parse.y"
{ CCL_EXPR(iscntrl) }
break;
case 66:
#line 746 "./parse.y"
{ CCL_EXPR(isdigit) }
break;
case 67:
#line 747 "./parse.y"
{ CCL_EXPR(isgraph) }
break;
case 68:
#line 748 "./parse.y"
{ CCL_EXPR(islower) }
break;
case 69:
#line 749 "./parse.y"
{ CCL_EXPR(isprint) }
break;
case 70:
#line 750 "./parse.y"
{ CCL_EXPR(ispunct) }
break;
case 71:
#line 751 "./parse.y"
{ CCL_EXPR(isspace) }
break;
case 72:
#line 752 "./parse.y"
{
if ( caseins )
CCL_EXPR(islower)
else
CCL_EXPR(isupper)
}
break;
case 73:
#line 758 "./parse.y"
{ CCL_EXPR(isxdigit) }
break;
case 74:
#line 762 "./parse.y"
{
if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
yyvsp[0] = clower( yyvsp[0] );
++rulelen;
yyval = link_machines( yyvsp[-1], mkstate( yyvsp[0] ) );
}
break;
case 75:
#line 772 "./parse.y"
{ yyval = mkstate( SYM_EPSILON ); }
break;
#line 1397 "y.tab.c"
}
yyssp -= yym;
yystate = *yyssp;
yyvsp -= yym;
yym = yylhs[yyn];
if (yystate == 0 && yym == 0)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: after reduction, shifting from state 0 to\
state %d\n", YYPREFIX, YYFINAL);
#endif
yystate = YYFINAL;
*++yyssp = YYFINAL;
*++yyvsp = yyval;
if (yychar < 0)
{
if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, reading %d (%s)\n",
YYPREFIX, YYFINAL, yychar, yys);
}
#endif
}
if (yychar == 0) goto yyaccept;
goto yyloop;
}
if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
yystate = yytable[yyn];
else
yystate = yydgoto[yym];
#if YYDEBUG
if (yydebug)
printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
if (yyssp >= yyss + yystacksize - 1)
{
goto yyoverflow;
}
*++yyssp = yystate;
*++yyvsp = yyval;
goto yyloop;
yyoverflow:
yyerror("yacc stack overflow");
yyabort:
return (1);
yyaccept:
return (0);
}
Reference in a new issue Copy permalink