diff options
Diffstat (limited to 'funtools/filter/idx.tab.c')
| -rw-r--r-- | funtools/filter/idx.tab.c | 2177 |
1 files changed, 2177 insertions, 0 deletions
diff --git a/funtools/filter/idx.tab.c b/funtools/filter/idx.tab.c new file mode 100644 index 0000000..d38c8af --- /dev/null +++ b/funtools/filter/idx.tab.c @@ -0,0 +1,2177 @@ +/* A Bison parser, made by GNU Bison 2.0. */ + +/* Skeleton parser for GLR parsing with Bison, + Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* This is the parser code for GLR (Generalized LR) parser. */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include <setjmp.h> + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Skeleton name. */ +#define YYSKELETON_NAME "glr.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + +/* Substitute the variable and function names. */ +#define yyparse idxparse +#define yylex idxlex +#define yyerror idxerror +#define yylval idxlval +#define yychar idxchar +#define yydebug idxdebug +#define yynerrs idxnerrs +#define yylloc idxlloc + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NUM = 258, + COL = 259, + FUNC = 260, + REG = 261, + INDEF = 262, + OR = 263, + AND = 264, + NE = 265, + EQ = 266, + GE = 267, + LE = 268, + UMINUS = 269 + }; +#endif +#define NUM 258 +#define COL 259 +#define FUNC 260 +#define REG 261 +#define INDEF 262 +#define OR 263 +#define AND 264 +#define NE 265 +#define EQ 266 +#define GE 267 +#define LE 268 +#define UMINUS 269 + + + + +/* Copy the first part of user declarations. */ +#line 1 "idx.y" + +#include <idx.h> +#include <idx.tab.h> + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 6 "idx.y" +typedef union YYSTYPE { + idxrowrec *row; + idxvalrec *val; +} YYSTYPE; +/* Line 186 of glr.c. */ +#line 115 "idx.tab.c" +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) +typedef struct YYLTYPE +{ + + char yydummy; + +} YYLTYPE; +# define YYLTYPE_IS_DECLARED 1 +# define YYLTYPE_IS_TRIVIAL 1 +#endif + +/* Default (constant) value used for initialization for null + right-hand sides. Unlike the standard yacc.c template, + here we set the default value of $$ to a zeroed-out value. + Since the default value is undefined, this behavior is + technically correct. */ +static YYSTYPE yyval_default; + +/* Copy the second part of user declarations. */ + + +/* Line 217 of glr.c. */ +#line 142 "idx.tab.c" + +#ifndef YYFREE +# define YYFREE free +#endif +#ifndef YYMALLOC +# define YYMALLOC malloc +#endif +#ifndef YYREALLOC +# define YYREALLOC realloc +#endif + +#ifdef __cplusplus + typedef bool yybool; +#else + typedef unsigned char yybool; +#endif +#define yytrue 1 +#define yyfalse 0 + +/*-----------------. +| GCC extensions. | +`-----------------*/ + +#ifndef __attribute__ +/* This feature is available in gcc versions 2.5 and later. */ +# if !defined (__GNUC__) || __GNUC__ < 2 || \ +(__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__ +# define __attribute__(Spec) /* empty */ +# endif +#endif + +#ifndef YYASSERT +# define YYASSERT(condition) ((void) ((condition) || (abort (), 0))) +#endif + +#ifndef ATTRIBUTE_UNUSED +# define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 21 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 143 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 29 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 5 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 30 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 57 +/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ +#define YYMAXRHS 3 +/* YYMAXLEFT -- Maximum number of symbols to the left of a handle + accessed by $0, $-1, etc., in any rule. */ +#define YYMAXLEFT 0 + +/* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 269 + +#define YYTRANSLATE(YYX) \ + ((YYX <= 0) ? YYEOF : \ + (unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 24, 2, 2, 2, 23, 12, 2, + 27, 28, 21, 19, 2, 20, 2, 22, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 15, 2, 16, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 11, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 10, 2, 25, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 13, 14, 17, 18, 26 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = +{ + 0, 0, 3, 5, 7, 11, 15, 19, 21, 23, + 27, 31, 35, 39, 43, 47, 49, 51, 53, 55, + 59, 63, 67, 71, 75, 79, 83, 87, 90, 93, + 96 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const signed char yyrhs[] = +{ + 30, 0, -1, 31, -1, 32, -1, 31, 8, 31, + -1, 31, 9, 31, -1, 27, 31, 28, -1, 6, + -1, 5, -1, 33, 14, 33, -1, 33, 13, 33, + -1, 33, 15, 33, -1, 33, 18, 33, -1, 33, + 16, 33, -1, 33, 17, 33, -1, 3, -1, 4, + -1, 7, -1, 5, -1, 33, 19, 33, -1, 33, + 20, 33, -1, 33, 21, 33, -1, 33, 22, 33, + -1, 33, 23, 33, -1, 33, 12, 33, -1, 33, + 10, 33, -1, 33, 11, 33, -1, 24, 33, -1, + 25, 33, -1, 20, 33, -1, 27, 33, 28, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned char yyrline[] = +{ + 0, 39, 39, 42, 43, 44, 45, 49, 50, 51, + 52, 53, 54, 55, 56, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74 +}; +#endif + +#if (YYDEBUG) || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NUM", "COL", "FUNC", "REG", "INDEF", + "OR", "AND", "'|'", "'^'", "'&'", "NE", "EQ", "'<'", "'>'", "GE", "LE", + "'+'", "'-'", "'*'", "'/'", "'%'", "'!'", "'~'", "UMINUS", "'('", "')'", + "$accept", "idx", "expr", "rowlist", "value", 0 +}; +#endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 29, 30, 31, 31, 31, 31, 32, 32, 32, + 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 33 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 1, 1, 3, 3, 3, 1, 1, 3, + 3, 3, 3, 3, 3, 1, 1, 1, 1, 3, + 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, + 3 +}; + +/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ +static const unsigned char yydprec[] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 +}; + +/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ +static const unsigned char yymerger[] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 +}; + +/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE + doesn't specify something else to do. Zero means the default is an + error. */ +static const unsigned char yydefact[] = +{ + 0, 15, 16, 18, 7, 17, 0, 0, 0, 0, + 0, 2, 3, 0, 18, 0, 29, 27, 28, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 30, 4, 5, 25, 26, 24, 10, 9, 11, 13, + 14, 12, 19, 20, 21, 22, 23 +}; + +/* YYPDEFGOTO[NTERM-NUM]. */ +static const signed char yydefgoto[] = +{ + -1, 10, 11, 12, 13 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -17 +static const signed char yypact[] = +{ + 30, -17, -17, 4, -17, -17, 36, 36, 36, 30, + 8, 2, -17, 89, -17, 36, -17, -17, -17, 37, + 56, -17, 30, 30, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 70, -17, + -17, 5, -17, 108, 120, 114, 103, 103, 103, 103, + 103, 103, -16, -16, -17, -17, -17 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const signed char yypgoto[] = +{ + -17, -17, 29, -17, -6 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -9 +static const signed char yytable[] = +{ + 16, 17, 18, 20, -8, 35, 36, 37, 21, 38, + 22, 23, -8, -8, 23, 0, 0, 0, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, -8, 1, 2, 3, 4, 5, 19, 1, + 2, 14, 0, 5, 0, 22, 23, 0, 0, 0, + 6, 41, 42, 0, 7, 8, 6, 9, 0, 0, + 7, 8, 0, 15, 0, 39, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 24, 25, 26, 0, 40, 0, 0, 0, 0, 33, + 34, 35, 36, 37, 0, 0, 0, 0, 40, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 24, 25, 26, 0, 0, 0, 25, + 26, 0, 33, 34, 35, 36, 37, 33, 34, 35, + 36, 37, 26, 33, 34, 35, 36, 37, 0, 33, + 34, 35, 36, 37 +}; + +/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of + list of conflicting reductions corresponding to action entry for + state STATE-NUM in yytable. 0 means no conflicts. The list in + yyconfl is terminated by a rule number of 0. */ +static const unsigned char yyconflp[] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0 +}; + +/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by + 0, pointed into by YYCONFLP. */ +static const short int yyconfl[] = +{ + 0, 18, 0 +}; + +static const signed char yycheck[] = +{ + 6, 7, 8, 9, 0, 21, 22, 23, 0, 15, + 8, 9, 8, 9, 9, -1, -1, -1, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 28, 3, 4, 5, 6, 7, 9, 3, + 4, 5, -1, 7, -1, 8, 9, -1, -1, -1, + 20, 22, 23, -1, 24, 25, 20, 27, -1, -1, + 24, 25, -1, 27, -1, 28, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 10, 11, 12, -1, 28, -1, -1, -1, -1, 19, + 20, 21, 22, 23, -1, -1, -1, -1, 28, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 10, 11, 12, -1, -1, -1, 11, + 12, -1, 19, 20, 21, 22, 23, 19, 20, 21, + 22, 23, 12, 19, 20, 21, 22, 23, -1, 19, + 20, 21, 22, 23 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 3, 4, 5, 6, 7, 20, 24, 25, 27, + 30, 31, 32, 33, 5, 27, 33, 33, 33, 31, + 33, 0, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 33, 28, + 28, 31, 31, 33, 33, 33, 33, 33, 33, 33, + 33, 33, 33, 33, 33, 33, 33 +}; + + +/* Prevent warning if -Wmissing-prototypes. */ +int yyparse (void); + +/* Error token number */ +#define YYTERROR 1 + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0) +#endif + + +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ +#define YYLEX yylex () + +YYSTYPE yylval; + +YYLTYPE yylloc; + +int yynerrs; +int yychar; + +static const int YYEOF = 0; +static const int YYEMPTY = -2; + +typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; + +#define YYCHK(YYE) \ + do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \ + while (0) + +#if YYDEBUG + +#if ! defined (YYFPRINTF) +# define YYFPRINTF fprintf +#endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +static void +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); +} + + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; + +#else /* !YYDEBUG */ + +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) + +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + +/* Minimum number of free items on the stack allowed after an + allocation. This is to allow allocation and initialization + to be completed by functions that call expandGLRStack before the + stack is expanded, thus insuring that all necessary pointers get + properly redirected to new data. */ +#define YYHEADROOM 2 + +#if (! defined (YYSTACKEXPANDABLE) \ + && (! defined (__cplusplus) \ + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) +#define YYSTACKEXPANDABLE 1 +#else +#define YYSTACKEXPANDABLE 0 +#endif + +/** State numbers, as in LALR(1) machine */ +typedef int yyStateNum; + +/** Rule numbers, as in LALR(1) machine */ +typedef int yyRuleNum; + +/** Grammar symbol */ +typedef short int yySymbol; + +/** Item references, as in LALR(1) machine */ +typedef short int yyItemNum; + +typedef struct yyGLRState yyGLRState; +typedef struct yySemanticOption yySemanticOption; +typedef union yyGLRStackItem yyGLRStackItem; +typedef struct yyGLRStack yyGLRStack; +typedef struct yyGLRStateSet yyGLRStateSet; + +struct yyGLRState { + yybool yyisState; + yybool yyresolved; + yyStateNum yylrState; + yyGLRState* yypred; + size_t yyposn; + union { + yySemanticOption* yyfirstVal; + YYSTYPE yysval; + } yysemantics; + YYLTYPE yyloc; +}; + +struct yyGLRStateSet { + yyGLRState** yystates; + size_t yysize, yycapacity; +}; + +struct yySemanticOption { + yybool yyisState; + yyRuleNum yyrule; + yyGLRState* yystate; + yySemanticOption* yynext; +}; + +union yyGLRStackItem { + yyGLRState yystate; + yySemanticOption yyoption; +}; + +struct yyGLRStack { + int yyerrflag; + int yyerrState; + + + yySymbol* yytokenp; + jmp_buf yyexception_buffer; + yyGLRStackItem* yyitems; + yyGLRStackItem* yynextFree; + int yyspaceLeft; + yyGLRState* yysplitPoint; + yyGLRState* yylastDeleted; + yyGLRStateSet yytops; +}; + +static void yyinitGLRStack (yyGLRStack* yystack, size_t yysize); +static void yyexpandGLRStack (yyGLRStack* yystack); +static void yyfreeGLRStack (yyGLRStack* yystack); + +static void +yyFail (yyGLRStack* yystack, const char* yyformat, ...) +{ + yystack->yyerrflag = 1; + if (yyformat != NULL) + { + char yymsg[256]; + va_list yyap; + va_start (yyap, yyformat); + vsprintf (yymsg, yyformat, yyap); + yyerror (yymsg); + } + longjmp (yystack->yyexception_buffer, 1); +} + +#if YYDEBUG || YYERROR_VERBOSE +/** A printable representation of TOKEN. Valid until next call to + * tokenName. */ +static inline const char* +yytokenName (yySymbol yytoken) +{ + if (yytoken == YYEMPTY) + return ""; + + return yytname[yytoken]; +} +#endif + +/** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting + * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred + * containing the pointer to the next state in the chain. Assumes + * YYLOW1 < YYLOW0. */ +static void yyfillin (yyGLRStackItem *, int, int) ATTRIBUTE_UNUSED; +static void +yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) +{ + yyGLRState* s; + int i; + s = yyvsp[yylow0].yystate.yypred; + for (i = yylow0-1; i >= yylow1; i -= 1) + { + YYASSERT (s->yyresolved); + yyvsp[i].yystate.yyresolved = yytrue; + yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval; + yyvsp[i].yystate.yyloc = s->yyloc; + s = yyvsp[i].yystate.yypred = s->yypred; + } +} + +/* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in + YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. + For convenience, always return YYLOW1. */ +static inline int yyfill (yyGLRStackItem *, int *, int, yybool) + ATTRIBUTE_UNUSED; +static inline int +yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) +{ + if (!yynormal && yylow1 < *yylow) + { + yyfillin (yyvsp, *yylow, yylow1); + *yylow = yylow1; + } + return yylow1; +} + +/** Perform user action for rule number YYN, with RHS length YYRHSLEN, + * and top stack item YYVSP. YYLVALP points to place to put semantic + * value ($$), and yylocp points to place for location information + * (@$). Returns yyok for normal return, yyaccept for YYACCEPT, + * yyerr for YYERROR, yyabort for YYABORT. */ +static YYRESULTTAG +yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, + YYSTYPE* yyvalp, + YYLTYPE* yylocp ATTRIBUTE_UNUSED, + yyGLRStack* yystack + ) +{ + yybool yynormal ATTRIBUTE_UNUSED = (yystack->yysplitPoint == NULL); + int yylow; + +# undef yyerrok +# define yyerrok (yystack->yyerrState = 0) +# undef YYACCEPT +# define YYACCEPT return yyaccept +# undef YYABORT +# define YYABORT return yyabort +# undef YYERROR +# define YYERROR return yyerrok, yyerr +# undef YYRECOVERING +# define YYRECOVERING (yystack->yyerrState != 0) +# undef yyclearin +# define yyclearin (yychar = *(yystack->yytokenp) = YYEMPTY) +# undef YYFILL +# define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal) +# undef YYBACKUP +# define YYBACKUP(Token, Value) \ + return yyerror ("syntax error: cannot back up"), \ + yyerrok, yyerr + + yylow = 1; + if (yyrhslen == 0) + *yyvalp = yyval_default; + else + *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval; + YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen); + + switch (yyn) + { + case 2: +#line 39 "idx.y" + { idxall((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.row)); ;} + break; + + case 4: +#line 43 "idx.y" + { ((*yyvalp).row) = idxor((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.row),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.row)); ;} + break; + + case 5: +#line 44 "idx.y" + { ((*yyvalp).row) = idxand((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.row),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.row)); ;} + break; + + case 6: +#line 45 "idx.y" + { ((*yyvalp).row) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.row); ;} + break; + + case 7: +#line 49 "idx.y" + { ((*yyvalp).row) = idxrowreg((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 8: +#line 50 "idx.y" + { ((*yyvalp).row) = idxrowfun((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 9: +#line 51 "idx.y" + { ((*yyvalp).row) = idxroweq((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 10: +#line 52 "idx.y" + { ((*yyvalp).row) = idxrowne((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 11: +#line 53 "idx.y" + { ((*yyvalp).row) = idxrowlt((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 12: +#line 54 "idx.y" + { ((*yyvalp).row) = idxrowle((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 13: +#line 55 "idx.y" + { ((*yyvalp).row) = idxrowgt((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 14: +#line 56 "idx.y" + { ((*yyvalp).row) = idxrowge((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 19: +#line 63 "idx.y" + { ((*yyvalp).val) = idxvaladd((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 20: +#line 64 "idx.y" + { ((*yyvalp).val) = idxvalsub((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 21: +#line 65 "idx.y" + { ((*yyvalp).val) = idxvalmul((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 22: +#line 66 "idx.y" + { ((*yyvalp).val) = idxvaldiv((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 23: +#line 67 "idx.y" + { ((*yyvalp).val) = idxvalmod((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 24: +#line 68 "idx.y" + { ((*yyvalp).val) = idxvaland((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 25: +#line 69 "idx.y" + { ((*yyvalp).val) = idxvalor((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 26: +#line 70 "idx.y" + { ((*yyvalp).val) = idxvalxor((((yyGLRStackItem const *)yyvsp)[YYFILL (-2)].yystate.yysemantics.yysval.val),(((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 27: +#line 71 "idx.y" + { ((*yyvalp).val) = idxvalnot((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 28: +#line 72 "idx.y" + { ((*yyvalp).val) = idxvalcom((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 29: +#line 73 "idx.y" + { ((*yyvalp).val) = idxvalmin((((yyGLRStackItem const *)yyvsp)[YYFILL (0)].yystate.yysemantics.yysval.val)); ;} + break; + + case 30: +#line 74 "idx.y" + { ((*yyvalp).val) = (((yyGLRStackItem const *)yyvsp)[YYFILL (-1)].yystate.yysemantics.yysval.val); ;} + break; + + + } + + return yyok; +# undef yyerrok +# undef YYABORT +# undef YYACCEPT +# undef YYERROR +# undef YYBACKUP +# undef yyclearin +# undef YYRECOVERING +/* Line 750 of glr.c. */ +#line 890 "idx.tab.c" +} + + +static void +yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) +{ + /* `Use' the arguments. */ + (void) yy0; + (void) yy1; + + switch (yyn) + { + + } +} + + /* Bison grammar-table manipulation. */ + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + +/** Number of symbols composing the right hand side of rule #RULE. */ +static inline int +yyrhsLength (yyRuleNum yyrule) +{ + return yyr2[yyrule]; +} + +/** Left-hand-side symbol for rule #RULE. */ +static inline yySymbol +yylhsNonterm (yyRuleNum yyrule) +{ + return yyr1[yyrule]; +} + +#define yyis_pact_ninf(yystate) \ + ((yystate) == YYPACT_NINF) + +/** True iff LR state STATE has only a default reduction (regardless + * of token). */ +static inline yybool +yyisDefaultedState (yyStateNum yystate) +{ + return yyis_pact_ninf (yypact[yystate]); +} + +/** The default reduction for STATE, assuming it has one. */ +static inline yyRuleNum +yydefaultAction (yyStateNum yystate) +{ + return yydefact[yystate]; +} + +#define yyis_table_ninf(yytable_value) \ + 0 + +/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. + * Result R means + * R < 0: Reduce on rule -R. + * R = 0: Error. + * R > 0: Shift to state R. + * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of + * conflicting reductions. + */ +static inline void +yygetLRActions (yyStateNum yystate, int yytoken, + int* yyaction, const short int** yyconflicts) +{ + int yyindex = yypact[yystate] + yytoken; + if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) + { + *yyaction = -yydefact[yystate]; + *yyconflicts = yyconfl; + } + else if (! yyis_table_ninf (yytable[yyindex])) + { + *yyaction = yytable[yyindex]; + *yyconflicts = yyconfl + yyconflp[yyindex]; + } + else + { + *yyaction = 0; + *yyconflicts = yyconfl + yyconflp[yyindex]; + } +} + +static inline yyStateNum +yyLRgotoState (yyStateNum yystate, yySymbol yylhs) +{ + int yyr; + yyr = yypgoto[yylhs - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) + return yytable[yyr]; + else + return yydefgoto[yylhs - YYNTOKENS]; +} + +static inline yybool +yyisShiftAction (int yyaction) +{ + return 0 < yyaction; +} + +static inline yybool +yyisErrorAction (int yyaction) +{ + return yyaction == 0; +} + + /* GLRStates */ + +static void +yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate, + yyGLRState* rhs, yyRuleNum yyrule) +{ + yySemanticOption* yynewItem; + yynewItem = &yystack->yynextFree->yyoption; + yystack->yyspaceLeft -= 1; + yystack->yynextFree += 1; + yynewItem->yyisState = yyfalse; + yynewItem->yystate = rhs; + yynewItem->yyrule = yyrule; + yynewItem->yynext = yystate->yysemantics.yyfirstVal; + yystate->yysemantics.yyfirstVal = yynewItem; + if (yystack->yyspaceLeft < YYHEADROOM) + yyexpandGLRStack (yystack); +} + + /* GLRStacks */ + +/** Initialize SET to a singleton set containing an empty stack. */ +static void +yyinitStateSet (yyGLRStateSet* yyset) +{ + yyset->yysize = 1; + yyset->yycapacity = 16; + yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]); + yyset->yystates[0] = NULL; +} + +static void yyfreeStateSet (yyGLRStateSet* yyset) +{ + YYFREE (yyset->yystates); +} + +/** Initialize STACK to a single empty stack, with total maximum + * capacity for all stacks of SIZE. */ +static void +yyinitGLRStack (yyGLRStack* yystack, size_t yysize) +{ + yystack->yyerrflag = 0; + yystack->yyerrState = 0; + yynerrs = 0; + yystack->yyspaceLeft = yysize; + yystack->yynextFree = yystack->yyitems = + (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystack->yynextFree[0]); + yystack->yysplitPoint = NULL; + yystack->yylastDeleted = NULL; + yyinitStateSet (&yystack->yytops); +} + +#define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ + &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE + +/** If STACK is expandable, extend it. WARNING: Pointers into the + stack from outside should be considered invalid after this call. + We always expand when there are 1 or fewer items left AFTER an + allocation, so that we can avoid having external pointers exist + across an allocation. */ +static void +yyexpandGLRStack (yyGLRStack* yystack) +{ +#if YYSTACKEXPANDABLE + yyGLRStack yynewStack; + yyGLRStackItem* yyp0, *yyp1; + size_t yysize, yynewSize; + size_t yyn; + yysize = yystack->yynextFree - yystack->yyitems; + if (YYMAXDEPTH <= yysize) + yyFail (yystack, "parser stack overflow"); + yynewSize = 2*yysize; + if (YYMAXDEPTH < yynewSize) + yynewSize = YYMAXDEPTH; + yyinitGLRStack (&yynewStack, yynewSize); + for (yyp0 = yystack->yyitems, yyp1 = yynewStack.yyitems, yyn = yysize; + 0 < yyn; + yyn -= 1, yyp0 += 1, yyp1 += 1) + { + *yyp1 = *yyp0; + if (*(yybool *) yyp0) + { + yyGLRState* yys0 = &yyp0->yystate; + yyGLRState* yys1 = &yyp1->yystate; + if (yys0->yypred != NULL) + yys1->yypred = + YYRELOC (yyp0, yyp1, yys0->yypred, yystate); + if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL) + yys1->yysemantics.yyfirstVal = + YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); + } + else + { + yySemanticOption* yyv0 = &yyp0->yyoption; + yySemanticOption* yyv1 = &yyp1->yyoption; + if (yyv0->yystate != NULL) + yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); + if (yyv0->yynext != NULL) + yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); + } + } + if (yystack->yysplitPoint != NULL) + yystack->yysplitPoint = YYRELOC (yystack->yyitems, yynewStack.yyitems, + yystack->yysplitPoint, yystate); + + for (yyn = 0; yyn < yystack->yytops.yysize; yyn += 1) + if (yystack->yytops.yystates[yyn] != NULL) + yystack->yytops.yystates[yyn] = + YYRELOC (yystack->yyitems, yynewStack.yyitems, + yystack->yytops.yystates[yyn], yystate); + YYFREE (yystack->yyitems); + yystack->yyitems = yynewStack.yyitems; + yystack->yynextFree = yynewStack.yynextFree + yysize; + yystack->yyspaceLeft = yynewStack.yyspaceLeft - yysize; + +#else + + yyFail (yystack, "parser stack overflow"); +#endif +} + +static void +yyfreeGLRStack (yyGLRStack* yystack) +{ + YYFREE (yystack->yyitems); + yyfreeStateSet (&yystack->yytops); +} + +/** Assuming that S is a GLRState somewhere on STACK, update the + * splitpoint of STACK, if needed, so that it is at least as deep as + * S. */ +static inline void +yyupdateSplit (yyGLRStack* yystack, yyGLRState* yys) +{ + if (yystack->yysplitPoint != NULL && yystack->yysplitPoint > yys) + yystack->yysplitPoint = yys; +} + +/** Invalidate stack #K in STACK. */ +static inline void +yymarkStackDeleted (yyGLRStack* yystack, int yyk) +{ + if (yystack->yytops.yystates[yyk] != NULL) + yystack->yylastDeleted = yystack->yytops.yystates[yyk]; + yystack->yytops.yystates[yyk] = NULL; +} + +/** Undelete the last stack that was marked as deleted. Can only be + done once after a deletion, and only when all other stacks have + been deleted. */ +static void +yyundeleteLastStack (yyGLRStack* yystack) +{ + if (yystack->yylastDeleted == NULL || yystack->yytops.yysize != 0) + return; + yystack->yytops.yystates[0] = yystack->yylastDeleted; + yystack->yytops.yysize = 1; + YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); + yystack->yylastDeleted = NULL; +} + +static inline void +yyremoveDeletes (yyGLRStack* yystack) +{ + size_t yyi, yyj; + yyi = yyj = 0; + while (yyj < yystack->yytops.yysize) + { + if (yystack->yytops.yystates[yyi] == NULL) + { + if (yyi == yyj) + { + YYDPRINTF ((stderr, "Removing dead stacks.\n")); + } + yystack->yytops.yysize -= 1; + } + else + { + yystack->yytops.yystates[yyj] = yystack->yytops.yystates[yyi]; + if (yyj != yyi) + { + YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", + (unsigned long int) yyi, (unsigned long int) yyj)); + } + yyj += 1; + } + yyi += 1; + } +} + +/** Shift to a new state on stack #K of STACK, corresponding to LR state + * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ +static inline void +yyglrShift (yyGLRStack* yystack, int yyk, yyStateNum yylrState, size_t yyposn, + YYSTYPE yysval, YYLTYPE* yylocp) +{ + yyGLRStackItem* yynewItem; + + yynewItem = yystack->yynextFree; + yystack->yynextFree += 1; + yystack->yyspaceLeft -= 1; + yynewItem->yystate.yyisState = yytrue; + yynewItem->yystate.yylrState = yylrState; + yynewItem->yystate.yyposn = yyposn; + yynewItem->yystate.yyresolved = yytrue; + yynewItem->yystate.yypred = yystack->yytops.yystates[yyk]; + yystack->yytops.yystates[yyk] = &yynewItem->yystate; + yynewItem->yystate.yysemantics.yysval = yysval; + yynewItem->yystate.yyloc = *yylocp; + if (yystack->yyspaceLeft < YYHEADROOM) + yyexpandGLRStack (yystack); +} + +/** Shift stack #K of YYSTACK, to a new state corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with the (unresolved) + * semantic value of YYRHS under the action for YYRULE. */ +static inline void +yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState, + size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule) +{ + yyGLRStackItem* yynewItem; + + yynewItem = yystack->yynextFree; + yynewItem->yystate.yyisState = yytrue; + yynewItem->yystate.yylrState = yylrState; + yynewItem->yystate.yyposn = yyposn; + yynewItem->yystate.yyresolved = yyfalse; + yynewItem->yystate.yypred = yystack->yytops.yystates[yyk]; + yynewItem->yystate.yysemantics.yyfirstVal = NULL; + yystack->yytops.yystates[yyk] = &yynewItem->yystate; + yystack->yynextFree += 1; + yystack->yyspaceLeft -= 1; + yyaddDeferredAction (yystack, &yynewItem->yystate, rhs, yyrule); +} + +/** Pop the symbols consumed by reduction #RULE from the top of stack + * #K of STACK, and perform the appropriate semantic action on their + * semantic values. Assumes that all ambiguities in semantic values + * have been previously resolved. Set *VALP to the resulting value, + * and *LOCP to the computed location (if any). Return value is as + * for userAction. */ +static inline YYRESULTTAG +yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, + YYSTYPE* yyvalp, YYLTYPE* yylocp) +{ + int yynrhs = yyrhsLength (yyrule); + + if (yystack->yysplitPoint == NULL) + { + /* Standard special case: single stack. */ + yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk]; + YYASSERT (yyk == 0); + yystack->yynextFree -= yynrhs; + yystack->yyspaceLeft += yynrhs; + yystack->yytops.yystates[0] = & yystack->yynextFree[-1].yystate; + return yyuserAction (yyrule, yynrhs, rhs, + yyvalp, yylocp, yystack); + } + else + { + int yyi; + yyGLRState* yys; + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred + = yystack->yytops.yystates[yyk]; + for (yyi = 0; yyi < yynrhs; yyi += 1) + { + yys = yys->yypred; + YYASSERT (yys); + } + yyupdateSplit (yystack, yys); + yystack->yytops.yystates[yyk] = yys; + return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yyvalp, yylocp, yystack); + } +} + +#if !YYDEBUG +# define YY_REDUCE_PRINT(K, Rule) +#else +# define YY_REDUCE_PRINT(K, Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (K, Rule); \ +} while (0) + +/*----------------------------------------------------------. +| Report that the RULE is going to be reduced on stack #K. | +`----------------------------------------------------------*/ + +static inline void +yy_reduce_print (size_t yyk, yyRuleNum yyrule) +{ + int yyi; + YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu), ", + (unsigned long int) yyk, yyrule - 1, + (unsigned long int) yyrline[yyrule]); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi])); + YYFPRINTF (stderr, "-> %s\n", yytokenName (yyr1[yyrule])); +} +#endif + +/** Pop items off stack #K of STACK according to grammar rule RULE, + * and push back on the resulting nonterminal symbol. Perform the + * semantic action associated with RULE and store its value with the + * newly pushed state, if FORCEEVAL or if STACK is currently + * unambiguous. Otherwise, store the deferred semantic action with + * the new state. If the new state would have an identical input + * position, LR state, and predecessor to an existing state on the stack, + * it is identified with that existing state, eliminating stack #K from + * the STACK. In this case, the (necessarily deferred) semantic value is + * added to the options for the existing state's semantic value. + */ +static inline YYRESULTTAG +yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, + yybool yyforceEval) +{ + size_t yyposn = yystack->yytops.yystates[yyk]->yyposn; + + if (yyforceEval || yystack->yysplitPoint == NULL) + { + YYSTYPE yysval; + YYLTYPE yyloc; + + YY_REDUCE_PRINT (yyk, yyrule); + YYCHK (yydoAction (yystack, yyk, yyrule, &yysval, &yyloc)); + yyglrShift (yystack, yyk, + yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState, + yylhsNonterm (yyrule)), + yyposn, yysval, &yyloc); + } + else + { + size_t yyi; + int yyn; + yyGLRState* yys, *yys0 = yystack->yytops.yystates[yyk]; + yyStateNum yynewLRState; + + for (yys = yystack->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); + 0 < yyn; yyn -= 1) + { + yys = yys->yypred; + YYASSERT (yys); + } + yyupdateSplit (yystack, yys); + yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); + YYDPRINTF ((stderr, + "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n", + (unsigned long int) yyk, yyrule - 1, yynewLRState)); + for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1) + if (yyi != yyk && yystack->yytops.yystates[yyi] != NULL) + { + yyGLRState* yyp, *yysplit = yystack->yysplitPoint; + yyp = yystack->yytops.yystates[yyi]; + while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) + { + if (yyp->yylrState == yynewLRState && yyp->yypred == yys) + { + yyaddDeferredAction (yystack, yyp, yys0, yyrule); + yymarkStackDeleted (yystack, yyk); + YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", + (unsigned long int) yyk, + (unsigned long int) yyi)); + return yyok; + } + yyp = yyp->yypred; + } + } + yystack->yytops.yystates[yyk] = yys; + yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule); + } + return yyok; +} + +static int +yysplitStack (yyGLRStack* yystack, int yyk) +{ + if (yystack->yysplitPoint == NULL) + { + YYASSERT (yyk == 0); + yystack->yysplitPoint = yystack->yytops.yystates[yyk]; + } + if (yystack->yytops.yysize >= yystack->yytops.yycapacity) + { + yystack->yytops.yycapacity *= 2; + yystack->yytops.yystates = + (yyGLRState**) YYREALLOC (yystack->yytops.yystates, + (yystack->yytops.yycapacity + * sizeof yystack->yytops.yystates[0])); + } + yystack->yytops.yystates[yystack->yytops.yysize] + = yystack->yytops.yystates[yyk]; + yystack->yytops.yysize += 1; + return yystack->yytops.yysize-1; +} + +/** True iff Y0 and Y1 represent identical options at the top level. + * That is, they represent the same rule applied to RHS symbols + * that produce the same terminal symbols. */ +static yybool +yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + if (yyy0->yyrule == yyy1->yyrule) + { + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + yyn > 0; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + if (yys0->yyposn != yys1->yyposn) + return yyfalse; + return yytrue; + } + else + return yyfalse; +} + +/** Assuming identicalOptions (Y0,Y1), (destructively) merge the + * alternative semantic values for the RHS-symbols of Y1 into the + * corresponding semantic value sets of the symbols of Y0. */ +static void +yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + yyn > 0; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + if (yys0 == yys1) + break; + else if (! yys0->yyresolved && ! yys1->yyresolved) + { + yySemanticOption* yyz; + for (yyz = yys0->yysemantics.yyfirstVal; yyz->yynext != NULL; + yyz = yyz->yynext) + continue; + yyz->yynext = yys1->yysemantics.yyfirstVal; + } +} + +/** Y0 and Y1 represent two possible actions to take in a given + * parsing state; return 0 if no combination is possible, + * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ +static int +yypreference (yySemanticOption* y0, yySemanticOption* y1) +{ + yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; + int p0 = yydprec[r0], p1 = yydprec[r1]; + + if (p0 == p1) + { + if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) + return 0; + else + return 1; + } + if (p0 == 0 || p1 == 0) + return 0; + if (p0 < p1) + return 3; + if (p1 < p0) + return 2; + return 0; +} + +static YYRESULTTAG yyresolveValue (yySemanticOption* yyoptionList, + yyGLRStack* yystack, YYSTYPE* yyvalp, + YYLTYPE* yylocp); + +static YYRESULTTAG +yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystack) +{ + YYRESULTTAG yyflag; + if (0 < yyn) + { + YYASSERT (yys->yypred); + yyflag = yyresolveStates (yys->yypred, yyn-1, yystack); + if (yyflag != yyok) + return yyflag; + if (! yys->yyresolved) + { + yyflag = yyresolveValue (yys->yysemantics.yyfirstVal, yystack, + &yys->yysemantics.yysval, &yys->yyloc + ); + if (yyflag != yyok) + return yyflag; + yys->yyresolved = yytrue; + } + } + return yyok; +} + +static YYRESULTTAG +yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack, + YYSTYPE* yyvalp, YYLTYPE* yylocp) +{ + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + int yynrhs; + + yynrhs = yyrhsLength (yyopt->yyrule); + YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack)); + yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate; + return yyuserAction (yyopt->yyrule, yynrhs, + yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yyvalp, yylocp, yystack); +} + +#if YYDEBUG +static void +yyreportTree (yySemanticOption* yyx, int yyindent) +{ + int yynrhs = yyrhsLength (yyx->yyrule); + int yyi; + yyGLRState* yys; + yyGLRState* yystates[YYMAXRHS]; + yyGLRState yyleftmost_state; + + for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) + yystates[yyi] = yys; + if (yys == NULL) + { + yyleftmost_state.yyposn = 0; + yystates[0] = &yyleftmost_state; + } + else + yystates[0] = yys; + + if (yyx->yystate->yyposn < yys->yyposn + 1) + YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n", + yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), + yyx->yyrule); + else + YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n", + yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), + yyx->yyrule, (unsigned long int) (yys->yyposn + 1), + (unsigned long int) yyx->yystate->yyposn); + for (yyi = 1; yyi <= yynrhs; yyi += 1) + { + if (yystates[yyi]->yyresolved) + { + if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) + YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "", + yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1])); + else + YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "", + yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]), + (unsigned long int) (yystates[yyi - 1]->yyposn + 1), + (unsigned long int) yystates[yyi]->yyposn); + } + else + yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); + } +} +#endif + +static void +yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, + yyGLRStack* yystack) +{ + /* `Unused' warnings. */ + (void) yyx0; + (void) yyx1; + +#if YYDEBUG + YYFPRINTF (stderr, "Ambiguity detected.\n"); + YYFPRINTF (stderr, "Option 1,\n"); + yyreportTree (yyx0, 2); + YYFPRINTF (stderr, "\nOption 2,\n"); + yyreportTree (yyx1, 2); + YYFPRINTF (stderr, "\n"); +#endif + yyFail (yystack, "ambiguity detected"); +} + + +/** Resolve the ambiguity represented by OPTIONLIST, perform the indicated + * actions, and return the result. */ +static YYRESULTTAG +yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack, + YYSTYPE* yyvalp, YYLTYPE* yylocp) +{ + yySemanticOption* yybest; + yySemanticOption* yyp; + int yymerge; + + yybest = yyoptionList; + yymerge = 0; + for (yyp = yyoptionList->yynext; yyp != NULL; yyp = yyp->yynext) + { + if (yyidenticalOptions (yybest, yyp)) + yymergeOptionSets (yybest, yyp); + else + switch (yypreference (yybest, yyp)) + { + case 0: + yyreportAmbiguity (yybest, yyp, yystack); + break; + case 1: + yymerge = 1; + break; + case 2: + break; + case 3: + yybest = yyp; + yymerge = 0; + break; + } + } + + if (yymerge) + { + int yyprec = yydprec[yybest->yyrule]; + YYCHK (yyresolveAction (yybest, yystack, yyvalp, yylocp)); + for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) + { + if (yyprec == yydprec[yyp->yyrule]) + { + YYSTYPE yyval1; + YYLTYPE yydummy; + YYCHK (yyresolveAction (yyp, yystack, &yyval1, &yydummy)); + yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1); + } + } + return yyok; + } + else + return yyresolveAction (yybest, yystack, yyvalp, yylocp); +} + +static YYRESULTTAG +yyresolveStack (yyGLRStack* yystack) +{ + if (yystack->yysplitPoint != NULL) + { + yyGLRState* yys; + int yyn; + + for (yyn = 0, yys = yystack->yytops.yystates[0]; + yys != yystack->yysplitPoint; + yys = yys->yypred, yyn += 1) + continue; + YYCHK (yyresolveStates (yystack->yytops.yystates[0], yyn, yystack + )); + } + return yyok; +} + +static void +yycompressStack (yyGLRStack* yystack) +{ + yyGLRState* yyp, *yyq, *yyr; + + if (yystack->yytops.yysize != 1 || yystack->yysplitPoint == NULL) + return; + + for (yyp = yystack->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL; + yyp != yystack->yysplitPoint; + yyr = yyp, yyp = yyq, yyq = yyp->yypred) + yyp->yypred = yyr; + + yystack->yyspaceLeft += yystack->yynextFree - yystack->yyitems; + yystack->yynextFree = ((yyGLRStackItem*) yystack->yysplitPoint) + 1; + yystack->yyspaceLeft -= yystack->yynextFree - yystack->yyitems; + yystack->yysplitPoint = NULL; + yystack->yylastDeleted = NULL; + + while (yyr != NULL) + { + yystack->yynextFree->yystate = *yyr; + yyr = yyr->yypred; + yystack->yynextFree->yystate.yypred = & yystack->yynextFree[-1].yystate; + yystack->yytops.yystates[0] = &yystack->yynextFree->yystate; + yystack->yynextFree += 1; + yystack->yyspaceLeft -= 1; + } +} + +static YYRESULTTAG +yyprocessOneStack (yyGLRStack* yystack, int yyk, + size_t yyposn, YYSTYPE* yylvalp, YYLTYPE* yyllocp + ) +{ + int yyaction; + const short int* yyconflicts; + yyRuleNum yyrule; + yySymbol* const yytokenp = yystack->yytokenp; + + while (yystack->yytops.yystates[yyk] != NULL) + { + yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState; + YYDPRINTF ((stderr, "Stack %d Entering state %d\n", yyk, yystate)); + + YYASSERT (yystate != YYFINAL); + + if (yyisDefaultedState (yystate)) + { + yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { + YYDPRINTF ((stderr, "Stack %d dies.\n", yyk)); + yymarkStackDeleted (yystack, yyk); + return yyok; + } + YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse)); + } + else + { + if (*yytokenp == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + *yytokenp = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp); + } + yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts); + + while (*yyconflicts != 0) + { + int yynewStack = yysplitStack (yystack, yyk); + YYDPRINTF ((stderr, "Splitting off stack %d from %d.\n", + yynewStack, yyk)); + YYCHK (yyglrReduce (yystack, yynewStack, + *yyconflicts, yyfalse)); + YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn, + yylvalp, yyllocp)); + yyconflicts += 1; + } + + if (yyisShiftAction (yyaction)) + { + YYDPRINTF ((stderr, "On stack %d, ", yyk)); + YY_SYMBOL_PRINT ("shifting", *yytokenp, yylvalp, yyllocp); + yyglrShift (yystack, yyk, yyaction, yyposn+1, + *yylvalp, yyllocp); + YYDPRINTF ((stderr, ", now in state #%d\n", + yystack->yytops.yystates[yyk]->yylrState)); + break; + } + else if (yyisErrorAction (yyaction)) + { + YYDPRINTF ((stderr, "Stack %d dies.\n", yyk)); + yymarkStackDeleted (yystack, yyk); + break; + } + else + YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse)); + } + } + return yyok; +} + +static void +yyreportSyntaxError (yyGLRStack* yystack, + YYSTYPE* yylvalp, YYLTYPE* yyllocp) +{ + /* `Unused' warnings. */ + (void) yylvalp; + (void) yyllocp; + + if (yystack->yyerrState == 0) + { +#if YYERROR_VERBOSE + yySymbol* const yytokenp = yystack->yytokenp; + int yyn; + yyn = yypact[yystack->yytops.yystates[0]->yylrState]; + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + size_t yysize = 0; + const char* yyprefix; + char* yymsg; + int yyx; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += strlen (yyprefix) + strlen (yytokenName (yyx)); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + yyprefix = " or "; + } + yysize += (sizeof ("syntax error, unexpected ") + + strlen (yytokenName (*yytokenp))); + yymsg = (char*) YYMALLOC (yysize); + if (yymsg != 0) + { + char* yyp = yymsg; + sprintf (yyp, "syntax error%s%s", + (*yytokenp == YYEMPTY ? "" : ", unexpected "), + yytokenName (*yytokenp)); + yyp += strlen (yyp); + if (yycount < 5) + { + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx)); + yyp += strlen (yyp); + yyprefix = " or "; + } + } + yyerror (yymsg); + YYFREE (yymsg); + } + else + yyerror ("syntax error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("syntax error"); + yynerrs += 1; + } +} + +/* Recover from a syntax error on YYSTACK, assuming that YYTOKENP, + YYLVALP, and YYLLOCP point to the syntactic category, semantic + value, and location of the look-ahead. */ +static void +yyrecoverSyntaxError (yyGLRStack* yystack, + YYSTYPE* yylvalp, + YYLTYPE* yyllocp ATTRIBUTE_UNUSED + ) +{ + yySymbol* const yytokenp = yystack->yytokenp; + size_t yyk; + int yyj; + + if (yystack->yyerrState == 3) + /* We just shifted the error token and (perhaps) took some + reductions. Skip tokens until we can proceed. */ + while (yytrue) + { + if (*yytokenp == YYEOF) + { + /* Now pop stack until empty and fail. */ + while (yystack->yytops.yystates[0] != NULL) + { + yyGLRState *yys = yystack->yytops.yystates[0]; + + yydestruct ("Error: popping", + yystos[yys->yylrState], + &yys->yysemantics.yysval); + yystack->yytops.yystates[0] = yys->yypred; + yystack->yynextFree -= 1; + yystack->yyspaceLeft += 1; + } + yyFail (yystack, NULL); + } + if (*yytokenp != YYEMPTY) + { + yydestruct ("Error: discarding", + *yytokenp, yylvalp); + } + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + *yytokenp = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp); + yyj = yypact[yystack->yytops.yystates[0]->yylrState]; + if (yyis_pact_ninf (yyj)) + return; + yyj += *yytokenp; + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp) + { + if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0) + return; + } + else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj])) + return; + } + + /* Reduce to one stack. */ + for (yyk = 0; yyk < yystack->yytops.yysize; yyk += 1) + if (yystack->yytops.yystates[yyk] != NULL) + break; + if (yyk >= yystack->yytops.yysize) + yyFail (yystack, NULL); + for (yyk += 1; yyk < yystack->yytops.yysize; yyk += 1) + yymarkStackDeleted (yystack, yyk); + yyremoveDeletes (yystack); + yycompressStack (yystack); + + /* Now pop stack until we find a state that shifts the error token. */ + yystack->yyerrState = 3; + while (yystack->yytops.yystates[0] != NULL) + { + yyGLRState *yys = yystack->yytops.yystates[0]; + yyj = yypact[yys->yylrState]; + if (! yyis_pact_ninf (yyj)) + { + yyj += YYTERROR; + if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR + && yyisShiftAction (yytable[yyj])) + { + /* Shift the error token having adjusted its location. */ + YYLTYPE yyerrloc; + YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], + yylvalp, &yyerrloc); + yyglrShift (yystack, 0, yytable[yyj], + yys->yyposn, *yylvalp, &yyerrloc); + yys = yystack->yytops.yystates[0]; + break; + } + } + + yydestruct ("Error: popping", + yystos[yys->yylrState], + &yys->yysemantics.yysval); + yystack->yytops.yystates[0] = yys->yypred; + yystack->yynextFree -= 1; + yystack->yyspaceLeft += 1; + } + if (yystack->yytops.yystates[0] == NULL) + yyFail (yystack, NULL); +} + +#define YYCHK1(YYE) \ + do { \ + switch (YYE) { \ + default: \ + break; \ + case yyabort: \ + yystack.yyerrflag = 1; \ + goto yyDone; \ + case yyaccept: \ + yystack.yyerrflag = 0; \ + goto yyDone; \ + case yyerr: \ + goto yyuser_error; \ + } \ + } while (0) + + +/*----------. +| yyparse. | +`----------*/ + +int +yyparse (void) +{ + yySymbol yytoken; + yyGLRStack yystack; + size_t yyposn; + + + YYSTYPE* const yylvalp = &yylval; + YYLTYPE* const yyllocp = &yylloc; + + yyinitGLRStack (&yystack, YYINITDEPTH); + yystack.yytokenp = &yytoken; + + YYDPRINTF ((stderr, "Starting parse\n")); + + if (setjmp (yystack.yyexception_buffer) != 0) + goto yyDone; + + yylval = yyval_default; + + + yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc); + yytoken = YYEMPTY; + yyposn = 0; + + while (yytrue) + { + /* For efficiency, we have two loops, the first of which is + specialized to deterministic operation (single stack, no + potential ambiguity). */ + /* Standard mode */ + while (yytrue) + { + yyRuleNum yyrule; + int yyaction; + const short int* yyconflicts; + + yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + if (yystate == YYFINAL) + goto yyDone; + if (yyisDefaultedState (yystate)) + { + yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { + + yyreportSyntaxError (&yystack, yylvalp, yyllocp); + goto yyuser_error; + } + YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue)); + } + else + { + if (yytoken == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, yylvalp, yyllocp); + } + yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); + if (*yyconflicts != 0) + break; + if (yyisShiftAction (yyaction)) + { + YY_SYMBOL_PRINT ("Shifting", yytoken, yylvalp, yyllocp); + if (yytoken != YYEOF) + yytoken = YYEMPTY; + yyposn += 1; + yyglrShift (&yystack, 0, yyaction, yyposn, + yylval, yyllocp); + if (0 < yystack.yyerrState) + yystack.yyerrState -= 1; + } + else if (yyisErrorAction (yyaction)) + { + + yyreportSyntaxError (&yystack, yylvalp, yyllocp); + goto yyuser_error; + } + else + YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue)); + } + } + + while (yytrue) + { + int yys; + int yyn = yystack.yytops.yysize; + for (yys = 0; yys < yyn; yys += 1) + YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn, + yylvalp, yyllocp)); + yytoken = YYEMPTY; + yyposn += 1; + yyremoveDeletes (&yystack); + if (yystack.yytops.yysize == 0) + { + yyundeleteLastStack (&yystack); + if (yystack.yytops.yysize == 0) + yyFail (&yystack, "syntax error"); + YYCHK1 (yyresolveStack (&yystack)); + YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); + + yyreportSyntaxError (&yystack, yylvalp, yyllocp); + goto yyuser_error; + } + else if (yystack.yytops.yysize == 1) + { + YYCHK1 (yyresolveStack (&yystack)); + YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); + yycompressStack (&yystack); + break; + } + } + continue; + yyuser_error: + yyrecoverSyntaxError (&yystack, yylvalp, yyllocp); + yyposn = yystack.yytops.yystates[0]->yyposn; + } + yyDone: + /* On YYABORT, free the lookahead. */ + if (yystack.yyerrflag == 1 && yytoken != YYEMPTY) + yydestruct ("Error: discarding lookahead", + yytoken, yylvalp); + + yyfreeGLRStack (&yystack); + return yystack.yyerrflag; +} + +/* DEBUGGING ONLY */ +#ifdef YYDEBUG +static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED; +static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED; + +static void +yy_yypstack (yyGLRState* yys) +{ + if (yys->yypred) + { + yy_yypstack (yys->yypred); + fprintf (stderr, " -> "); + } + fprintf (stderr, "%d@%lu", yys->yylrState, (unsigned long int) yys->yyposn); +} + +static void +yypstates (yyGLRState* yyst) +{ + if (yyst == NULL) + fprintf (stderr, "<null>"); + else + yy_yypstack (yyst); + fprintf (stderr, "\n"); +} + +static void +yypstack (yyGLRStack* yystack, int yyk) +{ + yypstates (yystack->yytops.yystates[yyk]); +} + +#define YYINDEX(YYX) \ + ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystack->yyitems) + + +static void +yypdumpstack (yyGLRStack* yystack) +{ + yyGLRStackItem* yyp; + size_t yyi; + for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1) + { + fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystack->yyitems)); + if (*(yybool *) yyp) + { + fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", + yyp->yystate.yyresolved, yyp->yystate.yylrState, + (unsigned long int) yyp->yystate.yyposn, + (long int) YYINDEX (yyp->yystate.yypred)); + if (! yyp->yystate.yyresolved) + fprintf (stderr, ", firstVal: %ld", + (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); + } + else + { + fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld", + yyp->yyoption.yyrule, + (long int) YYINDEX (yyp->yyoption.yystate), + (long int) YYINDEX (yyp->yyoption.yynext)); + } + fprintf (stderr, "\n"); + } + fprintf (stderr, "Tops:"); + for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1) + fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi, + (long int) YYINDEX (yystack->yytops.yystates[yyi])); + fprintf (stderr, "\n"); +} +#endif + + +#line 77 "idx.y" + + |