1 /* A Bison parser, made by GNU Bison 2.3.  */

     2 

     3 /* Skeleton implementation for Bison's Yacc-like parsers in C

     4 

     5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006

     6    Free Software Foundation, Inc.

     7 

     8    This program is free software; you can redistribute it and/or modify

     9    it under the terms of the GNU General Public License as published by

    10    the Free Software Foundation; either version 2, or (at your option)

    11    any later version.

    12 

    13    This program is distributed in the hope that it will be useful,

    14    but WITHOUT ANY WARRANTY; without even the implied warranty of

    15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16    GNU General Public License for more details.

    17 

    18    You should have received a copy of the GNU General Public License

    19    along with this program; if not, write to the Free Software

    20    Foundation, Inc., 51 Franklin Street, Fifth Floor,

    21    Boston, MA 02110-1301, USA.  */

    22 

    23 /* As a special exception, you may create a larger work that contains

    24    part or all of the Bison parser skeleton and distribute that work

    25    under terms of your choice, so long as that work isn't itself a

    26    parser generator using the skeleton or a modified version thereof

    27    as a parser skeleton.  Alternatively, if you modify or redistribute

    28    the parser skeleton itself, you may (at your option) remove this

    29    special exception, which will cause the skeleton and the resulting

    30    Bison output files to be licensed under the GNU General Public

    31    License without this special exception.

    32 

    33    This special exception was added by the Free Software Foundation in

    34    version 2.2 of Bison.  */

    35 

    36 /* C LALR(1) parser skeleton written by Richard Stallman, by

    37    simplifying the original so-called "semantic" parser.  */

    38 

    39 /* All symbols defined below should begin with yy or YY, to avoid

    40    infringing on user name space.  This should be done even for local

    41    variables, as they might otherwise be expanded by user macros.

    42    There are some unavoidable exceptions within include files to

    43    define necessary library symbols; they are noted "INFRINGES ON

    44    USER NAME SPACE" below.  */

    45 

    46 /* Identify Bison output.  */

    47 #define YYBISON 1

    48 

    49 /* Bison version.  */

    50 #define YYBISON_VERSION "2.3"

    51 

    52 /* Skeleton name.  */

    53 #define YYSKELETON_NAME "yacc.c"

    54 

    55 /* Pure parsers.  */

    56 #define YYPURE 1

    57 

    58 /* Using locations.  */

    59 #define YYLSP_NEEDED 0

    60 

    61 /* Substitute the variable and function names.  */

    62 #define yyparse xpathyyparse

    63 #define yylex   xpathyylex

    64 #define yyerror xpathyyerror

    65 #define yylval  xpathyylval

    66 #define yychar  xpathyychar

    67 #define yydebug xpathyydebug

    68 #define yynerrs xpathyynerrs

    69 

    70 

    71 /* Tokens.  */

    72 #ifndef YYTOKENTYPE

    73 # define YYTOKENTYPE

    74    /* Put the tokens into the symbol table, so that GDB and other debuggers

    75       know about them.  */

    76    enum yytokentype {

    77      MULOP = 258,

    78      RELOP = 259,

    79      EQOP = 260,

    80      MINUS = 261,

    81      PLUS = 262,

    82      AND = 263,

    83      OR = 264,

    84      AXISNAME = 265,

    85      NODETYPE = 266,

    86      PI = 267,

    87      FUNCTIONNAME = 268,

    88      LITERAL = 269,

    89      VARIABLEREFERENCE = 270,

    90      NUMBER = 271,

    91      DOTDOT = 272,

    92      SLASHSLASH = 273,

    93      NAMETEST = 274,

    94      ERROR = 275

    95    };

    96 #endif

    97 /* Tokens.  */

    98 #define MULOP 258

    99 #define RELOP 259

   100 #define EQOP 260

   101 #define MINUS 261

   102 #define PLUS 262

   103 #define AND 263

   104 #define OR 264

   105 #define AXISNAME 265

   106 #define NODETYPE 266

   107 #define PI 267

   108 #define FUNCTIONNAME 268

   109 #define LITERAL 269

   110 #define VARIABLEREFERENCE 270

   111 #define NUMBER 271

   112 #define DOTDOT 272

   113 #define SLASHSLASH 273

   114 #define NAMETEST 274

   115 #define ERROR 275

   116 

   117 

   118 

   119 

   120 /* Copy the first part of user declarations.  */

   121 #line 28 "/cygdrive/x/tot/WebCore/xml/XPathGrammar.y"

   122 

   123 

   124 #include "config.h"

   125 

   126 #if ENABLE(XPATH)

   127 

   128 #include "XPathFunctions.h"

   129 #include "XPathNSResolver.h"

   130 #include "XPathParser.h"

   131 #include "XPathPath.h"

   132 #include "XPathPredicate.h"

   133 #include "XPathVariableReference.h"

   134 

   135 #define YYENABLE_NLS 0

   136 #define YYLTYPE_IS_TRIVIAL 1

   137 #define YYDEBUG 0

   138 #define YYMAXDEPTH 10000

   139 #define YYPARSE_PARAM parserParameter

   140 #define PARSER static_cast<Parser*>(parserParameter)

   141 

   142 using namespace WebCore;

   143 using namespace XPath;

   144 

   145 

   146 

   147 /* Enabling traces.  */

   148 #ifndef YYDEBUG

   149 # define YYDEBUG 0

   150 #endif

   151 

   152 /* Enabling verbose error messages.  */

   153 #ifdef YYERROR_VERBOSE

   154 # undef YYERROR_VERBOSE

   155 # define YYERROR_VERBOSE 1

   156 #else

   157 # define YYERROR_VERBOSE 0

   158 #endif

   159 

   160 /* Enabling the token table.  */

   161 #ifndef YYTOKEN_TABLE

   162 # define YYTOKEN_TABLE 0

   163 #endif

   164 

   165 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED

   166 typedef union YYSTYPE

   167 #line 56 "/cygdrive/x/tot/WebCore/xml/XPathGrammar.y"

   168 {

   169     Step::Axis axis;

   170     Step::NodeTest* nodeTest;

   171     NumericOp::Opcode numop;

   172     EqTestOp::Opcode eqop;

   173     String* str;

   174     Expression* expr;

   175     Vector<Predicate*>* predList;

   176     Vector<Expression*>* argList;

   177     Step* step;

   178     LocationPath* locationPath;

   179 }

   180 /* Line 187 of yacc.c.  */

   181 #line 182 "XPathGrammar.cpp"

   182 	YYSTYPE;

   183 # define yystype YYSTYPE /* obsolescent; will be withdrawn */

   184 # define YYSTYPE_IS_DECLARED 1

   185 # define YYSTYPE_IS_TRIVIAL 1

   186 #endif

   187 

   188 

   189 

   190 /* Copy the second part of user declarations.  */

   191 #line 69 "/cygdrive/x/tot/WebCore/xml/XPathGrammar.y"

   192 

   193 

   194 int xpathyylex(YYSTYPE *yylval) { return Parser::current()->lex(yylval); }

   195 void xpathyyerror(const char *str) { }

   196     

   197 

   198 

   199 /* Line 216 of yacc.c.  */

   200 #line 201 "XPathGrammar.cpp"

   201 

   202 #ifdef short

   203 # undef short

   204 #endif

   205 

   206 #ifdef YYTYPE_UINT8

   207 typedef YYTYPE_UINT8 yytype_uint8;

   208 #else

   209 typedef unsigned char yytype_uint8;

   210 #endif

   211 

   212 #ifdef YYTYPE_INT8

   213 typedef YYTYPE_INT8 yytype_int8;

   214 #elif (defined __STDC__ || defined __C99__FUNC__ \

   215      || defined __cplusplus || defined _MSC_VER)

   216 typedef signed char yytype_int8;

   217 #else

   218 typedef short int yytype_int8;

   219 #endif

   220 

   221 #ifdef YYTYPE_UINT16

   222 typedef YYTYPE_UINT16 yytype_uint16;

   223 #else

   224 typedef unsigned short int yytype_uint16;

   225 #endif

   226 

   227 #ifdef YYTYPE_INT16

   228 typedef YYTYPE_INT16 yytype_int16;

   229 #else

   230 typedef short int yytype_int16;

   231 #endif

   232 

   233 #ifndef YYSIZE_T

   234 # ifdef __SIZE_TYPE__

   235 #  define YYSIZE_T __SIZE_TYPE__

   236 # elif defined size_t

   237 #  define YYSIZE_T size_t

   238 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \

   239      || defined __cplusplus || defined _MSC_VER)

   240 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */

   241 #  define YYSIZE_T size_t

   242 # else

   243 #  define YYSIZE_T unsigned int

   244 # endif

   245 #endif

   246 

   247 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)

   248 

   249 #ifndef YY_

   250 # if YYENABLE_NLS

   251 #  if ENABLE_NLS

   252 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */

   253 #   define YY_(msgid) dgettext ("bison-runtime", msgid)

   254 #  endif

   255 # endif

   256 # ifndef YY_

   257 #  define YY_(msgid) msgid

   258 # endif

   259 #endif

   260 

   261 /* Suppress unused-variable warnings by "using" E.  */

   262 #if ! defined lint || defined __GNUC__

   263 # define YYUSE(e) ((void) (e))

   264 #else

   265 # define YYUSE(e) /* empty */

   266 #endif

   267 

   268 /* Identity function, used to suppress warnings about constant conditions.  */

   269 #ifndef lint

   270 # define YYID(n) (n)

   271 #else

   272 #if (defined __STDC__ || defined __C99__FUNC__ \

   273      || defined __cplusplus || defined _MSC_VER)

   274 static int

   275 YYID (int i)

   276 #else

   277 static int

   278 YYID (i)

   279     int i;

   280 #endif

   281 {

   282   return i;

   283 }

   284 #endif

   285 

   286 #if ! defined yyoverflow || YYERROR_VERBOSE

   287 

   288 /* The parser invokes alloca or malloc; define the necessary symbols.  */

   289 

   290 # ifdef YYSTACK_USE_ALLOCA

   291 #  if YYSTACK_USE_ALLOCA

   292 #   ifdef __GNUC__

   293 #    define YYSTACK_ALLOC __builtin_alloca

   294 #   elif defined __BUILTIN_VA_ARG_INCR

   295 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */

   296 #   elif defined _AIX

   297 #    define YYSTACK_ALLOC __alloca

   298 #   elif defined _MSC_VER

   299 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */

   300 #    define alloca _alloca

   301 #   else

   302 #    define YYSTACK_ALLOC alloca

   303 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

   304      || defined __cplusplus || defined _MSC_VER)

   305 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

   306 #     ifndef _STDLIB_H

   307 #      define _STDLIB_H 1

   308 #     endif

   309 #    endif

   310 #   endif

   311 #  endif

   312 # endif

   313 

   314 # ifdef YYSTACK_ALLOC

   315    /* Pacify GCC's `empty if-body' warning.  */

   316 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))

   317 #  ifndef YYSTACK_ALLOC_MAXIMUM

   318     /* The OS might guarantee only one guard page at the bottom of the stack,

   319        and a page size can be as small as 4096 bytes.  So we cannot safely

   320        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number

   321        to allow for a few compiler-allocated temporary stack slots.  */

   322 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */

   323 #  endif

   324 # else

   325 #  define YYSTACK_ALLOC YYMALLOC

   326 #  define YYSTACK_FREE YYFREE

   327 #  ifndef YYSTACK_ALLOC_MAXIMUM

   328 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM

   329 #  endif

   330 #  if (defined __cplusplus && ! defined _STDLIB_H \

   331        && ! ((defined YYMALLOC || defined malloc) \

   332 	     && (defined YYFREE || defined free)))

   333 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

   334 #   ifndef _STDLIB_H

   335 #    define _STDLIB_H 1

   336 #   endif

   337 #  endif

   338 #  ifndef YYMALLOC

   339 #   define YYMALLOC malloc

   340 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

   341      || defined __cplusplus || defined _MSC_VER)

   342 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */

   343 #   endif

   344 #  endif

   345 #  ifndef YYFREE

   346 #   define YYFREE free

   347 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

   348      || defined __cplusplus || defined _MSC_VER)

   349 void free (void *); /* INFRINGES ON USER NAME SPACE */

   350 #   endif

   351 #  endif

   352 # endif

   353 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */

   354 

   355 

   356 #if (! defined yyoverflow \

   357      && (! defined __cplusplus \

   358 	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

   359 

   360 /* A type that is properly aligned for any stack member.  */

   361 union yyalloc

   362 {

   363   yytype_int16 yyss;

   364   YYSTYPE yyvs;

   365   };

   366 

   367 /* The size of the maximum gap between one aligned stack and the next.  */

   368 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

   369 

   370 /* The size of an array large to enough to hold all stacks, each with

   371    N elements.  */

   372 # define YYSTACK_BYTES(N) \

   373      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \

   374       + YYSTACK_GAP_MAXIMUM)

   375 

   376 /* Copy COUNT objects from FROM to TO.  The source and destination do

   377    not overlap.  */

   378 # ifndef YYCOPY

   379 #  if defined __GNUC__ && 1 < __GNUC__

   380 #   define YYCOPY(To, From, Count) \

   381       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))

   382 #  else

   383 #   define YYCOPY(To, From, Count)		\

   384       do					\

   385 	{					\

   386 	  YYSIZE_T yyi;				\

   387 	  for (yyi = 0; yyi < (Count); yyi++)	\

   388 	    (To)[yyi] = (From)[yyi];		\

   389 	}					\

   390       while (YYID (0))

   391 #  endif

   392 # endif

   393 

   394 /* Relocate STACK from its old location to the new one.  The

   395    local variables YYSIZE and YYSTACKSIZE give the old and new number of

   396    elements in the stack, and YYPTR gives the new location of the

   397    stack.  Advance YYPTR to a properly aligned location for the next

   398    stack.  */

   399 # define YYSTACK_RELOCATE(Stack)					\

   400     do									\

   401       {									\

   402 	YYSIZE_T yynewbytes;						\

   403 	YYCOPY (&yyptr->Stack, Stack, yysize);				\

   404 	Stack = &yyptr->Stack;						\

   405 	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \

   406 	yyptr += yynewbytes / sizeof (*yyptr);				\

   407       }									\

   408     while (YYID (0))

   409 

   410 #endif

   411 

   412 /* YYFINAL -- State number of the termination state.  */

   413 #define YYFINAL  47

   414 /* YYLAST -- Last index in YYTABLE.  */

   415 #define YYLAST   120

   416 

   417 /* YYNTOKENS -- Number of terminals.  */

   418 #define YYNTOKENS  30

   419 /* YYNNTS -- Number of nonterminals.  */

   420 #define YYNNTS  27

   421 /* YYNRULES -- Number of rules.  */

   422 #define YYNRULES  61

   423 /* YYNRULES -- Number of states.  */

   424 #define YYNSTATES  94

   425 

   426 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */

   427 #define YYUNDEFTOK  2

   428 #define YYMAXUTOK   275

   429 

   430 #define YYTRANSLATE(YYX)						\

   431   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

   432 

   433 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */

   434 static const yytype_uint8 yytranslate[] =

   435 {

   436        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   437        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   438        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   439        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   440       23,    24,     2,     2,    28,     2,    27,    21,     2,     2,

   441        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   442        2,     2,     2,     2,    22,     2,     2,     2,     2,     2,

   443        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   444        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   445        2,    25,     2,    26,     2,     2,     2,     2,     2,     2,

   446        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   447        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   448        2,     2,     2,     2,    29,     2,     2,     2,     2,     2,

   449        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   450        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   451        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   452        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   453        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   454        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   455        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   456        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   457        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   458        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   459        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   460        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

   461        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,

   462        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,

   463       15,    16,    17,    18,    19,    20

   464 };

   465 

   466 #if YYDEBUG

   467 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in

   468    YYRHS.  */

   469 static const yytype_uint8 yyprhs[] =

   470 {

   471        0,     0,     3,     5,     7,     9,    11,    14,    17,    19,

   472       23,    27,    30,    33,    37,    41,    43,    45,    47,    51,

   473       55,    60,    61,    63,    65,    68,    72,    74,    76,    78,

   474       80,    84,    86,    88,    90,    94,    99,   101,   105,   107,

   475      109,   113,   115,   117,   121,   125,   127,   130,   132,   136,

   476      138,   142,   144,   148,   150,   154,   156,   160,   164,   166,

   477      170,   172

   478 };

   479 

   480 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */

   481 static const yytype_int8 yyrhs[] =

   482 {

   483       31,     0,    -1,    50,    -1,    34,    -1,    33,    -1,    21,

   484       -1,    21,    34,    -1,    41,    34,    -1,    35,    -1,    34,

   485       21,    35,    -1,    34,    41,    35,    -1,    37,    38,    -1,

   486       19,    38,    -1,    36,    37,    38,    -1,    36,    19,    38,

   487       -1,    42,    -1,    10,    -1,    22,    -1,    11,    23,    24,

   488       -1,    12,    23,    24,    -1,    12,    23,    14,    24,    -1,

   489       -1,    39,    -1,    40,    -1,    39,    40,    -1,    25,    31,

   490       26,    -1,    18,    -1,    27,    -1,    17,    -1,    15,    -1,

   491       23,    31,    24,    -1,    14,    -1,    16,    -1,    44,    -1,

   492       13,    23,    24,    -1,    13,    23,    45,    24,    -1,    46,

   493       -1,    45,    28,    46,    -1,    31,    -1,    48,    -1,    47,

   494       29,    48,    -1,    32,    -1,    49,    -1,    49,    21,    34,

   495       -1,    49,    41,    34,    -1,    43,    -1,    43,    39,    -1,

   496       51,    -1,    50,     9,    51,    -1,    52,    -1,    51,     8,

   497       52,    -1,    53,    -1,    52,     5,    53,    -1,    54,    -1,

   498       53,     4,    54,    -1,    55,    -1,    54,     7,    55,    -1,

   499       54,     6,    55,    -1,    56,    -1,    55,     3,    56,    -1,

   500       47,    -1,     6,    56,    -1

   501 };

   502 

   503 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */

   504 static const yytype_uint16 yyrline[] =

   505 {

   506        0,   117,   117,   124,   129,   136,   142,   147,   156,   164,

   507      170,   180,   191,   209,   220,   238,   242,   244,   251,   264,

   508      271,   282,   286,   290,   298,   306,   313,   321,   327,   335,

   509      342,   347,   354,   361,   365,   374,   386,   394,   402,   406,

   510      408,   420,   425,   427,   436,   449,   451,   461,   463,   473,

   511      475,   485,   487,   497,   499,   509,   511,   519,   529,   531,

   512      541,   543

   513 };

   514 #endif

   515 

   516 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE

   517 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.

   518    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */

   519 static const char *const yytname[] =

   520 {

   521   "$end", "error", "$undefined", "MULOP", "RELOP", "EQOP", "MINUS",

   522   "PLUS", "AND", "OR", "AXISNAME", "NODETYPE", "PI", "FUNCTIONNAME",

   523   "LITERAL", "VARIABLEREFERENCE", "NUMBER", "DOTDOT", "SLASHSLASH",

   524   "NAMETEST", "ERROR", "'/'", "'@'", "'('", "')'", "'['", "']'", "'.'",

   525   "','", "'|'", "$accept", "Expr", "LocationPath", "AbsoluteLocationPath",

   526   "RelativeLocationPath", "Step", "AxisSpecifier", "NodeTest",

   527   "OptionalPredicateList", "PredicateList", "Predicate",

   528   "DescendantOrSelf", "AbbreviatedStep", "PrimaryExpr", "FunctionCall",

   529   "ArgumentList", "Argument", "UnionExpr", "PathExpr", "FilterExpr",

   530   "OrExpr", "AndExpr", "EqualityExpr", "RelationalExpr", "AdditiveExpr",

   531   "MultiplicativeExpr", "UnaryExpr", 0

   532 };

   533 #endif

   534 

   535 # ifdef YYPRINT

   536 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to

   537    token YYLEX-NUM.  */

   538 static const yytype_uint16 yytoknum[] =

   539 {

   540        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,

   541      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,

   542      275,    47,    64,    40,    41,    91,    93,    46,    44,   124

   543 };

   544 # endif

   545 

   546 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */

   547 static const yytype_uint8 yyr1[] =

   548 {

   549        0,    30,    31,    32,    32,    33,    33,    33,    34,    34,

   550       34,    35,    35,    35,    35,    35,    36,    36,    37,    37,

   551       37,    38,    38,    39,    39,    40,    41,    42,    42,    43,

   552       43,    43,    43,    43,    44,    44,    45,    45,    46,    47,

   553       47,    48,    48,    48,    48,    49,    49,    50,    50,    51,

   554       51,    52,    52,    53,    53,    54,    54,    54,    55,    55,

   555       56,    56

   556 };

   557 

   558 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */

   559 static const yytype_uint8 yyr2[] =

   560 {

   561        0,     2,     1,     1,     1,     1,     2,     2,     1,     3,

   562        3,     2,     2,     3,     3,     1,     1,     1,     3,     3,

   563        4,     0,     1,     1,     2,     3,     1,     1,     1,     1,

   564        3,     1,     1,     1,     3,     4,     1,     3,     1,     1,

   565        3,     1,     1,     3,     3,     1,     2,     1,     3,     1,

   566        3,     1,     3,     1,     3,     1,     3,     3,     1,     3,

   567        1,     2

   568 };

   569 

   570 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state

   571    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero

   572    means the default is an error.  */

   573 static const yytype_uint8 yydefact[] =

   574 {

   575        0,     0,    16,     0,     0,     0,    31,    29,    32,    28,

   576       26,    21,     5,    17,     0,    27,     0,    41,     4,     3,

   577        8,     0,    21,     0,    15,    45,    33,    60,    39,    42,

   578        2,    47,    49,    51,    53,    55,    58,    61,     0,     0,

   579        0,     0,    12,    22,    23,     6,     0,     1,     0,     0,

   580       21,    21,    11,     7,    46,     0,     0,     0,     0,     0,

   581        0,     0,     0,     0,     0,    18,     0,    19,    34,    38,

   582        0,    36,     0,    24,    30,     9,    10,    14,    13,    40,

   583       43,    44,    48,    50,    52,    54,    57,    56,    59,    20,

   584       35,     0,    25,    37

   585 };

   586 

   587 /* YYDEFGOTO[NTERM-NUM].  */

   588 static const yytype_int8 yydefgoto[] =

   589 {

   590       -1,    69,    17,    18,    19,    20,    21,    22,    42,    43,

   591       44,    23,    24,    25,    26,    70,    71,    27,    28,    29,

   592       30,    31,    32,    33,    34,    35,    36

   593 };

   594 

   595 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing

   596    STATE-NUM.  */

   597 #define YYPACT_NINF -44

   598 static const yytype_int8 yypact[] =

   599 {

   600       75,    75,   -44,    -9,    -4,    18,   -44,   -44,   -44,   -44,

   601      -44,    19,    -2,   -44,    75,   -44,    36,   -44,   -44,    13,

   602      -44,    11,    19,    -2,   -44,    19,   -44,    21,   -44,    17,

   603       33,    39,    43,    45,    20,    48,   -44,   -44,    28,    -3,

   604       56,    75,   -44,    19,   -44,    13,    29,   -44,    -2,    -2,

   605       19,    19,   -44,    13,    19,    93,    -2,    -2,    75,    75,

   606       75,    75,    75,    75,    75,   -44,    30,   -44,   -44,   -44,

   607        0,   -44,    31,   -44,   -44,   -44,   -44,   -44,   -44,   -44,

   608       13,    13,    39,    43,    45,    20,    48,    48,   -44,   -44,

   609      -44,    75,   -44,   -44

   610 };

   611 

   612 /* YYPGOTO[NTERM-NUM].  */

   613 static const yytype_int8 yypgoto[] =

   614 {

   615      -44,     2,   -44,   -44,   -11,   -43,   -44,    34,   -18,    35,

   616      -36,   -16,   -44,   -44,   -44,   -44,   -35,   -44,     3,   -44,

   617      -44,     1,    23,    16,    38,   -23,    -1

   618 };

   619 

   620 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If

   621    positive, shift that token.  If negative, reduce the rule which

   622    number is the opposite.  If zero, do what YYDEFACT says.

   623    If YYTABLE_NINF, syntax error.  */

   624 #define YYTABLE_NINF -1

   625 static const yytype_uint8 yytable[] =

   626 {

   627       37,    45,    16,    49,    52,    75,    76,    73,     2,     3,

   628        4,    66,    53,    57,    38,     9,    46,    11,    73,    39,

   629       13,    67,     3,     4,    90,    15,    62,    63,    91,    49,

   630       50,    10,    77,    78,    48,    10,    47,    49,    56,    86,

   631       87,    40,    58,    72,    41,    80,    81,    59,    60,    61,

   632       55,    64,    65,    74,    89,    51,    93,    92,    79,    82,

   633       54,     0,     1,    88,    49,    49,     2,     3,     4,     5,

   634        6,     7,     8,     9,    10,    11,    84,    12,    13,    14,

   635       68,     1,    83,    15,     0,     2,     3,     4,     5,     6,

   636        7,     8,     9,    10,    11,     0,    12,    13,    14,    85,

   637        0,     0,    15,     2,     3,     4,     5,     6,     7,     8,

   638        9,    10,    11,     0,    12,    13,    14,     0,     0,     0,

   639       15

   640 };

   641 

   642 static const yytype_int8 yycheck[] =

   643 {

   644        1,    12,     0,    19,    22,    48,    49,    43,    10,    11,

   645       12,    14,    23,    29,    23,    17,    14,    19,    54,    23,

   646       22,    24,    11,    12,    24,    27,     6,     7,    28,    45,

   647       19,    18,    50,    51,    21,    18,     0,    53,    21,    62,

   648       63,    23,     9,    41,    25,    56,    57,     8,     5,     4,

   649       29,     3,    24,    24,    24,    21,    91,    26,    55,    58,

   650       25,    -1,     6,    64,    80,    81,    10,    11,    12,    13,

   651       14,    15,    16,    17,    18,    19,    60,    21,    22,    23,

   652       24,     6,    59,    27,    -1,    10,    11,    12,    13,    14,

   653       15,    16,    17,    18,    19,    -1,    21,    22,    23,    61,

   654       -1,    -1,    27,    10,    11,    12,    13,    14,    15,    16,

   655       17,    18,    19,    -1,    21,    22,    23,    -1,    -1,    -1,

   656       27

   657 };

   658 

   659 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing

   660    symbol of state STATE-NUM.  */

   661 static const yytype_uint8 yystos[] =

   662 {

   663        0,     6,    10,    11,    12,    13,    14,    15,    16,    17,

   664       18,    19,    21,    22,    23,    27,    31,    32,    33,    34,

   665       35,    36,    37,    41,    42,    43,    44,    47,    48,    49,

   666       50,    51,    52,    53,    54,    55,    56,    56,    23,    23,

   667       23,    25,    38,    39,    40,    34,    31,     0,    21,    41,

   668       19,    37,    38,    34,    39,    29,    21,    41,     9,     8,

   669        5,     4,     6,     7,     3,    24,    14,    24,    24,    31,

   670       45,    46,    31,    40,    24,    35,    35,    38,    38,    48,

   671       34,    34,    51,    52,    53,    54,    55,    55,    56,    24,

   672       24,    28,    26,    46

   673 };

   674 

   675 #define yyerrok		(yyerrstatus = 0)

   676 #define yyclearin	(yychar = YYEMPTY)

   677 #define YYEMPTY		(-2)

   678 #define YYEOF		0

   679 

   680 #define YYACCEPT	goto yyacceptlab

   681 #define YYABORT		goto yyabortlab

   682 #define YYERROR		goto yyerrorlab

   683 

   684 

   685 /* Like YYERROR except do call yyerror.  This remains here temporarily

   686    to ease the transition to the new meaning of YYERROR, for GCC.

   687    Once GCC version 2 has supplanted version 1, this can go.  */

   688 

   689 #define YYFAIL		goto yyerrlab

   690 

   691 #define YYRECOVERING()  (!!yyerrstatus)

   692 

   693 #define YYBACKUP(Token, Value)					\

   694 do								\

   695   if (yychar == YYEMPTY && yylen == 1)				\

   696     {								\

   697       yychar = (Token);						\

   698       yylval = (Value);						\

   699       yytoken = YYTRANSLATE (yychar);				\

   700       YYPOPSTACK (1);						\

   701       goto yybackup;						\

   702     }								\

   703   else								\

   704     {								\

   705       yyerror (YY_("syntax error: cannot back up")); \

   706       YYERROR;							\

   707     }								\

   708 while (YYID (0))

   709 

   710 

   711 #define YYTERROR	1

   712 #define YYERRCODE	256

   713 

   714 

   715 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].

   716    If N is 0, then set CURRENT to the empty location which ends

   717    the previous symbol: RHS[0] (always defined).  */

   718 

   719 #define YYRHSLOC(Rhs, K) ((Rhs)[K])

   720 #ifndef YYLLOC_DEFAULT

   721 # define YYLLOC_DEFAULT(Current, Rhs, N)				\

   722     do									\

   723       if (YYID (N))                                                    \

   724 	{								\

   725 	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\

   726 	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\

   727 	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\

   728 	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\

   729 	}								\

   730       else								\

   731 	{								\

   732 	  (Current).first_line   = (Current).last_line   =		\

   733 	    YYRHSLOC (Rhs, 0).last_line;				\

   734 	  (Current).first_column = (Current).last_column =		\

   735 	    YYRHSLOC (Rhs, 0).last_column;				\

   736 	}								\

   737     while (YYID (0))

   738 #endif

   739 

   740 

   741 /* YY_LOCATION_PRINT -- Print the location on the stream.

   742    This macro was not mandated originally: define only if we know

   743    we won't break user code: when these are the locations we know.  */

   744 

   745 #ifndef YY_LOCATION_PRINT

   746 # if YYLTYPE_IS_TRIVIAL

   747 #  define YY_LOCATION_PRINT(File, Loc)			\

   748      fprintf (File, "%d.%d-%d.%d",			\

   749 	      (Loc).first_line, (Loc).first_column,	\

   750 	      (Loc).last_line,  (Loc).last_column)

   751 # else

   752 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)

   753 # endif

   754 #endif

   755 

   756 

   757 /* YYLEX -- calling `yylex' with the right arguments.  */

   758 

   759 #ifdef YYLEX_PARAM

   760 # define YYLEX yylex (&yylval, YYLEX_PARAM)

   761 #else

   762 # define YYLEX yylex (&yylval)

   763 #endif

   764 

   765 /* Enable debugging if requested.  */

   766 #if YYDEBUG

   767 

   768 # ifndef YYFPRINTF

   769 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */

   770 #  define YYFPRINTF fprintf

   771 # endif

   772 

   773 # define YYDPRINTF(Args)			\

   774 do {						\

   775   if (yydebug)					\

   776     YYFPRINTF Args;				\

   777 } while (YYID (0))

   778 

   779 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \

   780 do {									  \

   781   if (yydebug)								  \

   782     {									  \

   783       YYFPRINTF (stderr, "%s ", Title);					  \

   784       yy_symbol_print (stderr,						  \

   785 		  Type, Value); \

   786       YYFPRINTF (stderr, "\n");						  \

   787     }									  \

   788 } while (YYID (0))

   789 

   790 

   791 /*--------------------------------.

   792 | Print this symbol on YYOUTPUT.  |

   793 `--------------------------------*/

   794 

   795 /*ARGSUSED*/

   796 #if (defined __STDC__ || defined __C99__FUNC__ \

   797      || defined __cplusplus || defined _MSC_VER)

   798 static void

   799 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)

   800 #else

   801 static void

   802 yy_symbol_value_print (yyoutput, yytype, yyvaluep)

   803     FILE *yyoutput;

   804     int yytype;

   805     YYSTYPE const * const yyvaluep;

   806 #endif

   807 {

   808   if (!yyvaluep)

   809     return;

   810 # ifdef YYPRINT

   811   if (yytype < YYNTOKENS)

   812     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);

   813 # else

   814   YYUSE (yyoutput);

   815 # endif

   816   switch (yytype)

   817     {

   818       default:

   819 	break;

   820     }

   821 }

   822 

   823 

   824 /*--------------------------------.

   825 | Print this symbol on YYOUTPUT.  |

   826 `--------------------------------*/

   827 

   828 #if (defined __STDC__ || defined __C99__FUNC__ \

   829      || defined __cplusplus || defined _MSC_VER)

   830 static void

   831 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)

   832 #else

   833 static void

   834 yy_symbol_print (yyoutput, yytype, yyvaluep)

   835     FILE *yyoutput;

   836     int yytype;

   837     YYSTYPE const * const yyvaluep;

   838 #endif

   839 {

   840   if (yytype < YYNTOKENS)

   841     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);

   842   else

   843     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

   844 

   845   yy_symbol_value_print (yyoutput, yytype, yyvaluep);

   846   YYFPRINTF (yyoutput, ")");

   847 }

   848 

   849 /*------------------------------------------------------------------.

   850 | yy_stack_print -- Print the state stack from its BOTTOM up to its |

   851 | TOP (included).                                                   |

   852 `------------------------------------------------------------------*/

   853 

   854 #if (defined __STDC__ || defined __C99__FUNC__ \

   855      || defined __cplusplus || defined _MSC_VER)

   856 static void

   857 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)

   858 #else

   859 static void

   860 yy_stack_print (bottom, top)

   861     yytype_int16 *bottom;

   862     yytype_int16 *top;

   863 #endif

   864 {

   865   YYFPRINTF (stderr, "Stack now");

   866   for (; bottom <= top; ++bottom)

   867     YYFPRINTF (stderr, " %d", *bottom);

   868   YYFPRINTF (stderr, "\n");

   869 }

   870 

   871 # define YY_STACK_PRINT(Bottom, Top)				\

   872 do {								\

   873   if (yydebug)							\

   874     yy_stack_print ((Bottom), (Top));				\

   875 } while (YYID (0))

   876 

   877 

   878 /*------------------------------------------------.

   879 | Report that the YYRULE is going to be reduced.  |

   880 `------------------------------------------------*/

   881 

   882 #if (defined __STDC__ || defined __C99__FUNC__ \

   883      || defined __cplusplus || defined _MSC_VER)

   884 static void

   885 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)

   886 #else

   887 static void

   888 yy_reduce_print (yyvsp, yyrule)

   889     YYSTYPE *yyvsp;

   890     int yyrule;

   891 #endif

   892 {

   893   int yynrhs = yyr2[yyrule];

   894   int yyi;

   895   unsigned long int yylno = yyrline[yyrule];

   896   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",

   897 	     yyrule - 1, yylno);

   898   /* The symbols being reduced.  */

   899   for (yyi = 0; yyi < yynrhs; yyi++)

   900     {

   901       fprintf (stderr, "   $%d = ", yyi + 1);

   902       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],

   903 		       &(yyvsp[(yyi + 1) - (yynrhs)])

   904 		       		       );

   905       fprintf (stderr, "\n");

   906     }

   907 }

   908 

   909 # define YY_REDUCE_PRINT(Rule)		\

   910 do {					\

   911   if (yydebug)				\

   912     yy_reduce_print (yyvsp, Rule); \

   913 } while (YYID (0))

   914 

   915 /* Nonzero means print parse trace.  It is left uninitialized so that

   916    multiple parsers can coexist.  */

   917 int yydebug;

   918 #else /* !YYDEBUG */

   919 # define YYDPRINTF(Args)

   920 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)

   921 # define YY_STACK_PRINT(Bottom, Top)

   922 # define YY_REDUCE_PRINT(Rule)

   923 #endif /* !YYDEBUG */

   924 

   925 

   926 /* YYINITDEPTH -- initial size of the parser's stacks.  */

   927 #ifndef	YYINITDEPTH

   928 # define YYINITDEPTH 200

   929 #endif

   930 

   931 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only

   932    if the built-in stack extension method is used).

   933 

   934    Do not make this value too large; the results are undefined if

   935    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)

   936    evaluated with infinite-precision integer arithmetic.  */

   937 

   938 #ifndef YYMAXDEPTH

   939 # define YYMAXDEPTH 10000

   940 #endif

   941 

   942 

   943 

   944 #if YYERROR_VERBOSE

   945 

   946 # ifndef yystrlen

   947 #  if defined __GLIBC__ && defined _STRING_H

   948 #   define yystrlen strlen

   949 #  else

   950 /* Return the length of YYSTR.  */

   951 #if (defined __STDC__ || defined __C99__FUNC__ \

   952      || defined __cplusplus || defined _MSC_VER)

   953 static YYSIZE_T

   954 yystrlen (const char *yystr)

   955 #else

   956 static YYSIZE_T

   957 yystrlen (yystr)

   958     const char *yystr;

   959 #endif

   960 {

   961   YYSIZE_T yylen;

   962   for (yylen = 0; yystr[yylen]; yylen++)

   963     continue;

   964   return yylen;

   965 }

   966 #  endif

   967 # endif

   968 

   969 # ifndef yystpcpy

   970 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE

   971 #   define yystpcpy stpcpy

   972 #  else

   973 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in

   974    YYDEST.  */

   975 #if (defined __STDC__ || defined __C99__FUNC__ \

   976      || defined __cplusplus || defined _MSC_VER)

   977 static char *

   978 yystpcpy (char *yydest, const char *yysrc)

   979 #else

   980 static char *

   981 yystpcpy (yydest, yysrc)

   982     char *yydest;

   983     const char *yysrc;

   984 #endif

   985 {

   986   char *yyd = yydest;

   987   const char *yys = yysrc;

   988 

   989   while ((*yyd++ = *yys++) != '\0')

   990     continue;

   991 

   992   return yyd - 1;

   993 }

   994 #  endif

   995 # endif

   996 

   997 # ifndef yytnamerr

   998 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary

   999    quotes and backslashes, so that it's suitable for yyerror.  The

  1000    heuristic is that double-quoting is unnecessary unless the string

  1001    contains an apostrophe, a comma, or backslash (other than

  1002    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is

  1003    null, do not copy; instead, return the length of what the result

  1004    would have been.  */

  1005 static YYSIZE_T

  1006 yytnamerr (char *yyres, const char *yystr)

  1007 {

  1008   if (*yystr == '"')

  1009     {

  1010       YYSIZE_T yyn = 0;

  1011       char const *yyp = yystr;

  1012 

  1013       for (;;)

  1014 	switch (*++yyp)

  1015 	  {

  1016 	  case '\'':

  1017 	  case ',':

  1018 	    goto do_not_strip_quotes;

  1019 

  1020 	  case '\\':

  1021 	    if (*++yyp != '\\')

  1022 	      goto do_not_strip_quotes;

  1023 	    /* Fall through.  */

  1024 	  default:

  1025 	    if (yyres)

  1026 	      yyres[yyn] = *yyp;

  1027 	    yyn++;

  1028 	    break;

  1029 

  1030 	  case '"':

  1031 	    if (yyres)

  1032 	      yyres[yyn] = '\0';

  1033 	    return yyn;

  1034 	  }

  1035     do_not_strip_quotes: ;

  1036     }

  1037 

  1038   if (! yyres)

  1039     return yystrlen (yystr);

  1040 

  1041   return yystpcpy (yyres, yystr) - yyres;

  1042 }

  1043 # endif

  1044 

  1045 /* Copy into YYRESULT an error message about the unexpected token

  1046    YYCHAR while in state YYSTATE.  Return the number of bytes copied,

  1047    including the terminating null byte.  If YYRESULT is null, do not

  1048    copy anything; just return the number of bytes that would be

  1049    copied.  As a special case, return 0 if an ordinary "syntax error"

  1050    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during

  1051    size calculation.  */

  1052 static YYSIZE_T

  1053 yysyntax_error (char *yyresult, int yystate, int yychar)

  1054 {

  1055   int yyn = yypact[yystate];

  1056 

  1057   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))

  1058     return 0;

  1059   else

  1060     {

  1061       int yytype = YYTRANSLATE (yychar);

  1062       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);

  1063       YYSIZE_T yysize = yysize0;

  1064       YYSIZE_T yysize1;

  1065       int yysize_overflow = 0;

  1066       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };

  1067       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];

  1068       int yyx;

  1069 

  1070 # if 0

  1071       /* This is so xgettext sees the translatable formats that are

  1072 	 constructed on the fly.  */

  1073       YY_("syntax error, unexpected %s");

  1074       YY_("syntax error, unexpected %s, expecting %s");

  1075       YY_("syntax error, unexpected %s, expecting %s or %s");

  1076       YY_("syntax error, unexpected %s, expecting %s or %s or %s");

  1077       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");

  1078 # endif

  1079       char *yyfmt;

  1080       char const *yyf;

  1081       static char const yyunexpected[] = "syntax error, unexpected %s";

  1082       static char const yyexpecting[] = ", expecting %s";

  1083       static char const yyor[] = " or %s";

  1084       char yyformat[sizeof yyunexpected

  1085 		    + sizeof yyexpecting - 1

  1086 		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)

  1087 		       * (sizeof yyor - 1))];

  1088       char const *yyprefix = yyexpecting;

  1089 

  1090       /* Start YYX at -YYN if negative to avoid negative indexes in

  1091 	 YYCHECK.  */

  1092       int yyxbegin = yyn < 0 ? -yyn : 0;

  1093 

  1094       /* Stay within bounds of both yycheck and yytname.  */

  1095       int yychecklim = YYLAST - yyn + 1;

  1096       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;

  1097       int yycount = 1;

  1098 

  1099       yyarg[0] = yytname[yytype];

  1100       yyfmt = yystpcpy (yyformat, yyunexpected);

  1101 

  1102       for (yyx = yyxbegin; yyx < yyxend; ++yyx)

  1103 	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

  1104 	  {

  1105 	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)

  1106 	      {

  1107 		yycount = 1;

  1108 		yysize = yysize0;

  1109 		yyformat[sizeof yyunexpected - 1] = '\0';

  1110 		break;

  1111 	      }

  1112 	    yyarg[yycount++] = yytname[yyx];

  1113 	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);

  1114 	    yysize_overflow |= (yysize1 < yysize);

  1115 	    yysize = yysize1;

  1116 	    yyfmt = yystpcpy (yyfmt, yyprefix);

  1117 	    yyprefix = yyor;

  1118 	  }

  1119 

  1120       yyf = YY_(yyformat);

  1121       yysize1 = yysize + yystrlen (yyf);

  1122       yysize_overflow |= (yysize1 < yysize);

  1123       yysize = yysize1;

  1124 

  1125       if (yysize_overflow)

  1126 	return YYSIZE_MAXIMUM;

  1127 

  1128       if (yyresult)

  1129 	{

  1130 	  /* Avoid sprintf, as that infringes on the user's name space.

  1131 	     Don't have undefined behavior even if the translation

  1132 	     produced a string with the wrong number of "%s"s.  */

  1133 	  char *yyp = yyresult;

  1134 	  int yyi = 0;

  1135 	  while ((*yyp = *yyf) != '\0')