1453 lines
35 KiB
C
1453 lines
35 KiB
C
#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);
|
|
}
|