www.pudn.com > flex_bingle.rar > parse.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 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# else # ifdef __hpux void *alloca (); # else # ifdef __TURBOC__ # include # 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 "< >" 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 < > 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 < > 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); }