--- trunk/reactos/tools/wpp/wpp.tab.c 2005-10-08 00:41:31 UTC (rev 18319)
+++ trunk/reactos/tools/wpp/ppy.tab.c 2005-10-08 10:28:57 UTC (rev 18322)
@@ -0,0 +1,2328 @@
+/* A Bison parser, made by GNU Bison 1.875b. */
+
+/* Skeleton parser for Yacc-like parsing with Bison,
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 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. */
+
+/* As a special exception, when this file is copied by Bison into a
+ Bison output file, you may use that output file without restriction.
+ This special exception was added by the Free Software Foundation
+ in version 1.24 of Bison. */
+
+/* Written by Richard Stallman by simplifying the original so called
+ ``semantic'' parser. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+/* Identify Bison output. */
+#define YYBISON 1
+
+/* Skeleton name. */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers. */
+#define YYPURE 0
+
+/* Using locations. */
+#define YYLSP_NEEDED 0
+
+/* If NAME_PREFIX is specified substitute the variables and functions
+ names. */
+#define yyparse ppparse
+#define yylex pplex
+#define yyerror pperror
+#define yylval pplval
+#define yychar ppchar
+#define yydebug ppdebug
+#define yynerrs ppnerrs
+
+
+/* Tokens. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ /* Put the tokens into the symbol table, so that GDB and other debuggers
+ know about them. */
+ enum yytokentype {
+ tRCINCLUDE = 258,
+ tIF = 259,
+ tIFDEF = 260,
+ tIFNDEF = 261,
+ tELSE = 262,
+ tELIF = 263,
+ tENDIF = 264,
+ tDEFINED = 265,
+ tNL = 266,
+ tINCLUDE = 267,
+ tINCLUDE_NEXT = 268,
+ tLINE = 269,
+ tGCCLINE = 270,
+ tERROR = 271,
+ tWARNING = 272,
+ tPRAGMA = 273,
+ tPPIDENT = 274,
+ tUNDEF = 275,
+ tMACROEND = 276,
+ tCONCAT = 277,
+ tELIPSIS = 278,
+ tSTRINGIZE = 279,
+ tIDENT = 280,
+ tLITERAL = 281,
+ tMACRO = 282,
+ tDEFINE = 283,
+ tDQSTRING = 284,
+ tSQSTRING = 285,
+ tIQSTRING = 286,
+ tUINT = 287,
+ tSINT = 288,
+ tULONG = 289,
+ tSLONG = 290,
+ tULONGLONG = 291,
+ tSLONGLONG = 292,
+ tRCINCLUDEPATH = 293,
+ tLOGOR = 294,
+ tLOGAND = 295,
+ tNE = 296,
+ tEQ = 297,
+ tGTE = 298,
+ tLTE = 299,
+ tRSHIFT = 300,
+ tLSHIFT = 301
+ };
+#endif
+#define tRCINCLUDE 258
+#define tIF 259
+#define tIFDEF 260
+#define tIFNDEF 261
+#define tELSE 262
+#define tELIF 263
+#define tENDIF 264
+#define tDEFINED 265
+#define tNL 266
+#define tINCLUDE 267
+#define tINCLUDE_NEXT 268
+#define tLINE 269
+#define tGCCLINE 270
+#define tERROR 271
+#define tWARNING 272
+#define tPRAGMA 273
+#define tPPIDENT 274
+#define tUNDEF 275
+#define tMACROEND 276
+#define tCONCAT 277
+#define tELIPSIS 278
+#define tSTRINGIZE 279
+#define tIDENT 280
+#define tLITERAL 281
+#define tMACRO 282
+#define tDEFINE 283
+#define tDQSTRING 284
+#define tSQSTRING 285
+#define tIQSTRING 286
+#define tUINT 287
+#define tSINT 288
+#define tULONG 289
+#define tSLONG 290
+#define tULONGLONG 291
+#define tSLONGLONG 292
+#define tRCINCLUDEPATH 293
+#define tLOGOR 294
+#define tLOGAND 295
+#define tNE 296
+#define tEQ 297
+#define tGTE 298
+#define tLTE 299
+#define tRSHIFT 300
+#define tLSHIFT 301
+
+
+
+
+/* Copy the first part of user declarations. */
+#line 30 "wpp/ppy.y"
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "wpp_private.h"
+
+
+#define UNARY_OP(r, v, OP) \
+ switch(v.type) \
+ { \
+ case cv_sint: r.val.si = OP v.val.si; break; \
+ case cv_uint: r.val.ui = OP v.val.ui; break; \
+ case cv_slong: r.val.sl = OP v.val.sl; break; \
+ case cv_ulong: r.val.ul = OP v.val.ul; break; \
+ case cv_sll: r.val.sll = OP v.val.sll; break; \
+ case cv_ull: r.val.ull = OP v.val.ull; break; \
+ }
+
+#define cv_signed(v) ((v.type & FLAG_SIGNED) != 0)
+
+#define BIN_OP_INT(r, v1, v2, OP) \
+ r.type = v1.type; \
+ if(cv_signed(v1) && cv_signed(v2)) \
+ r.val.si = v1.val.si OP v2.val.si; \
+ else if(cv_signed(v1) && !cv_signed(v2)) \
+ r.val.si = v1.val.si OP v2.val.ui; \
+ else if(!cv_signed(v1) && cv_signed(v2)) \
+ r.val.ui = v1.val.ui OP v2.val.si; \
+ else \
+ r.val.ui = v1.val.ui OP v2.val.ui;
+
+#define BIN_OP_LONG(r, v1, v2, OP) \
+ r.type = v1.type; \
+ if(cv_signed(v1) && cv_signed(v2)) \
+ r.val.sl = v1.val.sl OP v2.val.sl; \
+ else if(cv_signed(v1) && !cv_signed(v2)) \
+ r.val.sl = v1.val.sl OP v2.val.ul; \
+ else if(!cv_signed(v1) && cv_signed(v2)) \
+ r.val.ul = v1.val.ul OP v2.val.sl; \
+ else \
+ r.val.ul = v1.val.ul OP v2.val.ul;
+
+#define BIN_OP_LONGLONG(r, v1, v2, OP) \
+ r.type = v1.type; \
+ if(cv_signed(v1) && cv_signed(v2)) \
+ r.val.sll = v1.val.sll OP v2.val.sll; \
+ else if(cv_signed(v1) && !cv_signed(v2)) \
+ r.val.sll = v1.val.sll OP v2.val.ull; \
+ else if(!cv_signed(v1) && cv_signed(v2)) \
+ r.val.ull = v1.val.ull OP v2.val.sll; \
+ else \
+ r.val.ull = v1.val.ull OP v2.val.ull;
+
+#define BIN_OP(r, v1, v2, OP) \
+ switch(v1.type & SIZE_MASK) \
+ { \
+ case SIZE_INT: BIN_OP_INT(r, v1, v2, OP); break; \
+ case SIZE_LONG: BIN_OP_LONG(r, v1, v2, OP); break; \
+ case SIZE_LONGLONG: BIN_OP_LONGLONG(r, v1, v2, OP); break; \
+ default: pp_internal_error(__FILE__, __LINE__, "Invalid type indicator (0x%04x)", v1.type); \
+ }
+
+
+/*
+ * Prototypes
+ */
+static int boolean(cval_t *v);
+static void promote_equal_size(cval_t *v1, cval_t *v2);
+static void cast_to_sint(cval_t *v);
+static void cast_to_uint(cval_t *v);
+static void cast_to_slong(cval_t *v);
+static void cast_to_ulong(cval_t *v);
+static void cast_to_sll(cval_t *v);
+static void cast_to_ull(cval_t *v);
+static marg_t *new_marg(char *str, def_arg_t type);
+static marg_t *add_new_marg(char *str, def_arg_t type);
+static int marg_index(char *id);
+static mtext_t *new_mtext(char *str, int idx, def_exp_t type);
+static mtext_t *combine_mtext(mtext_t *tail, mtext_t *mtp);
+static char *merge_text(char *s1, char *s2);
+
+/*
+ * Local variables
+ */
+static marg_t **macro_args; /* Macro parameters array while parsing */
+static int nmacro_args;
+
+
+
+/* Enabling traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 1
+#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 126 "wpp/ppy.y"
+typedef union YYSTYPE {
+ int sint;
+ unsigned int uint;
+ long slong;
+ unsigned long ulong;
+ wrc_sll_t sll;
+ wrc_ull_t ull;
+ int *iptr;
+ char *cptr;
+ cval_t cval;
+ marg_t *marg;
+ mtext_t *mtext;
+} YYSTYPE;
+/* Line 191 of yacc.c. */
+#line 287 "wpp/ppy.tab.c"
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+/* Copy the second part of user declarations. */
+
+
+/* Line 214 of yacc.c. */
+#line 299 "wpp/ppy.tab.c"
+
+#if ! defined (yyoverflow) || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# if YYSTACK_USE_ALLOCA
+# define YYSTACK_ALLOC alloca
+# else
+# ifndef YYSTACK_USE_ALLOCA
+# if defined (alloca) || defined (_ALLOCA_H)
+# define YYSTACK_ALLOC alloca
+# else
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's `empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# else
+# if defined (__STDC__) || defined (__cplusplus)
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# endif
+# define YYSTACK_ALLOC malloc
+# define YYSTACK_FREE free
+# endif
+#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+
+
+#if (! defined (yyoverflow) \
+ && (! defined (__cplusplus) \
+ || (YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ short yyss;
+ YYSTYPE yyvs;
+ };
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
+ + YYSTACK_GAP_MAXIMUM)
+
+/* Copy COUNT objects from FROM to TO. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if 1 < __GNUC__
+# define YYCOPY(To, From, Count) \
+ __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+# else
+# define YYCOPY(To, From, Count) \
+ do \
+ { \
+ register YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (To)[yyi] = (From)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+
+/* Relocate STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ YYCOPY (&yyptr->Stack, Stack, yysize); \
+ Stack = &yyptr->Stack; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
+
+#endif
+
+#if defined (__STDC__) || defined (__cplusplus)
+ typedef signed char yysigned_char;
+#else
+ typedef short yysigned_char;
+#endif
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 2
+/* YYLAST -- Last index in YYTABLE. */
+#define YYLAST 308
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 63
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS 13
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 86
+/* YYNRULES -- Number of states. */
+#define YYNSTATES 158
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
+#define YYUNDEFTOK 2
+#define YYMAXUTOK 301
+
+#define YYTRANSLATE(YYX) \
+ ((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, 59, 2, 2, 2, 2, 45, 2,
+ 61, 62, 56, 54, 60, 55, 2, 57, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 40, 2,
+ 48, 2, 49, 39, 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, 44, 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, 43, 2, 58, 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, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+ 35, 36, 37, 38, 41, 42, 46, 47, 50, 51,
+ 52, 53
+};
+
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+ YYRHS. */
+static const unsigned short yyprhs[] =
+{
+ 0, 0, 3, 4, 7, 11, 15, 19, 23, 27,
+ 31, 35, 39, 42, 45, 49, 53, 60, 65, 70,
+ 76, 83, 91, 100, 103, 107, 111, 115, 119, 122,
+ 125, 126, 128, 130, 132, 134, 137, 140, 143, 144,
+ 145, 147, 149, 153, 157, 159, 160, 162, 164, 167,
+ 169, 171, 173, 175, 178, 180, 182, 184, 186, 188,
+ 190, 192, 195, 200, 202, 206, 210, 214, 218, 222,
+ 226, 230, 234, 238, 242, 246, 250, 254, 258, 262,
+ 266, 270, 273, 276, 279, 282, 286
+};
+
+/* YYRHS -- A `-1'-separated list of the rules' RHS. */
+static const yysigned_char yyrhs[] =
+{
+ 64, 0, -1, -1, 64, 65, -1, 12, 29, 11,
+ -1, 12, 31, 11, -1, 13, 29, 11, -1, 13,
+ 31, 11, -1, 4, 75, 11, -1, 5, 25, 11,
+ -1, 6, 25, 11, -1, 8, 75, 11, -1, 7,
+ 11, -1, 9, 11, -1, 20, 25, 11, -1, 28,
+ 66, 11, -1, 27, 68, 69, 21, 72, 11, -1,
+ 14, 33, 29, 11, -1, 15, 33, 29, 11, -1,
+ 15, 33, 29, 33, 11, -1, 15, 33, 29, 33,
+ 33, 11, -1, 15, 33, 29, 33, 33, 33, 11,
+ -1, 15, 33, 29, 33, 33, 33, 33, 11, -1,
+ 15, 11, -1, 16, 66, 11, -1, 17, 66, 11,
+ -1, 18, 66, 11, -1, 19, 66, 11, -1, 3,
+ 38, -1, 3, 29, -1, -1, 67, -1, 26, -1,
+ 29, -1, 30, -1, 67, 26, -1, 67, 29, -1,
+ 67, 30, -1, -1, -1, 70, -1, 71, -1, 71,
+ 60, 23, -1, 71, 60, 25, -1, 25, -1, -1,
+ 73, -1, 74, -1, 73, 74, -1, 26, -1, 29,
+ -1, 30, -1, 22, -1, 24, 25, -1, 25, -1,
+ 33, -1, 32, -1, 35, -1, 34, -1, 37, -1,
+ 36, -1, 10, 25, -1, 10, 61, 25, 62, -1,
+ 25, -1, 75, 41, 75, -1, 75, 42, 75, -1,
+ 75, 47, 75, -1, 75, 46, 75, -1, 75, 48,
+ 75, -1, 75, 49, 75, -1, 75, 51, 75, -1,
+ 75, 50, 75, -1, 75, 54, 75, -1, 75, 55,
+ 75, -1, 75, 44, 75, -1, 75, 45, 75, -1,
+ 75, 43, 75, -1, 75, 56, 75, -1, 75, 57,
+ 75, -1, 75, 53, 75, -1, 75, 52, 75, -1,
+ 54, 75, -1, 55, 75, -1, 58, 75, -1, 59,
+ 75, -1, 61, 75, 62, -1, 75, 39, 75, 40,
+ 75, -1
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+static const unsigned short yyrline[] =
+{
+ 0, 181, 181, 182, 186, 187, 188, 189, 190, 191,
+ 192, 212, 233, 256, 271, 272, 273, 276, 277, 278,
+ 280, 282, 284, 286, 287, 288, 289, 290, 291, 298,
+ 304, 305, 308, 309, 310, 311, 312, 313, 316, 319,
+ 320, 323, 324, 327, 328, 332, 333, 339, 340, 343,
+ 344, 345, 346, 347, 353, 362, 363, 364, 365, 366,
+ 367, 368, 369, 370, 371, 372, 373, 374, 375, 376,
+ 377, 378, 379, 380, 381, 382, 383, 384, 385, 386,
+ 387, 388, 389, 390, 391, 392, 393
+};
+#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", "tRCINCLUDE", "tIF", "tIFDEF", "tIFNDEF",
+ "tELSE", "tELIF", "tENDIF", "tDEFINED", "tNL", "tINCLUDE",
+ "tINCLUDE_NEXT", "tLINE", "tGCCLINE", "tERROR", "tWARNING", "tPRAGMA",
+ "tPPIDENT", "tUNDEF", "tMACROEND", "tCONCAT", "tELIPSIS", "tSTRINGIZE",
+ "tIDENT", "tLITERAL", "tMACRO", "tDEFINE", "tDQSTRING", "tSQSTRING",
+ "tIQSTRING", "tUINT", "tSINT", "tULONG", "tSLONG", "tULONGLONG",
+ "tSLONGLONG", "tRCINCLUDEPATH", "'?'", "':'", "tLOGOR", "tLOGAND",
+ "'|'", "'^'", "'&'", "tNE", "tEQ", "'<'", "'>'", "tGTE", "tLTE",
+ "tRSHIFT", "tLSHIFT", "'+'", "'-'", "'*'", "'/'", "'~'", "'!'", "','",
+ "'('", "')'", "$accept", "pp_file", "preprocessor", "opt_text", "text",
+ "res_arg", "allmargs", "emargs", "margs", "opt_mtexts", "mtexts",
+ "mtext", "pp_expr", 0
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+ token YYLEX-NUM. */
+static const unsigned short yytoknum[] =
+{
+ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+ 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
+ 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
+ 285, 286, 287, 288, 289, 290, 291, 292, 293, 63,
+ 58, 294, 295, 124, 94, 38, 296, 297, 60, 62,
+ 298, 299, 300, 301, 43, 45, 42, 47, 126, 33,
+ 44, 40, 41
+};
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const unsigned char yyr1[] =
+{
+ 0, 63, 64, 64, 65, 65, 65, 65, 65, 65,
+ 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+ 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+ 66, 66, 67, 67, 67, 67, 67, 67, 68, 69,
+ 69, 70, 70, 71, 71, 72, 72, 73, 73, 74,
+ 74, 74, 74, 74, 74, 75, 75, 75, 75, 75,
+ 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
+ 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
+ 75, 75, 75, 75, 75, 75, 75
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
+static const unsigned char yyr2[] =
+{
+ 0, 2, 0, 2, 3, 3, 3, 3, 3, 3,
+ 3, 3, 2, 2, 3, 3, 6, 4, 4, 5,
+ 6, 7, 8, 2, 3, 3, 3, 3, 2, 2,
+ 0, 1, 1, 1, 1, 2, 2, 2, 0, 0,
+ 1, 1, 3, 3, 1, 0, 1, 1, 2, 1,
+ 1, 1, 1, 2, 1, 1, 1, 1, 1, 1,
+ 1, 2, 4, 1, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 2, 2, 2, 2, 3, 5
+};
+
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+ STATE-NUM when YYTABLE doesn't specify something else to do. Zero
+ means the default is an error. */
+static const unsigned char yydefact[] =
+{
+ 2, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 30, 30, 30, 30, 0, 38,
+ 30, 3, 29, 28, 0, 63, 56, 55, 58, 57,
+ 60, 59, 0, 0, 0, 0, 0, 0, 0, 0,
+ 12, 0, 13, 0, 0, 0, 0, 0, 23, 0,
+ 32, 33, 34, 0, 31, 0, 0, 0, 0, 39,
+ 0, 61, 0, 81, 82, 83, 84, 0, 8, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 9, 10, 11,
+ 4, 5, 6, 7, 0, 0, 24, 35, 36, 37,
+ 25, 26, 27, 14, 44, 0, 40, 41, 15, 0,
+ 85, 0, 64, 65, 76, 74, 75, 67, 66, 68,
+ 69, 71, 70, 80, 79, 72, 73, 77, 78, 17,
+ 18, 0, 45, 0, 62, 0, 19, 0, 52, 0,
+ 54, 49, 50, 51, 0, 46, 47, 42, 43, 86,
+ 20, 0, 53, 16, 48, 21, 0, 22
+};
+
+/* YYDEFGOTO[NTERM-NUM]. */
+static const short yydefgoto[] =
+{
+ -1, 1, 21, 53, 54, 59, 105, 106, 107, 144,
+ 145, 146, 37
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+#define YYPACT_NINF -28
+static const short yypact[] =
+{
+ -28, 126, -28, -27, -3, -13, -5, 4, -3, 12,
+ -10, 28, 21, 2, -20, -20, -20, -20, 35, -28,
+ -20, -28, -28, -28, -24, -28, -28, -28, -28, -28,
+ -28, -28, -3, -3, -3, -3, -3, 42, 95, 97,
+ -28, 68, -28, 117, 137, 138, 141, 127, -28, 170,
+ -28, -28, -28, 277, 121, 281, 282, 285, 286, 273,
+ 288, -28, 275, 80, 80, -28, -28, 116, -28, -3,
+ -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
+ -3, -3, -3, -3, -3, -3, -3, -28, -28, -28,
+ -28, -28, -28, -28, 290, 3, -28, -28, -28, -28,
+ -28, -28, -28, -28, -28, 283, -28, 242, -28, 241,
+ -28, 140, 175, 190, 204, 217, 229, -7, -7, 48,
+ 48, 48, 48, 120, 120, 80, 80, -28, -28, -28,
+ -28, 5, 265, 57, -28, -3, -28, 6, -28, 280,
+ -28, -28, -28, -28, 295, 265, -28, -28, -28, 159,
+ -28, 7, -28, -28, -28, -28, 296, -28
+};
+
+/* YYPGOTO[NTERM-NUM]. */
+static const short yypgoto[] =
+{
+ -28, -28, -28, -12, -28, -28, -28, -28, -28, -28,
+ -28, 163, -8
+};
+
+/* 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 -1
+static const unsigned char yytable[] =
+{
+ 41, 61, 22, 55, 56, 57, 50, 24, 60, 51,
+ 52, 23, 38, 48, 130, 40, 136, 150, 155, 43,
+ 39, 44, 25, 42, 63, 64, 65, 66, 67, 26,
+ 27, 28, 29, 30, 31, 49, 131, 62, 137, 151,
+ 156, 77, 78, 79, 80, 81, 82, 83, 84, 85,
+ 86, 32, 33, 68, 47, 34, 35, 45, 36, 46,
+ 58, 111, 112, 113, 114, 115, 116, 117, 118, 119,
+ 120, 121, 122, 123, 124, 125, 126, 127, 128, 89,
+ 147, 69, 148, 70, 71, 72, 73, 74, 75, 76,
+ 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+ 81, 82, 83, 84, 85, 86, 87, 69, 88, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+ 81, 82, 83, 84, 85, 86, 2, 149, 90, 3,
+ 4, 5, 6, 7, 8, 9, 85, 86, 10, 11,
+ 12, 13, 14, 15, 16, 17, 18, 97, 91, 92,
+ 98, 99, 93, 19, 20, 69, 94, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+ 83, 84, 85, 86, 83, 84, 85, 86, 110, 69,
+ 135, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 69, 95,
+ 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 71, 72, 73,
+ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+ 84, 85, 86, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 73, 74,
+ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+ 85, 86, 74, 75, 76, 77, 78, 79, 80, 81,
+ 82, 83, 84, 85, 86, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 138, 96, 139,
+ 140, 141, 100, 101, 142, 143, 102, 103, 104, 108,
+ 109, 129, 133, 134, 132, 152, 153, 157, 154
+};
+
+static const unsigned char yycheck[] =
+{
+ 8, 25, 29, 15, 16, 17, 26, 10, 20, 29,
+ 30, 38, 25, 11, 11, 11, 11, 11, 11, 29,
+ 25, 31, 25, 11, 32, 33, 34, 35, 36, 32,
+ 33, 34, 35, 36, 37, 33, 33, 61, 33, 33,
+ 33, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+ 57, 54, 55, 11, 33, 58, 59, 29, 61, 31,
+ 25, 69, 70, 71, 72, 73, 74, 75, 76, 77,
+ 78, 79, 80, 81, 82, 83, 84, 85, 86, 11,
+ 23, 39, 25, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+ 52, 53, 54, 55, 56, 57, 11, 39, 11, 41,
+ 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+ 52, 53, 54, 55, 56, 57, 0, 135, 11, 3,
+ 4, 5, 6, 7, 8, 9, 56, 57, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 26, 11, 11,
+ 29, 30, 11, 27, 28, 39, 29, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+ 54, 55, 56, 57, 54, 55, 56, 57, 62, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+ 50, 51, 52, 53, 54, 55, 56, 57, 39, 29,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, 57, 42, 43, 44,
+ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, 57, 43, 44, 45, 46, 47, 48, 49,
+ 50, 51, 52, 53, 54, 55, 56, 57, 44, 45,
+ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 45, 46, 47, 48, 49, 50, 51, 52,
+ 53, 54, 55, 56, 57, 46, 47, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, 57, 22, 11, 24,
+ 25, 26, 11, 11, 29, 30, 11, 11, 25, 11,
+ 25, 11, 60, 62, 21, 25, 11, 11, 145
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const unsigned char yystos[] =
+{
+ 0, 64, 0, 3, 4, 5, 6, 7, 8, 9,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 27,
+ 28, 65, 29, 38, 10, 25, 32, 33, 34, 35,
+ 36, 37, 54, 55, 58, 59, 61, 75, 25, 25,
+ 11, 75, 11, 29, 31, 29, 31, 33, 11, 33,
+ 26, 29, 30, 66, 67, 66, 66, 66, 25, 68,
+ 66, 25, 61, 75, 75, 75, 75, 75, 11, 39,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, 57, 11, 11, 11,
+ 11, 11, 11, 11, 29, 29, 11, 26, 29, 30,
+ 11, 11, 11, 11, 25, 69, 70, 71, 11, 25,
+ 62, 75, 75, 75, 75, 75, 75, 75, 75, 75,
+ 75, 75, 75, 75, 75, 75, 75, 75, 75, 11,
+ 11, 33, 21, 60, 62, 40, 11, 33, 22, 24,
+ 25, 26, 29, 30, 72, 73, 74, 23, 25, 75,
+ 11, 33, 25, 11, 74, 11, 33, 11
+};
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# if defined (__STDC__) || defined (__cplusplus)
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# endif
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY (-2)
+#define YYEOF 0
+
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrlab1
+
+
+/* Like YYERROR except do call yyerror. This remains here temporarily
+ to ease the transition to the new meaning of YYERROR, for GCC.
+ Once GCC version 2 has supplanted version 1, this can go. */
+
+#define YYFAIL goto yyerrlab
+
+#define YYRECOVERING() (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value) \
+do \
+ if (yychar == YYEMPTY && yylen == 1) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ yytoken = YYTRANSLATE (yychar); \
+ YYPOPSTACK; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror ("syntax error: cannot back up");\
+ YYERROR; \
+ } \
+while (0)
+
+#define YYTERROR 1
+#define YYERRCODE 256
+
+/* YYLLOC_DEFAULT -- Compute the default location (before the actions
+ are run). */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N) \
+ Current.first_line = Rhs[1].first_line; \
+ Current.first_column = Rhs[1].first_column; \
+ Current.last_line = Rhs[N].last_line; \
+ Current.last_column = Rhs[N].last_column;
+#endif
+
+/* YYLEX -- calling `yylex' with the right arguments. */
+
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (YYLEX_PARAM)
+#else
+# define YYLEX yylex ()
+#endif
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+
+# define YYDSYMPRINT(Args) \
+do { \
+ if (yydebug) \
+ yysymprint Args; \
+} while (0)
+
+# define YYDSYMPRINTF(Title, Token, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yysymprint (stderr, \
+ Token, Value); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (cinluded). |
+`------------------------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_stack_print (short *bottom, short *top)
+#else
+static void
+yy_stack_print (bottom, top)
+ short *bottom;
+ short *top;
+#endif
+{
+ YYFPRINTF (stderr, "Stack now");
+ for (/* Nothing. */; bottom <= top; ++bottom)
+ YYFPRINTF (stderr, " %d", *bottom);
+ YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top) \
+do { \
+ if (yydebug) \
+ yy_stack_print ((Bottom), (Top)); \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced. |
+`------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_reduce_print (int yyrule)
+#else
+static void
+yy_reduce_print (yyrule)
+ int yyrule;
+#endif
+{
+ int yyi;
+ unsigned int yylno = yyrline[yyrule];
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
+ yyrule - 1, yylno);
+ /* Print the symbols being reduced, and their result. */
+ for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
+ YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
+ YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
+}
+
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (Rule); \
+} 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 YYDSYMPRINT(Args)
+# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#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 < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
+#if YYMAXDEPTH == 0
+# undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
[truncated at 1000 lines; 4068 more skipped]