| #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: /home/daffy/u0/vern/flex/RCS/parse.y,v 2.28 95/04/21 11:51:51 vern Exp $ */ |
| |
| |
| /* Some versions of bison are broken in that they use alloca() but don't |
| * declare it properly. The following is the patented (just kidding!) |
| * #ifdef chud to fix the problem, courtesy of Francois Pinard. |
| */ |
| #ifdef YYBISON |
| /* AIX requires this to be the first thing in the file. What a piece. */ |
| # ifdef _AIX |
| #pragma alloca |
| # endif |
| #endif |
| |
| #include "flexdef.h" |
| |
| /* The remainder of the alloca() cruft has to come after including flexdef.h, |
| * so HAVE_ALLOCA_H is (possibly) defined. |
| */ |
| #ifdef YYBISON |
| # ifdef __GNUC__ |
| # ifndef alloca |
| # define alloca __builtin_alloca |
| # endif |
| # else |
| # if HAVE_ALLOCA_H |
| # include <alloca.h> |
| # else |
| # ifdef __hpux |
| void *alloca (); |
| # else |
| # ifdef __TURBOC__ |
| # include <malloc.h> |
| # else |
| char *alloca (); |
| # endif |
| # endif |
| # endif |
| # endif |
| #endif |
| |
| /* Bletch, ^^^^ that was ugly! */ |
| |
| |
| int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, rulelen; |
| int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule; |
| |
| int *scon_stk; |
| int scon_stk_ptr; |
| |
| static int madeany = false; /* whether we've made the '.' character class */ |
| int previous_continued_action; /* whether the previous rule's action was '|' */ |
| |
| /* Expand a POSIX character class expression. */ |
| #define CCL_EXPR(func) \ |
| { \ |
| int c; \ |
| for ( c = 0; c < csize; ++c ) \ |
| if ( isascii(c) && func(c) ) \ |
| ccladd( currccl, c ); \ |
| } |
| |
| /* While POSIX defines isblank(), it's not ANSI C. */ |
| #define IS_BLANK(c) ((c) == ' ' || (c) == '\t') |
| |
| /* On some over-ambitious machines, such as DEC Alpha's, the default |
| * token type is "long" instead of "int"; this leads to problems with |
| * declaring yylval in flexdef.h. But so far, all the yacc's I've seen |
| * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the |
| * following should ensure that the default token type is "int". |
| */ |
| #define YYSTYPE int |
| |
| #line 112 "y.tab.c" |
| #define CHAR 257 |
| #define NUMBER 258 |
| #define SECTEND 259 |
| #define SCDECL 260 |
| #define XSCDECL 261 |
| #define NAME 262 |
| #define PREVCCL 263 |
| #define EOF_OP 264 |
| #define OPTION_OP 265 |
| #define OPT_OUTFILE 266 |
| #define OPT_PREFIX 267 |
| #define OPT_YYCLASS 268 |
| #define CCE_ALNUM 269 |
| #define CCE_ALPHA 270 |
| #define CCE_BLANK 271 |
| #define CCE_CNTRL 272 |
| #define CCE_DIGIT 273 |
| #define CCE_GRAPH 274 |
| #define CCE_LOWER 275 |
| #define CCE_PRINT 276 |
| #define CCE_PUNCT 277 |
| #define CCE_SPACE 278 |
| #define CCE_UPPER 279 |
| #define CCE_XDIGIT 280 |
| #define YYERRCODE 256 |
| short yylhs[] = { -1, |
| 0, 1, 2, 2, 2, 2, 3, 6, 6, 7, |
| 7, 7, 8, 9, 9, 10, 10, 10, 4, 4, |
| 4, 5, 12, 12, 12, 12, 14, 11, 11, 11, |
| 15, 15, 15, 16, 13, 13, 13, 13, 18, 18, |
| 17, 19, 19, 20, 20, 20, 20, 20, 20, 20, |
| 20, 20, 20, 20, 20, 21, 21, 23, 23, 23, |
| 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, |
| 24, 24, 24, 22, 22, |
| }; |
| short yylen[] = { 2, |
| 5, 0, 3, 2, 0, 1, 1, 1, 1, 2, |
| 1, 1, 2, 2, 0, 3, 3, 3, 5, 5, |
| 0, 0, 2, 1, 1, 1, 0, 4, 3, 0, |
| 3, 1, 1, 1, 2, 3, 2, 1, 3, 1, |
| 2, 2, 1, 2, 2, 2, 6, 5, 4, 1, |
| 1, 1, 3, 3, 1, 3, 4, 4, 2, 2, |
| 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 2, 0, |
| }; |
| short yydefred[] = { 2, |
| 0, 0, 6, 0, 7, 8, 9, 15, 21, 0, |
| 4, 0, 0, 12, 11, 0, 0, 0, 0, 14, |
| 0, 1, 0, 10, 0, 0, 0, 0, 0, 21, |
| 0, 16, 17, 18, 29, 33, 34, 0, 32, 0, |
| 26, 55, 52, 25, 0, 50, 75, 0, 0, 0, |
| 24, 0, 0, 0, 0, 51, 28, 0, 20, 23, |
| 0, 0, 61, 0, 19, 0, 37, 0, 41, 0, |
| 0, 44, 45, 46, 31, 74, 53, 54, 0, 0, |
| 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, |
| 72, 73, 56, 60, 36, 0, 0, 57, 0, 49, |
| 0, 58, 0, 48, 47, |
| }; |
| short yydgoto[] = { 1, |
| 2, 4, 9, 13, 22, 10, 16, 11, 12, 20, |
| 23, 50, 51, 29, 38, 39, 52, 53, 54, 55, |
| 56, 61, 64, 94, |
| }; |
| short yysindex[] = { 0, |
| 0, -235, 0, -191, 0, 0, 0, 0, 0, -207, |
| 0, -215, -18, 0, 0, -202, 4, 26, 32, 0, |
| 41, 0, -35, 0, -168, -166, -165, 38, -180, 0, |
| -30, 0, 0, 0, 0, 0, 0, -16, 0, -40, |
| 0, 0, 0, 0, -2, 0, 0, -2, 8, 93, |
| 0, -2, -25, -2, 15, 0, 0, -153, 0, 0, |
| -27, -26, 0, -88, 0, -23, 0, -2, 0, 15, |
| -150, 0, 0, 0, 0, 0, 0, 0, -3, 65, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, -2, -21, 0, -145, 0, |
| -116, 0, -12, 0, 0, |
| }; |
| short yyrindex[] = { 0, |
| 0, -188, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, -154, 1, 0, 0, -140, 0, 0, 0, 0, |
| -176, 0, -28, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, -32, |
| 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, |
| 0, 0, 106, 7, -10, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 108, 0, 0, 0, -7, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, |
| }; |
| short yygindex[] = { 0, |
| 0, 0, 0, 92, 100, 0, 0, 0, 0, 0, |
| 0, 0, 81, 0, 0, 69, 0, 27, 60, -29, |
| 0, 0, 66, 0, |
| }; |
| #define YYTABLESIZE 326 |
| short yytable[] = { 43, |
| 22, 30, 42, 47, 93, 22, 77, 30, 104, 48, |
| 67, 22, 95, 30, 78, 46, 40, 22, 39, 21, |
| 3, 69, 101, 43, 70, 43, 42, 58, 42, 43, |
| 43, 47, 42, 42, 30, 43, 43, 48, 42, 42, |
| 30, 21, 40, 46, 39, 57, 30, 40, 14, 39, |
| 17, 18, 19, 40, 15, 39, 72, 73, 30, 24, |
| 49, 30, 22, 45, 25, 22, 70, 5, 6, 7, |
| 5, 5, 5, 8, 62, 36, 5, 74, 66, 27, |
| 43, 37, 28, 42, 59, 27, 26, 30, 49, 98, |
| 30, 30, 27, 32, 30, 33, 34, 68, 68, 35, |
| 68, 63, 65, 100, 13, 13, 13, 97, 37, 99, |
| 13, 102, 105, 43, 61, 38, 42, 35, 3, 3, |
| 3, 40, 31, 30, 3, 60, 75, 96, 79, 0, |
| 40, 0, 39, 0, 0, 0, 0, 71, 59, 0, |
| 0, 103, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 80, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, |
| 91, 92, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 30, 30, 41, 42, 22, 22, 76, |
| 30, 30, 43, 44, 22, 22, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 43, 0, 0, 42, |
| 0, 0, 43, 80, 42, 42, 30, 30, 0, 0, |
| 43, 0, 0, 30, 30, 81, 82, 83, 84, 85, |
| 86, 87, 88, 89, 90, 91, 92, 0, 61, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, |
| 61, 61, 59, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 59, 59, 59, 59, 59, 59, |
| 59, 59, 59, 59, 59, 59, |
| }; |
| short yycheck[] = { 10, |
| 0, 34, 10, 34, 93, 34, 34, 40, 125, 40, |
| 36, 40, 36, 46, 41, 46, 10, 46, 10, 60, |
| 256, 47, 44, 34, 54, 36, 34, 44, 36, 40, |
| 41, 34, 40, 41, 34, 46, 47, 40, 46, 47, |
| 40, 60, 36, 46, 36, 62, 46, 41, 256, 41, |
| 266, 267, 268, 47, 262, 47, 42, 43, 91, 262, |
| 91, 94, 91, 94, 61, 94, 96, 259, 260, 261, |
| 259, 260, 261, 265, 48, 256, 265, 63, 52, 256, |
| 91, 262, 42, 91, 125, 262, 61, 123, 91, 93, |
| 123, 91, 61, 262, 94, 262, 262, 124, 124, 62, |
| 124, 94, 10, 125, 259, 260, 261, 258, 262, 45, |
| 265, 257, 125, 124, 93, 10, 124, 10, 259, 260, |
| 261, 30, 23, 123, 265, 45, 58, 68, 63, -1, |
| 124, -1, 124, -1, -1, -1, -1, 123, 93, -1, |
| -1, 258, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, 257, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, |
| 279, 280, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, 256, 257, 256, 257, 256, 257, 257, |
| 263, 264, 263, 264, 263, 264, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, 257, -1, -1, 257, |
| -1, -1, 263, 257, 257, 263, 256, 257, -1, -1, |
| 263, -1, -1, 263, 264, 269, 270, 271, 272, 273, |
| 274, 275, 276, 277, 278, 279, 280, -1, 257, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, |
| 279, 280, 257, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, 269, 270, 271, 272, 273, 274, |
| 275, 276, 277, 278, 279, 280, |
| }; |
| #define YYFINAL 1 |
| #ifndef YYDEBUG |
| #define YYDEBUG 0 |
| #endif |
| #define YYMAXTOKEN 280 |
| #if YYDEBUG |
| char *yyname[] = { |
| "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
| 0,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0, |
| 0,0,0,0,0,0,0,0,0,0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
| 0,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
| 0,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
| 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
| 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
| 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND", |
| "SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE", |
| "OPT_PREFIX","OPT_YYCLASS","CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL", |
| "CCE_DIGIT","CCE_GRAPH","CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE", |
| "CCE_UPPER","CCE_XDIGIT", |
| }; |
| char *yyrule[] = { |
| "$accept : goal", |
| "goal : initlex sect1 sect1end sect2 initforrule", |
| "initlex :", |
| "sect1 : sect1 startconddecl namelist1", |
| "sect1 : sect1 options", |
| "sect1 :", |
| "sect1 : error", |
| "sect1end : SECTEND", |
| "startconddecl : SCDECL", |
| "startconddecl : XSCDECL", |
| "namelist1 : namelist1 NAME", |
| "namelist1 : NAME", |
| "namelist1 : error", |
| "options : OPTION_OP optionlist", |
| "optionlist : optionlist option", |
| "optionlist :", |
| "option : OPT_OUTFILE '=' NAME", |
| "option : OPT_PREFIX '=' NAME", |
| "option : OPT_YYCLASS '=' NAME", |
| "sect2 : sect2 scon initforrule flexrule '\\n'", |
| "sect2 : sect2 scon '{' sect2 '}'", |
| "sect2 :", |
| "initforrule :", |
| "flexrule : '^' rule", |
| "flexrule : rule", |
| "flexrule : EOF_OP", |
| "flexrule : error", |
| "scon_stk_ptr :", |
| "scon : '<' scon_stk_ptr namelist2 '>'", |
| "scon : '<' '*' '>'", |
| "scon :", |
| "namelist2 : namelist2 ',' sconname", |
| "namelist2 : sconname", |
| "namelist2 : error", |
| "sconname : NAME", |
| "rule : re2 re", |
| "rule : re2 re '$'", |
| "rule : re '$'", |
| "rule : re", |
| "re : re '|' series", |
| "re : series", |
| "re2 : re '/'", |
| "series : series singleton", |
| "series : singleton", |
| "singleton : singleton '*'", |
| "singleton : singleton '+'", |
| "singleton : singleton '?'", |
| "singleton : singleton '{' NUMBER ',' NUMBER '}'", |
| "singleton : singleton '{' NUMBER ',' '}'", |
| "singleton : singleton '{' NUMBER '}'", |
| "singleton : '.'", |
| "singleton : fullccl", |
| "singleton : PREVCCL", |
| "singleton : '\"' string '\"'", |
| "singleton : '(' re ')'", |
| "singleton : CHAR", |
| "fullccl : '[' ccl ']'", |
| "fullccl : '[' '^' ccl ']'", |
| "ccl : ccl CHAR '-' CHAR", |
| "ccl : ccl CHAR", |
| "ccl : ccl ccl_expr", |
| "ccl :", |
| "ccl_expr : CCE_ALNUM", |
| "ccl_expr : CCE_ALPHA", |
| "ccl_expr : CCE_BLANK", |
| "ccl_expr : CCE_CNTRL", |
| "ccl_expr : CCE_DIGIT", |
| "ccl_expr : CCE_GRAPH", |
| "ccl_expr : CCE_LOWER", |
| "ccl_expr : CCE_PRINT", |
| "ccl_expr : CCE_PUNCT", |
| "ccl_expr : CCE_SPACE", |
| "ccl_expr : CCE_UPPER", |
| "ccl_expr : CCE_XDIGIT", |
| "string : string CHAR", |
| "string :", |
| }; |
| #endif |
| #ifndef YYSTYPE |
| typedef int YYSTYPE; |
| #endif |
| #ifdef YYSTACKSIZE |
| #undef YYMAXDEPTH |
| #define YYMAXDEPTH YYSTACKSIZE |
| #else |
| #ifdef YYMAXDEPTH |
| #define YYSTACKSIZE YYMAXDEPTH |
| #else |
| #define YYSTACKSIZE 500 |
| #define YYMAXDEPTH 500 |
| #endif |
| #endif |
| int yydebug; |
| int yynerrs; |
| int yyerrflag; |
| int yychar; |
| short *yyssp; |
| YYSTYPE *yyvsp; |
| YYSTYPE yyval; |
| YYSTYPE yylval; |
| short yyss[YYSTACKSIZE]; |
| YYSTYPE yyvs[YYSTACKSIZE]; |
| #define yystacksize YYSTACKSIZE |
| #line 776 "./parse.y" |
| |
| |
| /* build_eof_action - build the "<<EOF>>" action for the active start |
| * conditions |
| */ |
| |
| void build_eof_action() |
| { |
| register int i; |
| char action_text[MAXLINE]; |
| |
| for ( i = 1; i <= scon_stk_ptr; ++i ) |
| { |
| if ( sceof[scon_stk[i]] ) |
| format_pinpoint_message( |
| "multiple <<EOF>> rules for start condition %s", |
| scname[scon_stk[i]] ); |
| |
| else |
| { |
| sceof[scon_stk[i]] = true; |
| sprintf( action_text, "case YY_STATE_EOF(%s):\n", |
| scname[scon_stk[i]] ); |
| add_action( action_text ); |
| } |
| } |
| |
| line_directive_out( (FILE *) 0, 1 ); |
| |
| /* This isn't a normal rule after all - don't count it as |
| * such, so we don't have any holes in the rule numbering |
| * (which make generating "rule can never match" warnings |
| * more difficult. |
| */ |
| --num_rules; |
| ++num_eof_rules; |
| } |
| |
| |
| /* format_synerr - write out formatted syntax error */ |
| |
| void format_synerr( msg, arg ) |
| char msg[], arg[]; |
| { |
| char errmsg[MAXLINE]; |
| |
| (void) sprintf( errmsg, msg, arg ); |
| synerr( errmsg ); |
| } |
| |
| |
| /* synerr - report a syntax error */ |
| |
| void synerr( str ) |
| char str[]; |
| { |
| syntaxerror = true; |
| pinpoint_message( str ); |
| } |
| |
| |
| /* format_warn - write out formatted warning */ |
| |
| void format_warn( msg, arg ) |
| char msg[], arg[]; |
| { |
| char warn_msg[MAXLINE]; |
| |
| (void) sprintf( warn_msg, msg, arg ); |
| warn( warn_msg ); |
| } |
| |
| |
| /* warn - report a warning, unless -w was given */ |
| |
| void warn( str ) |
| char str[]; |
| { |
| line_warning( str, linenum ); |
| } |
| |
| /* format_pinpoint_message - write out a message formatted with one string, |
| * pinpointing its location |
| */ |
| |
| 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); |
| } |
