org.simantics.fmil.core/native/FMILibrary/src/XML/src-gen/FMI1/fmi1_xml_variable_name_parser.tab.c

   1 /* A Bison parser, made by GNU Bison 2.7.  */\r
   2 \r
   3 /* Bison implementation for Yacc-like parsers in C\r
   4    \r
   5       Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.\r
   6    \r
   7    This program is free software: you can redistribute it and/or modify\r
   8    it under the terms of the GNU General Public License as published by\r
   9    the Free Software Foundation, either version 3 of the License, or\r
  10    (at your option) any later version.\r
  11    \r
  12    This program is distributed in the hope that it will be useful,\r
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  15    GNU General Public License for more details.\r
  16    \r
  17    You should have received a copy of the GNU General Public License\r
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */\r
  19 \r
  20 /* As a special exception, you may create a larger work that contains\r
  21    part or all of the Bison parser skeleton and distribute that work\r
  22    under terms of your choice, so long as that work isn't itself a\r
  23    parser generator using the skeleton or a modified version thereof\r
  24    as a parser skeleton.  Alternatively, if you modify or redistribute\r
  25    the parser skeleton itself, you may (at your option) remove this\r
  26    special exception, which will cause the skeleton and the resulting\r
  27    Bison output files to be licensed under the GNU General Public\r
  28    License without this special exception.\r
  29    \r
  30    This special exception was added by the Free Software Foundation in\r
  31    version 2.2 of Bison.  */\r
  32 \r
  33 /* C LALR(1) parser skeleton written by Richard Stallman, by\r
  34    simplifying the original so-called "semantic" parser.  */\r
  35 \r
  36 /* All symbols defined below should begin with yy or YY, to avoid\r
  37    infringing on user name space.  This should be done even for local\r
  38    variables, as they might otherwise be expanded by user macros.\r
  39    There are some unavoidable exceptions within include files to\r
  40    define necessary library symbols; they are noted "INFRINGES ON\r
  41    USER NAME SPACE" below.  */\r
  42 \r
  43 /* Identify Bison output.  */\r
  44 #define YYBISON 1\r
  45 \r
  46 /* Bison version.  */\r
  47 #define YYBISON_VERSION "2.7"\r
  48 \r
  49 /* Skeleton name.  */\r
  50 #define YYSKELETON_NAME "yacc.c"\r
  51 \r
  52 /* Pure parsers.  */\r
  53 #define YYPURE 2\r
  54 \r
  55 /* Push parsers.  */\r
  56 #define YYPUSH 0\r
  57 \r
  58 /* Pull parsers.  */\r
  59 #define YYPULL 1\r
  60 \r
  61 /* Substitute the type names.  */\r
  62 #define YYSTYPE         YYFMI1STYPE\r
  63 /* Substitute the variable and function names.  */\r
  64 #define yyparse         yyfmi1parse\r
  65 #define yylex           yyfmi1lex\r
  66 #define yyerror         yyfmi1error\r
  67 #define yylval          yyfmi1lval\r
  68 #define yychar          yyfmi1char\r
  69 #define yydebug         yyfmi1debug\r
  70 #define yynerrs         yyfmi1nerrs\r
  71 \r
  72 /* Copy the first part of user declarations.  */\r
  73 \r
  74 \r
  75 \r
  76 /*\r
  77 #define YYDEBUG 1\r
  78 int yydebug = 1;\r
  79 */\r
  80 \r
  81 #include <stdio.h>\r
  82 #include "fmi1_xml_variable_name_parser.tab.h"\r
  83 #include "fmi1_xml_variable_name_lex.h"\r
  84 \r
  85 #define MODULE "FMI1XML"\r
  86 #include <JM/jm_portability.h>\r
  87 \r
  88 void yyfmi1error(yyscan_t* scanner, jm_callbacks* cb, char* name, char const *msg)\r
  89 {\r
  90         jm_log_error(cb, MODULE, "Invalid structured ScalarVariable name \"%s\": %s", name, msg);\r
  91 }\r
  92 \r
  93 \r
  94 \r
  95 \r
  96 # ifndef YY_NULL\r
  97 #  if defined __cplusplus && 201103L <= __cplusplus\r
  98 #   define YY_NULL nullptr\r
  99 #  else\r
 100 #   define YY_NULL 0\r
 101 #  endif\r
 102 # endif\r
 103 \r
 104 /* Enabling verbose error messages.  */\r
 105 #ifdef YYERROR_VERBOSE\r
 106 # undef YYERROR_VERBOSE\r
 107 # define YYERROR_VERBOSE 1\r
 108 #else\r
 109 # define YYERROR_VERBOSE 1\r
 110 #endif\r
 111 \r
 112 /* In a future release of Bison, this section will be replaced\r
 113    by #include "fmi1_xml_variable_name_parser.tab.h".  */\r
 114 #ifndef YY_YYFMI1_FMI1_XML_VARIABLE_NAME_PARSER_TAB_H_INCLUDED\r
 115 # define YY_YYFMI1_FMI1_XML_VARIABLE_NAME_PARSER_TAB_H_INCLUDED\r
 116 /* Enabling traces.  */\r
 117 #ifndef YYFMI1DEBUG\r
 118 # if defined YYDEBUG\r
 119 #  if YYDEBUG\r
 120 #   define YYFMI1DEBUG 1\r
 121 #  else\r
 122 #   define YYFMI1DEBUG 0\r
 123 #  endif\r
 124 # else /* ! defined YYDEBUG */\r
 125 #  define YYFMI1DEBUG 0\r
 126 # endif /* ! defined YYDEBUG */\r
 127 #endif  /* ! defined YYFMI1DEBUG */\r
 128 #if YYFMI1DEBUG\r
 129 extern int yyfmi1debug;\r
 130 #endif\r
 131 \r
 132 /* Tokens.  */\r
 133 #ifndef YYFMI1TOKENTYPE\r
 134 # define YYFMI1TOKENTYPE\r
 135    /* Put the tokens into the symbol table, so that GDB and other debuggers\r
 136       know about them.  */\r
 137    enum yyfmi1tokentype {\r
 138      DER = 258,\r
 139      UNSIGNED_INTEGER = 259,\r
 140      NONDIGIT = 260,\r
 141      Q_NAME = 261\r
 142    };\r
 143 #endif\r
 144 \r
 145 \r
 146 #if ! defined YYFMI1STYPE && ! defined YYFMI1STYPE_IS_DECLARED\r
 147 typedef int YYFMI1STYPE;\r
 148 # define YYFMI1STYPE_IS_TRIVIAL 1\r
 149 # define yyfmi1stype YYFMI1STYPE /* obsolescent; will be withdrawn */\r
 150 # define YYFMI1STYPE_IS_DECLARED 1\r
 151 #endif\r
 152 \r
 153 \r
 154 #ifdef YYPARSE_PARAM\r
 155 #if defined __STDC__ || defined __cplusplus\r
 156 int yyfmi1parse (void *YYPARSE_PARAM);\r
 157 #else\r
 158 int yyfmi1parse ();\r
 159 #endif\r
 160 #else /* ! YYPARSE_PARAM */\r
 161 #if defined __STDC__ || defined __cplusplus\r
 162 int yyfmi1parse (void* scanner, void* cb, char* name);\r
 163 #else\r
 164 int yyfmi1parse ();\r
 165 #endif\r
 166 #endif /* ! YYPARSE_PARAM */\r
 167 \r
 168 #endif /* !YY_YYFMI1_FMI1_XML_VARIABLE_NAME_PARSER_TAB_H_INCLUDED  */\r
 169 \r
 170 /* Copy the second part of user declarations.  */\r
 171 \r
 172 \r
 173 \r
 174 #ifdef short\r
 175 # undef short\r
 176 #endif\r
 177 \r
 178 #ifdef YYTYPE_UINT8\r
 179 typedef YYTYPE_UINT8 yytype_uint8;\r
 180 #else\r
 181 typedef unsigned char yytype_uint8;\r
 182 #endif\r
 183 \r
 184 #ifdef YYTYPE_INT8\r
 185 typedef YYTYPE_INT8 yytype_int8;\r
 186 #elif (defined __STDC__ || defined __C99__FUNC__ \\r
 187      || defined __cplusplus || defined _MSC_VER)\r
 188 typedef signed char yytype_int8;\r
 189 #else\r
 190 typedef short int yytype_int8;\r
 191 #endif\r
 192 \r
 193 #ifdef YYTYPE_UINT16\r
 194 typedef YYTYPE_UINT16 yytype_uint16;\r
 195 #else\r
 196 typedef unsigned short int yytype_uint16;\r
 197 #endif\r
 198 \r
 199 #ifdef YYTYPE_INT16\r
 200 typedef YYTYPE_INT16 yytype_int16;\r
 201 #else\r
 202 typedef short int yytype_int16;\r
 203 #endif\r
 204 \r
 205 #ifndef YYSIZE_T\r
 206 # ifdef __SIZE_TYPE__\r
 207 #  define YYSIZE_T __SIZE_TYPE__\r
 208 # elif defined size_t\r
 209 #  define YYSIZE_T size_t\r
 210 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \\r
 211      || defined __cplusplus || defined _MSC_VER)\r
 212 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */\r
 213 #  define YYSIZE_T size_t\r
 214 # else\r
 215 #  define YYSIZE_T unsigned int\r
 216 # endif\r
 217 #endif\r
 218 \r
 219 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)\r
 220 \r
 221 #ifndef YY_\r
 222 # if defined YYENABLE_NLS && YYENABLE_NLS\r
 223 #  if ENABLE_NLS\r
 224 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */\r
 225 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)\r
 226 #  endif\r
 227 # endif\r
 228 # ifndef YY_\r
 229 #  define YY_(Msgid) Msgid\r
 230 # endif\r
 231 #endif\r
 232 \r
 233 /* Suppress unused-variable warnings by "using" E.  */\r
 234 #if ! defined lint || defined __GNUC__\r
 235 # define YYUSE(E) ((void) (E))\r
 236 #else\r
 237 # define YYUSE(E) /* empty */\r
 238 #endif\r
 239 \r
 240 /* Identity function, used to suppress warnings about constant conditions.  */\r
 241 #ifndef lint\r
 242 # define YYID(N) (N)\r
 243 #else\r
 244 #if (defined __STDC__ || defined __C99__FUNC__ \\r
 245      || defined __cplusplus || defined _MSC_VER)\r
 246 static int\r
 247 YYID (int yyi)\r
 248 #else\r
 249 static int\r
 250 YYID (yyi)\r
 251     int yyi;\r
 252 #endif\r
 253 {\r
 254   return yyi;\r
 255 }\r
 256 #endif\r
 257 \r
 258 #if ! defined yyoverflow || YYERROR_VERBOSE\r
 259 \r
 260 /* The parser invokes alloca or malloc; define the necessary symbols.  */\r
 261 \r
 262 # ifdef YYSTACK_USE_ALLOCA\r
 263 #  if YYSTACK_USE_ALLOCA\r
 264 #   ifdef __GNUC__\r
 265 #    define YYSTACK_ALLOC __builtin_alloca\r
 266 #   elif defined __BUILTIN_VA_ARG_INCR\r
 267 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */\r
 268 #   elif defined _AIX\r
 269 #    define YYSTACK_ALLOC __alloca\r
 270 #   elif defined _MSC_VER\r
 271 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */\r
 272 #    define alloca _alloca\r
 273 #   else\r
 274 #    define YYSTACK_ALLOC alloca\r
 275 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \\r
 276      || defined __cplusplus || defined _MSC_VER)\r
 277 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */\r
 278       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */\r
 279 #     ifndef EXIT_SUCCESS\r
 280 #      define EXIT_SUCCESS 0\r
 281 #     endif\r
 282 #    endif\r
 283 #   endif\r
 284 #  endif\r
 285 # endif\r
 286 \r
 287 # ifdef YYSTACK_ALLOC\r
 288    /* Pacify GCC's `empty if-body' warning.  */\r
 289 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))\r
 290 #  ifndef YYSTACK_ALLOC_MAXIMUM\r
 291     /* The OS might guarantee only one guard page at the bottom of the stack,\r
 292        and a page size can be as small as 4096 bytes.  So we cannot safely\r
 293        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number\r
 294        to allow for a few compiler-allocated temporary stack slots.  */\r
 295 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */\r
 296 #  endif\r
 297 # else\r
 298 #  define YYSTACK_ALLOC YYMALLOC\r
 299 #  define YYSTACK_FREE YYFREE\r
 300 #  ifndef YYSTACK_ALLOC_MAXIMUM\r
 301 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM\r
 302 #  endif\r
 303 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \\r
 304        && ! ((defined YYMALLOC || defined malloc) \\r
 305              && (defined YYFREE || defined free)))\r
 306 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */\r
 307 #   ifndef EXIT_SUCCESS\r
 308 #    define EXIT_SUCCESS 0\r
 309 #   endif\r
 310 #  endif\r
 311 #  ifndef YYMALLOC\r
 312 #   define YYMALLOC malloc\r
 313 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \\r
 314      || defined __cplusplus || defined _MSC_VER)\r
 315 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */\r
 316 #   endif\r
 317 #  endif\r
 318 #  ifndef YYFREE\r
 319 #   define YYFREE free\r
 320 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \\r
 321      || defined __cplusplus || defined _MSC_VER)\r
 322 void free (void *); /* INFRINGES ON USER NAME SPACE */\r
 323 #   endif\r
 324 #  endif\r
 325 # endif\r
 326 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */\r
 327 \r
 328 \r
 329 #if (! defined yyoverflow \\r
 330      && (! defined __cplusplus \\r
 331          || (defined YYFMI1STYPE_IS_TRIVIAL && YYFMI1STYPE_IS_TRIVIAL)))\r
 332 \r
 333 /* A type that is properly aligned for any stack member.  */\r
 334 union yyalloc\r
 335 {\r
 336   yytype_int16 yyss_alloc;\r
 337   YYSTYPE yyvs_alloc;\r
 338 };\r
 339 \r
 340 /* The size of the maximum gap between one aligned stack and the next.  */\r
 341 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)\r
 342 \r
 343 /* The size of an array large to enough to hold all stacks, each with\r
 344    N elements.  */\r
 345 # define YYSTACK_BYTES(N) \\r
 346      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \\r
 347       + YYSTACK_GAP_MAXIMUM)\r
 348 \r
 349 # define YYCOPY_NEEDED 1\r
 350 \r
 351 /* Relocate STACK from its old location to the new one.  The\r
 352    local variables YYSIZE and YYSTACKSIZE give the old and new number of\r
 353    elements in the stack, and YYPTR gives the new location of the\r
 354    stack.  Advance YYPTR to a properly aligned location for the next\r
 355    stack.  */\r
 356 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \\r
 357     do                                                                  \\r
 358       {                                                                 \\r
 359         YYSIZE_T yynewbytes;                                            \\r
 360         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \\r
 361         Stack = &yyptr->Stack_alloc;                                    \\r
 362         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \\r
 363         yyptr += yynewbytes / sizeof (*yyptr);                          \\r
 364       }                                                                 \\r
 365     while (YYID (0))\r
 366 \r
 367 #endif\r
 368 \r
 369 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED\r
 370 /* Copy COUNT objects from SRC to DST.  The source and destination do\r
 371    not overlap.  */\r
 372 # ifndef YYCOPY\r
 373 #  if defined __GNUC__ && 1 < __GNUC__\r
 374 #   define YYCOPY(Dst, Src, Count) \\r
 375       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))\r
 376 #  else\r
 377 #   define YYCOPY(Dst, Src, Count)              \\r
 378       do                                        \\r
 379         {                                       \\r
 380           YYSIZE_T yyi;                         \\r
 381           for (yyi = 0; yyi < (Count); yyi++)   \\r
 382             (Dst)[yyi] = (Src)[yyi];            \\r
 383         }                                       \\r
 384       while (YYID (0))\r
 385 #  endif\r
 386 # endif\r
 387 #endif /* !YYCOPY_NEEDED */\r
 388 \r
 389 /* YYFINAL -- State number of the termination state.  */\r
 390 #define YYFINAL  12\r
 391 /* YYLAST -- Last index in YYTABLE.  */\r
 392 #define YYLAST   22\r
 393 \r
 394 /* YYNTOKENS -- Number of terminals.  */\r
 395 #define YYNTOKENS  12\r
 396 /* YYNNTS -- Number of nonterminals.  */\r
 397 #define YYNNTS  7\r
 398 /* YYNRULES -- Number of rules.  */\r
 399 #define YYNRULES  15\r
 400 /* YYNRULES -- Number of states.  */\r
 401 #define YYNSTATES  27\r
 402 \r
 403 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */\r
 404 #define YYUNDEFTOK  2\r
 405 #define YYMAXUTOK   261\r
 406 \r
 407 #define YYTRANSLATE(YYX)                                                \\r
 408   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)\r
 409 \r
 410 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */\r
 411 static const yytype_uint8 yytranslate[] =\r
 412 {\r
 413        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 414        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 415        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 416        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 417        2,     7,     2,     2,     8,     2,     9,     2,     2,     2,\r
 418        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 419        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 420        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 421        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 422        2,    10,     2,    11,     2,     2,     2,     2,     2,     2,\r
 423        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 424        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 425        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 426        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 427        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 428        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 429        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 430        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 431        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 432        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 433        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 434        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 435        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 436        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 437        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 438        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,\r
 439        5,     6\r
 440 };\r
 441 \r
 442 #if YYFMI1DEBUG\r
 443 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in\r
 444    YYRHS.  */\r
 445 static const yytype_uint8 yyprhs[] =\r
 446 {\r
 447        0,     0,     3,     5,     9,    15,    17,    21,    23,    28,\r
 448       31,    33,    34,    37,    40,    42\r
 449 };\r
 450 \r
 451 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */\r
 452 static const yytype_int8 yyrhs[] =\r
 453 {\r
 454       13,     0,    -1,    14,    -1,     3,    14,     7,    -1,     3,\r
 455       14,     8,     4,     7,    -1,    15,    -1,    14,     9,    15,\r
 456       -1,    16,    -1,    16,    10,    18,    11,    -1,     5,    17,\r
 457       -1,     6,    -1,    -1,     4,    17,    -1,     5,    17,    -1,\r
 458        4,    -1,    18,     8,     4,    -1\r
 459 };\r
 460 \r
 461 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */\r
 462 static const yytype_uint8 yyrline[] =\r
 463 {\r
 464        0,    58,    58,    59,    60,    64,    65,    69,    70,    74,\r
 465       75,    78,    80,    81,    85,    86\r
 466 };\r
 467 #endif\r
 468 \r
 469 #if YYFMI1DEBUG || YYERROR_VERBOSE || 1\r
 470 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.\r
 471    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */\r
 472 static const char *const yytname[] =\r
 473 {\r
 474   "$end", "error", "$undefined", "DER", "UNSIGNED_INTEGER", "NONDIGIT",\r
 475   "Q_NAME", "')'", "','", "'.'", "'['", "']'", "$accept", "name",\r
 476   "identifier_list", "identifier", "bname", "nondigit_or_digit",\r
 477   "arrayIndices", YY_NULL\r
 478 };\r
 479 #endif\r
 480 \r
 481 # ifdef YYPRINT\r
 482 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to\r
 483    token YYLEX-NUM.  */\r
 484 static const yytype_uint16 yytoknum[] =\r
 485 {\r
 486        0,   256,   257,   258,   259,   260,   261,    41,    44,    46,\r
 487       91,    93\r
 488 };\r
 489 # endif\r
 490 \r
 491 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */\r
 492 static const yytype_uint8 yyr1[] =\r
 493 {\r
 494        0,    12,    13,    13,    13,    14,    14,    15,    15,    16,\r
 495       16,    17,    17,    17,    18,    18\r
 496 };\r
 497 \r
 498 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */\r
 499 static const yytype_uint8 yyr2[] =\r
 500 {\r
 501        0,     2,     1,     3,     5,     1,     3,     1,     4,     2,\r
 502        1,     0,     2,     2,     1,     3\r
 503 };\r
 504 \r
 505 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.\r
 506    Performed when YYTABLE doesn't specify something else to do.  Zero\r
 507    means the default is an error.  */\r
 508 static const yytype_uint8 yydefact[] =\r
 509 {\r
 510        0,     0,    11,    10,     0,     2,     5,     7,     0,    11,\r
 511       11,     9,     1,     0,     0,     3,     0,    12,    13,     6,\r
 512       14,     0,     0,     0,     8,     4,    15\r
 513 };\r
 514 \r
 515 /* YYDEFGOTO[NTERM-NUM].  */\r
 516 static const yytype_int8 yydefgoto[] =\r
 517 {\r
 518       -1,     4,     5,     6,     7,    11,    21\r
 519 };\r
 520 \r
 521 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing\r
 522    STATE-NUM.  */\r
 523 #define YYPACT_NINF -8\r
 524 static const yytype_int8 yypact[] =\r
 525 {\r
 526       -3,     3,     6,    -8,    12,     7,    -8,     5,    -2,     6,\r
 527        6,    -8,    -8,     3,    13,    -8,    14,    -8,    -8,    -8,\r
 528       -8,    -7,    15,    16,    -8,    -8,    -8\r
 529 };\r
 530 \r
 531 /* YYPGOTO[NTERM-NUM].  */\r
 532 static const yytype_int8 yypgoto[] =\r
 533 {\r
 534       -8,    -8,    18,     8,    -8,     4,    -8\r
 535 };\r
 536 \r
 537 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If\r
 538    positive, shift that token.  If negative, reduce the rule which\r
 539    number is the opposite.  If YYTABLE_NINF, syntax error.  */\r
 540 #define YYTABLE_NINF -1\r
 541 static const yytype_uint8 yytable[] =\r
 542 {\r
 543        1,    23,     2,     3,    24,    15,    16,    13,     2,     3,\r
 544        9,    10,    12,    17,    18,    14,    13,    20,    22,     8,\r
 545       26,    19,    25\r
 546 };\r
 547 \r
 548 #define yypact_value_is_default(Yystate) \\r
 549   (!!((Yystate) == (-8)))\r
 550 \r
 551 #define yytable_value_is_error(Yytable_value) \\r
 552   YYID (0)\r
 553 \r
 554 static const yytype_uint8 yycheck[] =\r
 555 {\r
 556        3,     8,     5,     6,    11,     7,     8,     9,     5,     6,\r
 557        4,     5,     0,     9,    10,    10,     9,     4,     4,     1,\r
 558        4,    13,     7\r
 559 };\r
 560 \r
 561 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing\r
 562    symbol of state STATE-NUM.  */\r
 563 static const yytype_uint8 yystos[] =\r
 564 {\r
 565        0,     3,     5,     6,    13,    14,    15,    16,    14,     4,\r
 566        5,    17,     0,     9,    10,     7,     8,    17,    17,    15,\r
 567        4,    18,     4,     8,    11,     7,     4\r
 568 };\r
 569 \r
 570 #define yyerrok         (yyerrstatus = 0)\r
 571 #define yyclearin       (yychar = YYEMPTY)\r
 572 #define YYEMPTY         (-2)\r
 573 #define YYEOF           0\r
 574 \r
 575 #define YYACCEPT        goto yyacceptlab\r
 576 #define YYABORT         goto yyabortlab\r
 577 #define YYERROR         goto yyerrorlab\r
 578 \r
 579 \r
 580 /* Like YYERROR except do call yyerror.  This remains here temporarily\r
 581    to ease the transition to the new meaning of YYERROR, for GCC.\r
 582    Once GCC version 2 has supplanted version 1, this can go.  However,\r
 583    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated\r
 584    in Bison 2.4.2's NEWS entry, where a plan to phase it out is\r
 585    discussed.  */\r
 586 \r
 587 #define YYFAIL          goto yyerrlab\r
 588 #if defined YYFAIL\r
 589   /* This is here to suppress warnings from the GCC cpp's\r
 590      -Wunused-macros.  Normally we don't worry about that warning, but\r
 591      some users do, and we want to make it easy for users to remove\r
 592      YYFAIL uses, which will produce warnings from Bison 2.5.  */\r
 593 #endif\r
 594 \r
 595 #define YYRECOVERING()  (!!yyerrstatus)\r
 596 \r
 597 #define YYBACKUP(Token, Value)                                  \\r
 598 do                                                              \\r
 599   if (yychar == YYEMPTY)                                        \\r
 600     {                                                           \\r
 601       yychar = (Token);                                         \\r
 602       yylval = (Value);                                         \\r
 603       YYPOPSTACK (yylen);                                       \\r
 604       yystate = *yyssp;                                         \\r
 605       goto yybackup;                                            \\r
 606     }                                                           \\r
 607   else                                                          \\r
 608     {                                                           \\r
 609       yyerror (scanner, cb, name, YY_("syntax error: cannot back up")); \\r
 610       YYERROR;                                                  \\r
 611     }                                                           \\r
 612 while (YYID (0))\r
 613 \r
 614 /* Error token number */\r
 615 #define YYTERROR        1\r
 616 #define YYERRCODE       256\r
 617 \r
 618 \r
 619 /* This macro is provided for backward compatibility. */\r
 620 #ifndef YY_LOCATION_PRINT\r
 621 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)\r
 622 #endif\r
 623 \r
 624 \r
 625 /* YYLEX -- calling `yylex' with the right arguments.  */\r
 626 #ifdef YYLEX_PARAM\r
 627 # define YYLEX yylex (&yylval, YYLEX_PARAM)\r
 628 #else\r
 629 # define YYLEX yylex (&yylval, scanner)\r
 630 #endif\r
 631 \r
 632 /* Enable debugging if requested.  */\r
 633 #if YYFMI1DEBUG\r
 634 \r
 635 # ifndef YYFPRINTF\r
 636 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */\r
 637 #  define YYFPRINTF fprintf\r
 638 # endif\r
 639 \r
 640 # define YYDPRINTF(Args)                        \\r
 641 do {                                            \\r
 642   if (yydebug)                                  \\r
 643     YYFPRINTF Args;                             \\r
 644 } while (YYID (0))\r
 645 \r
 646 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \\r
 647 do {                                                                      \\r
 648   if (yydebug)                                                            \\r
 649     {                                                                     \\r
 650       YYFPRINTF (stderr, "%s ", Title);                                   \\r
 651       yy_symbol_print (stderr,                                            \\r
 652                   Type, Value, scanner, cb, name); \\r
 653       YYFPRINTF (stderr, "\n");                                           \\r
 654     }                                                                     \\r
 655 } while (YYID (0))\r
 656 \r
 657 \r
 658 /*--------------------------------.\r
 659 | Print this symbol on YYOUTPUT.  |\r
 660 `--------------------------------*/\r
 661 \r
 662 /*ARGSUSED*/\r
 663 #if (defined __STDC__ || defined __C99__FUNC__ \\r
 664      || defined __cplusplus || defined _MSC_VER)\r
 665 static void\r
 666 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void* scanner, void* cb, char* name)\r
 667 #else\r
 668 static void\r
 669 yy_symbol_value_print (yyoutput, yytype, yyvaluep, scanner, cb, name)\r
 670     FILE *yyoutput;\r
 671     int yytype;\r
 672     YYSTYPE const * const yyvaluep;\r
 673     void* scanner;\r
 674     void* cb;\r
 675     char* name;\r
 676 #endif\r
 677 {\r
 678   FILE *yyo = yyoutput;\r
 679   YYUSE (yyo);\r
 680   if (!yyvaluep)\r
 681     return;\r
 682   YYUSE (scanner);\r
 683   YYUSE (cb);\r
 684   YYUSE (name);\r
 685 # ifdef YYPRINT\r
 686   if (yytype < YYNTOKENS)\r
 687     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);\r
 688 # else\r
 689   YYUSE (yyoutput);\r
 690 # endif\r
 691   switch (yytype)\r
 692     {\r
 693       default:\r
 694         break;\r
 695     }\r
 696 }\r
 697 \r
 698 \r
 699 /*--------------------------------.\r
 700 | Print this symbol on YYOUTPUT.  |\r
 701 `--------------------------------*/\r
 702 \r
 703 #if (defined __STDC__ || defined __C99__FUNC__ \\r
 704      || defined __cplusplus || defined _MSC_VER)\r
 705 static void\r
 706 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void* scanner, void* cb, char* name)\r
 707 #else\r
 708 static void\r
 709 yy_symbol_print (yyoutput, yytype, yyvaluep, scanner, cb, name)\r
 710     FILE *yyoutput;\r
 711     int yytype;\r
 712     YYSTYPE const * const yyvaluep;\r
 713     void* scanner;\r
 714     void* cb;\r
 715     char* name;\r
 716 #endif\r
 717 {\r
 718   if (yytype < YYNTOKENS)\r
 719     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);\r
 720   else\r
 721     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);\r
 722 \r
 723   yy_symbol_value_print (yyoutput, yytype, yyvaluep, scanner, cb, name);\r
 724   YYFPRINTF (yyoutput, ")");\r
 725 }\r
 726 \r
 727 /*------------------------------------------------------------------.\r
 728 | yy_stack_print -- Print the state stack from its BOTTOM up to its |\r
 729 | TOP (included).                                                   |\r
 730 `------------------------------------------------------------------*/\r
 731 \r
 732 #if (defined __STDC__ || defined __C99__FUNC__ \\r
 733      || defined __cplusplus || defined _MSC_VER)\r
 734 static void\r
 735 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)\r
 736 #else\r
 737 static void\r
 738 yy_stack_print (yybottom, yytop)\r
 739     yytype_int16 *yybottom;\r
 740     yytype_int16 *yytop;\r
 741 #endif\r
 742 {\r
 743   YYFPRINTF (stderr, "Stack now");\r
 744   for (; yybottom <= yytop; yybottom++)\r
 745     {\r
 746       int yybot = *yybottom;\r
 747       YYFPRINTF (stderr, " %d", yybot);\r
 748     }\r
 749   YYFPRINTF (stderr, "\n");\r
 750 }\r
 751 \r
 752 # define YY_STACK_PRINT(Bottom, Top)                            \\r
 753 do {                                                            \\r
 754   if (yydebug)                                                  \\r
 755     yy_stack_print ((Bottom), (Top));                           \\r
 756 } while (YYID (0))\r
 757 \r
 758 \r
 759 /*------------------------------------------------.\r
 760 | Report that the YYRULE is going to be reduced.  |\r
 761 `------------------------------------------------*/\r
 762 \r
 763 #if (defined __STDC__ || defined __C99__FUNC__ \\r
 764      || defined __cplusplus || defined _MSC_VER)\r
 765 static void\r
 766 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, void* scanner, void* cb, char* name)\r
 767 #else\r
 768 static void\r
 769 yy_reduce_print (yyvsp, yyrule, scanner, cb, name)\r
 770     YYSTYPE *yyvsp;\r
 771     int yyrule;\r
 772     void* scanner;\r
 773     void* cb;\r
 774     char* name;\r
 775 #endif\r
 776 {\r
 777   int yynrhs = yyr2[yyrule];\r
 778   int yyi;\r
 779   unsigned long int yylno = yyrline[yyrule];\r
 780   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",\r
 781              yyrule - 1, yylno);\r
 782   /* The symbols being reduced.  */\r
 783   for (yyi = 0; yyi < yynrhs; yyi++)\r
 784     {\r
 785       YYFPRINTF (stderr, "   $%d = ", yyi + 1);\r
 786       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],\r
 787                        &(yyvsp[(yyi + 1) - (yynrhs)])\r
 788                                        , scanner, cb, name);\r
 789       YYFPRINTF (stderr, "\n");\r
 790     }\r
 791 }\r
 792 \r
 793 # define YY_REDUCE_PRINT(Rule)          \\r
 794 do {                                    \\r
 795   if (yydebug)                          \\r
 796     yy_reduce_print (yyvsp, Rule, scanner, cb, name); \\r
 797 } while (YYID (0))\r
 798 \r
 799 /* Nonzero means print parse trace.  It is left uninitialized so that\r
 800    multiple parsers can coexist.  */\r
 801 int yydebug;\r
 802 #else /* !YYFMI1DEBUG */\r
 803 # define YYDPRINTF(Args)\r
 804 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)\r
 805 # define YY_STACK_PRINT(Bottom, Top)\r
 806 # define YY_REDUCE_PRINT(Rule)\r
 807 #endif /* !YYFMI1DEBUG */\r
 808 \r
 809 \r
 810 /* YYINITDEPTH -- initial size of the parser's stacks.  */\r
 811 #ifndef YYINITDEPTH\r
 812 # define YYINITDEPTH 200\r
 813 #endif\r
 814 \r
 815 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only\r
 816    if the built-in stack extension method is used).\r
 817 \r
 818    Do not make this value too large; the results are undefined if\r
 819    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)\r
 820    evaluated with infinite-precision integer arithmetic.  */\r
 821 \r
 822 #ifndef YYMAXDEPTH\r
 823 # define YYMAXDEPTH 10000\r
 824 #endif\r
 825 \r
 826 \r
 827 #if YYERROR_VERBOSE\r
 828 \r
 829 # ifndef yystrlen\r
 830 #  if defined __GLIBC__ && defined _STRING_H\r
 831 #   define yystrlen strlen\r
 832 #  else\r
 833 /* Return the length of YYSTR.  */\r
 834 #if (defined __STDC__ || defined __C99__FUNC__ \\r
 835      || defined __cplusplus || defined _MSC_VER)\r
 836 static YYSIZE_T\r
 837 yystrlen (const char *yystr)\r
 838 #else\r
 839 static YYSIZE_T\r
 840 yystrlen (yystr)\r
 841     const char *yystr;\r
 842 #endif\r
 843 {\r
 844   YYSIZE_T yylen;\r
 845   for (yylen = 0; yystr[yylen]; yylen++)\r
 846     continue;\r
 847   return yylen;\r
 848 }\r
 849 #  endif\r
 850 # endif\r
 851 \r
 852 # ifndef yystpcpy\r
 853 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE\r
 854 #   define yystpcpy stpcpy\r
 855 #  else\r
 856 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in\r
 857    YYDEST.  */\r
 858 #if (defined __STDC__ || defined __C99__FUNC__ \\r
 859      || defined __cplusplus || defined _MSC_VER)\r
 860 static char *\r
 861 yystpcpy (char *yydest, const char *yysrc)\r
 862 #else\r
 863 static char *\r
 864 yystpcpy (yydest, yysrc)\r
 865     char *yydest;\r
 866     const char *yysrc;\r
 867 #endif\r
 868 {\r
 869   char *yyd = yydest;\r
 870   const char *yys = yysrc;\r
 871 \r
 872   while ((*yyd++ = *yys++) != '\0')\r
 873     continue;\r
 874 \r
 875   return yyd - 1;\r
 876 }\r
 877 #  endif\r
 878 # endif\r
 879 \r
 880 # ifndef yytnamerr\r
 881 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary\r
 882    quotes and backslashes, so that it's suitable for yyerror.  The\r
 883    heuristic is that double-quoting is unnecessary unless the string\r
 884    contains an apostrophe, a comma, or backslash (other than\r
 885    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is\r
 886    null, do not copy; instead, return the length of what the result\r
 887    would have been.  */\r
 888 static YYSIZE_T\r
 889 yytnamerr (char *yyres, const char *yystr)\r
 890 {\r
 891   if (*yystr == '"')\r
 892     {\r
 893       YYSIZE_T yyn = 0;\r
 894       char const *yyp = yystr;\r
 895 \r
 896       for (;;)\r
 897         switch (*++yyp)\r
 898           {\r
 899           case '\'':\r
 900           case ',':\r
 901             goto do_not_strip_quotes;\r
 902 \r
 903           case '\\':\r
 904             if (*++yyp != '\\')\r
 905               goto do_not_strip_quotes;\r
 906             /* Fall through.  */\r
 907           default:\r
 908             if (yyres)\r
 909               yyres[yyn] = *yyp;\r
 910             yyn++;\r
 911             break;\r
 912 \r
 913           case '"':\r
 914             if (yyres)\r
 915               yyres[yyn] = '\0';\r
 916             return yyn;\r
 917           }\r
 918     do_not_strip_quotes: ;\r
 919     }\r
 920 \r
 921   if (! yyres)\r
 922     return yystrlen (yystr);\r
 923 \r
 924   return yystpcpy (yyres, yystr) - yyres;\r
 925 }\r
 926 # endif\r
 927 \r
 928 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message\r
 929    about the unexpected token YYTOKEN for the state stack whose top is\r
 930    YYSSP.\r
 931 \r
 932    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is\r
 933    not large enough to hold the message.  In that case, also set\r
 934    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the\r
 935    required number of bytes is too large to store.  */\r
 936 static int\r
 937 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,\r
 938                 yytype_int16 *yyssp, int yytoken)\r
 939 {\r
 940   YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);\r
 941   YYSIZE_T yysize = yysize0;\r
 942   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };\r
 943   /* Internationalized format string. */\r
 944   const char *yyformat = YY_NULL;\r
 945   /* Arguments of yyformat. */\r
 946   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];\r
 947   /* Number of reported tokens (one for the "unexpected", one per\r
 948      "expected"). */\r
 949   int yycount = 0;\r
 950 \r
 951   /* There are many possibilities here to consider:\r
 952      - Assume YYFAIL is not used.  It's too flawed to consider.  See\r
 953        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>\r
 954        for details.  YYERROR is fine as it does not invoke this\r
 955        function.\r
 956      - If this state is a consistent state with a default action, then\r
 957        the only way this function was invoked is if the default action\r
 958        is an error action.  In that case, don't check for expected\r
 959        tokens because there are none.\r
 960      - The only way there can be no lookahead present (in yychar) is if\r
 961        this state is a consistent state with a default action.  Thus,\r
 962        detecting the absence of a lookahead is sufficient to determine\r
 963        that there is no unexpected or expected token to report.  In that\r
 964        case, just report a simple "syntax error".\r
 965      - Don't assume there isn't a lookahead just because this state is a\r
 966        consistent state with a default action.  There might have been a\r
 967        previous inconsistent state, consistent state with a non-default\r
 968        action, or user semantic action that manipulated yychar.\r
 969      - Of course, the expected token list depends on states to have\r
 970        correct lookahead information, and it depends on the parser not\r
 971        to perform extra reductions after fetching a lookahead from the\r
 972        scanner and before detecting a syntax error.  Thus, state merging\r
 973        (from LALR or IELR) and default reductions corrupt the expected\r
 974        token list.  However, the list is correct for canonical LR with\r
 975        one exception: it will still contain any token that will not be\r
 976        accepted due to an error action in a later state.\r
 977   */\r
 978   if (yytoken != YYEMPTY)\r
 979     {\r
 980       int yyn = yypact[*yyssp];\r
 981       yyarg[yycount++] = yytname[yytoken];\r
 982       if (!yypact_value_is_default (yyn))\r
 983         {\r
 984           /* Start YYX at -YYN if negative to avoid negative indexes in\r
 985              YYCHECK.  In other words, skip the first -YYN actions for\r
 986              this state because they are default actions.  */\r
 987           int yyxbegin = yyn < 0 ? -yyn : 0;\r
 988           /* Stay within bounds of both yycheck and yytname.  */\r
 989           int yychecklim = YYLAST - yyn + 1;\r
 990           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;\r
 991           int yyx;\r
 992 \r
 993           for (yyx = yyxbegin; yyx < yyxend; ++yyx)\r
 994             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR\r
 995                 && !yytable_value_is_error (yytable[yyx + yyn]))\r
 996               {\r
 997                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)\r
 998                   {\r
 999                     yycount = 1;\r
1000                     yysize = yysize0;\r
1001                     break;\r
1002                   }\r
1003                 yyarg[yycount++] = yytname[yyx];\r
1004                 {\r
1005                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);\r
1006                   if (! (yysize <= yysize1\r
1007                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))\r
1008                     return 2;\r
1009                   yysize = yysize1;\r
1010                 }\r
1011               }\r
1012         }\r
1013     }\r
1014 \r
1015   switch (yycount)\r
1016     {\r
1017 # define YYCASE_(N, S)                      \\r
1018       case N:                               \\r
1019         yyformat = S;                       \\r
1020       break\r
1021       YYCASE_(0, YY_("syntax error"));\r
1022       YYCASE_(1, YY_("syntax error, unexpected %s"));\r
1023       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));\r
1024       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));\r
1025       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));\r
1026       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));\r
1027 # undef YYCASE_\r
1028     }\r
1029 \r
1030   {\r
1031     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);\r
1032     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))\r
1033       return 2;\r
1034     yysize = yysize1;\r
1035   }\r
1036 \r
1037   if (*yymsg_alloc < yysize)\r
1038     {\r
1039       *yymsg_alloc = 2 * yysize;\r
1040       if (! (yysize <= *yymsg_alloc\r
1041              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))\r
1042         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;\r
1043       return 1;\r
1044     }\r
1045 \r
1046   /* Avoid sprintf, as that infringes on the user's name space.\r
1047      Don't have undefined behavior even if the translation\r
1048      produced a string with the wrong number of "%s"s.  */\r
1049   {\r
1050     char *yyp = *yymsg;\r
1051     int yyi = 0;\r
1052     while ((*yyp = *yyformat) != '\0')\r
1053       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)\r
1054         {\r
1055           yyp += yytnamerr (yyp, yyarg[yyi++]);\r
1056           yyformat += 2;\r
1057         }\r
1058       else\r
1059         {\r
1060           yyp++;\r
1061           yyformat++;\r
1062         }\r
1063   }\r
1064   return 0;\r
1065 }\r
1066 #endif /* YYERROR_VERBOSE */\r
1067 \r
1068 /*-----------------------------------------------.\r
1069 | Release the memory associated to this symbol.  |\r
1070 `-----------------------------------------------*/\r
1071 \r
1072 /*ARGSUSED*/\r
1073 #if (defined __STDC__ || defined __C99__FUNC__ \\r
1074      || defined __cplusplus || defined _MSC_VER)\r
1075 static void\r
1076 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, void* scanner, void* cb, char* name)\r
1077 #else\r
1078 static void\r
1079 yydestruct (yymsg, yytype, yyvaluep, scanner, cb, name)\r
1080     const char *yymsg;\r
1081     int yytype;\r
1082     YYSTYPE *yyvaluep;\r
1083     void* scanner;\r
1084     void* cb;\r
1085     char* name;\r
1086 #endif\r
1087 {\r
1088   YYUSE (yyvaluep);\r
1089   YYUSE (scanner);\r
1090   YYUSE (cb);\r
1091   YYUSE (name);\r
1092 \r
1093   if (!yymsg)\r
1094     yymsg = "Deleting";\r
1095   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);\r
1096 \r
1097   switch (yytype)\r
1098     {\r
1099 \r
1100       default:\r
1101         break;\r
1102     }\r
1103 }\r
1104 \r
1105 \r
1106 \r
1107 \r
1108 /*----------.\r
1109 | yyparse.  |\r
1110 `----------*/\r
1111 \r
1112 #ifdef YYPARSE_PARAM\r
1113 #if (defined __STDC__ || defined __C99__FUNC__ \\r
1114      || defined __cplusplus || defined _MSC_VER)\r
1115 int\r
1116 yyparse (void *YYPARSE_PARAM)\r
1117 #else\r
1118 int\r
1119 yyparse (YYPARSE_PARAM)\r
1120     void *YYPARSE_PARAM;\r
1121 #endif\r
1122 #else /* ! YYPARSE_PARAM */\r
1123 #if (defined __STDC__ || defined __C99__FUNC__ \\r
1124      || defined __cplusplus || defined _MSC_VER)\r
1125 int\r
1126 yyparse (void* scanner, void* cb, char* name)\r
1127 #else\r
1128 int\r
1129 yyparse (scanner, cb, name)\r
1130     void* scanner;\r
1131     void* cb;\r
1132     char* name;\r
1133 #endif\r
1134 #endif\r
1135 {\r
1136 /* The lookahead symbol.  */\r
1137 int yychar;\r
1138 \r
1139 \r
1140 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__\r
1141 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */\r
1142 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \\r
1143     _Pragma ("GCC diagnostic push") \\r
1144     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\\r
1145     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")\r
1146 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \\r
1147     _Pragma ("GCC diagnostic pop")\r
1148 #else\r
1149 /* Default value used for initialization, for pacifying older GCCs\r
1150    or non-GCC compilers.  */\r
1151 static YYSTYPE yyval_default;\r
1152 # define YY_INITIAL_VALUE(Value) = Value\r
1153 #endif\r
1154 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN\r
1155 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN\r
1156 # define YY_IGNORE_MAYBE_UNINITIALIZED_END\r
1157 #endif\r
1158 #ifndef YY_INITIAL_VALUE\r
1159 # define YY_INITIAL_VALUE(Value) /* Nothing. */\r
1160 #endif\r
1161 \r
1162 /* The semantic value of the lookahead symbol.  */\r
1163 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);\r
1164 \r
1165     /* Number of syntax errors so far.  */\r
1166     int yynerrs;\r
1167 \r
1168     int yystate;\r
1169     /* Number of tokens to shift before error messages enabled.  */\r
1170     int yyerrstatus;\r
1171 \r
1172     /* The stacks and their tools:\r
1173        `yyss': related to states.\r
1174        `yyvs': related to semantic values.\r
1175 \r
1176        Refer to the stacks through separate pointers, to allow yyoverflow\r
1177        to reallocate them elsewhere.  */\r
1178 \r
1179     /* The state stack.  */\r
1180     yytype_int16 yyssa[YYINITDEPTH];\r
1181     yytype_int16 *yyss;\r
1182     yytype_int16 *yyssp;\r
1183 \r
1184     /* The semantic value stack.  */\r
1185     YYSTYPE yyvsa[YYINITDEPTH];\r
1186     YYSTYPE *yyvs;\r
1187     YYSTYPE *yyvsp;\r
1188 \r
1189     YYSIZE_T yystacksize;\r
1190 \r
1191   int yyn;\r
1192   int yyresult;\r
1193   /* Lookahead token as an internal (translated) token number.  */\r
1194   int yytoken = 0;\r
1195   /* The variables used to return semantic value and location from the\r
1196      action routines.  */\r
1197   YYSTYPE yyval;\r
1198 \r
1199 #if YYERROR_VERBOSE\r
1200   /* Buffer for error messages, and its allocated size.  */\r
1201   char yymsgbuf[128];\r
1202   char *yymsg = yymsgbuf;\r
1203   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;\r
1204 #endif\r
1205 \r
1206 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))\r
1207 \r
1208   /* The number of symbols on the RHS of the reduced rule.\r
1209      Keep to zero when no symbol should be popped.  */\r
1210   int yylen = 0;\r
1211 \r
1212   yyssp = yyss = yyssa;\r
1213   yyvsp = yyvs = yyvsa;\r
1214   yystacksize = YYINITDEPTH;\r
1215 \r
1216   YYDPRINTF ((stderr, "Starting parse\n"));\r
1217 \r
1218   yystate = 0;\r
1219   yyerrstatus = 0;\r
1220   yynerrs = 0;\r
1221   yychar = YYEMPTY; /* Cause a token to be read.  */\r
1222   goto yysetstate;\r
1223 \r
1224 /*------------------------------------------------------------.\r
1225 | yynewstate -- Push a new state, which is found in yystate.  |\r
1226 `------------------------------------------------------------*/\r
1227  yynewstate:\r
1228   /* In all cases, when you get here, the value and location stacks\r
1229      have just been pushed.  So pushing a state here evens the stacks.  */\r
1230   yyssp++;\r
1231 \r
1232  yysetstate:\r
1233   *yyssp = yystate;\r
1234 \r
1235   if (yyss + yystacksize - 1 <= yyssp)\r
1236     {\r
1237       /* Get the current used size of the three stacks, in elements.  */\r
1238       YYSIZE_T yysize = yyssp - yyss + 1;\r
1239 \r
1240 #ifdef yyoverflow\r
1241       {\r
1242         /* Give user a chance to reallocate the stack.  Use copies of\r
1243            these so that the &'s don't force the real ones into\r
1244            memory.  */\r
1245         YYSTYPE *yyvs1 = yyvs;\r
1246         yytype_int16 *yyss1 = yyss;\r
1247 \r
1248         /* Each stack pointer address is followed by the size of the\r
1249            data in use in that stack, in bytes.  This used to be a\r
1250            conditional around just the two extra args, but that might\r
1251            be undefined if yyoverflow is a macro.  */\r
1252         yyoverflow (YY_("memory exhausted"),\r
1253                     &yyss1, yysize * sizeof (*yyssp),\r
1254                     &yyvs1, yysize * sizeof (*yyvsp),\r
1255                     &yystacksize);\r
1256 \r
1257         yyss = yyss1;\r
1258         yyvs = yyvs1;\r
1259       }\r
1260 #else /* no yyoverflow */\r
1261 # ifndef YYSTACK_RELOCATE\r
1262       goto yyexhaustedlab;\r
1263 # else\r
1264       /* Extend the stack our own way.  */\r
1265       if (YYMAXDEPTH <= yystacksize)\r
1266         goto yyexhaustedlab;\r
1267       yystacksize *= 2;\r
1268       if (YYMAXDEPTH < yystacksize)\r
1269         yystacksize = YYMAXDEPTH;\r
1270 \r
1271       {\r
1272         yytype_int16 *yyss1 = yyss;\r
1273         union yyalloc *yyptr =\r
1274           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));\r
1275         if (! yyptr)\r
1276           goto yyexhaustedlab;\r
1277         YYSTACK_RELOCATE (yyss_alloc, yyss);\r
1278         YYSTACK_RELOCATE (yyvs_alloc, yyvs);\r
1279 #  undef YYSTACK_RELOCATE\r
1280         if (yyss1 != yyssa)\r
1281           YYSTACK_FREE (yyss1);\r
1282       }\r
1283 # endif\r
1284 #endif /* no yyoverflow */\r
1285 \r
1286       yyssp = yyss + yysize - 1;\r
1287       yyvsp = yyvs + yysize - 1;\r
1288 \r
1289       YYDPRINTF ((stderr, "Stack size increased to %lu\n",\r
1290                   (unsigned long int) yystacksize));\r
1291 \r
1292       if (yyss + yystacksize - 1 <= yyssp)\r
1293         YYABORT;\r
1294     }\r
1295 \r
1296   YYDPRINTF ((stderr, "Entering state %d\n", yystate));\r
1297 \r
1298   if (yystate == YYFINAL)\r
1299     YYACCEPT;\r
1300 \r
1301   goto yybackup;\r
1302 \r
1303 /*-----------.\r
1304 | yybackup.  |\r
1305 `-----------*/\r
1306 yybackup:\r
1307 \r
1308   /* Do appropriate processing given the current state.  Read a\r
1309      lookahead token if we need one and don't already have one.  */\r
1310 \r
1311   /* First try to decide what to do without reference to lookahead token.  */\r
1312   yyn = yypact[yystate];\r
1313   if (yypact_value_is_default (yyn))\r
1314     goto yydefault;\r
1315 \r
1316   /* Not known => get a lookahead token if don't already have one.  */\r
1317 \r
1318   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */\r
1319   if (yychar == YYEMPTY)\r
1320     {\r
1321       YYDPRINTF ((stderr, "Reading a token: "));\r
1322       yychar = YYLEX;\r
1323     }\r
1324 \r
1325   if (yychar <= YYEOF)\r
1326     {\r
1327       yychar = yytoken = YYEOF;\r
1328       YYDPRINTF ((stderr, "Now at end of input.\n"));\r
1329     }\r
1330   else\r
1331     {\r
1332       yytoken = YYTRANSLATE (yychar);\r
1333       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);\r
1334     }\r
1335 \r
1336   /* If the proper action on seeing token YYTOKEN is to reduce or to\r
1337      detect an error, take that action.  */\r
1338   yyn += yytoken;\r
1339   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)\r
1340     goto yydefault;\r
1341   yyn = yytable[yyn];\r
1342   if (yyn <= 0)\r
1343     {\r
1344       if (yytable_value_is_error (yyn))\r
1345         goto yyerrlab;\r
1346       yyn = -yyn;\r
1347       goto yyreduce;\r
1348     }\r
1349 \r
1350   /* Count tokens shifted since error; after three, turn off error\r
1351      status.  */\r
1352   if (yyerrstatus)\r
1353     yyerrstatus--;\r
1354 \r
1355   /* Shift the lookahead token.  */\r
1356   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);\r
1357 \r
1358   /* Discard the shifted token.  */\r
1359   yychar = YYEMPTY;\r
1360 \r
1361   yystate = yyn;\r
1362   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN\r
1363   *++yyvsp = yylval;\r
1364   YY_IGNORE_MAYBE_UNINITIALIZED_END\r
1365 \r
1366   goto yynewstate;\r
1367 \r
1368 \r
1369 /*-----------------------------------------------------------.\r
1370 | yydefault -- do the default action for the current state.  |\r
1371 `-----------------------------------------------------------*/\r
1372 yydefault:\r
1373   yyn = yydefact[yystate];\r
1374   if (yyn == 0)\r
1375     goto yyerrlab;\r
1376   goto yyreduce;\r
1377 \r
1378 \r
1379 /*-----------------------------.\r
1380 | yyreduce -- Do a reduction.  |\r
1381 `-----------------------------*/\r
1382 yyreduce:\r
1383   /* yyn is the number of a rule to reduce with.  */\r
1384   yylen = yyr2[yyn];\r
1385 \r
1386   /* If YYLEN is nonzero, implement the default value of the action:\r
1387      `$$ = $1'.\r
1388 \r
1389      Otherwise, the following line sets YYVAL to garbage.\r
1390      This behavior is undocumented and Bison\r
1391      users should not rely upon it.  Assigning to YYVAL\r
1392      unconditionally makes the parser a bit smaller, and it avoids a\r
1393      GCC warning that YYVAL may be used uninitialized.  */\r
1394   yyval = yyvsp[1-yylen];\r
1395 \r
1396 \r
1397   YY_REDUCE_PRINT (yyn);\r
1398   switch (yyn)\r
1399     {\r
1400       \r
1401 \r
1402       default: break;\r
1403     }\r
1404   /* User semantic actions sometimes alter yychar, and that requires\r
1405      that yytoken be updated with the new translation.  We take the\r
1406      approach of translating immediately before every use of yytoken.\r
1407      One alternative is translating here after every semantic action,\r
1408      but that translation would be missed if the semantic action invokes\r
1409      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or\r
1410      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an\r
1411      incorrect destructor might then be invoked immediately.  In the\r
1412      case of YYERROR or YYBACKUP, subsequent parser actions might lead\r
1413      to an incorrect destructor call or verbose syntax error message\r
1414      before the lookahead is translated.  */\r
1415   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);\r
1416 \r
1417   YYPOPSTACK (yylen);\r
1418   yylen = 0;\r
1419   YY_STACK_PRINT (yyss, yyssp);\r
1420 \r
1421   *++yyvsp = yyval;\r
1422 \r
1423   /* Now `shift' the result of the reduction.  Determine what state\r
1424      that goes to, based on the state we popped back to and the rule\r
1425      number reduced by.  */\r
1426 \r
1427   yyn = yyr1[yyn];\r
1428 \r
1429   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;\r
1430   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)\r
1431     yystate = yytable[yystate];\r
1432   else\r
1433     yystate = yydefgoto[yyn - YYNTOKENS];\r
1434 \r
1435   goto yynewstate;\r
1436 \r
1437 \r
1438 /*------------------------------------.\r
1439 | yyerrlab -- here on detecting error |\r
1440 `------------------------------------*/\r
1441 yyerrlab:\r
1442   /* Make sure we have latest lookahead translation.  See comments at\r
1443      user semantic actions for why this is necessary.  */\r
1444   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);\r
1445 \r
1446   /* If not already recovering from an error, report this error.  */\r
1447   if (!yyerrstatus)\r
1448     {\r
1449       ++yynerrs;\r
1450 #if ! YYERROR_VERBOSE\r
1451       yyerror (scanner, cb, name, YY_("syntax error"));\r
1452 #else\r
1453 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \\r
1454                                         yyssp, yytoken)\r
1455       {\r
1456         char const *yymsgp = YY_("syntax error");\r
1457         int yysyntax_error_status;\r
1458         yysyntax_error_status = YYSYNTAX_ERROR;\r
1459         if (yysyntax_error_status == 0)\r
1460           yymsgp = yymsg;\r
1461         else if (yysyntax_error_status == 1)\r
1462           {\r
1463             if (yymsg != yymsgbuf)\r
1464               YYSTACK_FREE (yymsg);\r
1465             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);\r
1466             if (!yymsg)\r
1467               {\r
1468                 yymsg = yymsgbuf;\r
1469                 yymsg_alloc = sizeof yymsgbuf;\r
1470                 yysyntax_error_status = 2;\r
1471               }\r
1472             else\r
1473               {\r
1474                 yysyntax_error_status = YYSYNTAX_ERROR;\r
1475                 yymsgp = yymsg;\r
1476               }\r
1477           }\r
1478         yyerror (scanner, cb, name, yymsgp);\r
1479         if (yysyntax_error_status == 2)\r
1480           goto yyexhaustedlab;\r
1481       }\r
1482 # undef YYSYNTAX_ERROR\r
1483 #endif\r
1484     }\r
1485 \r
1486 \r
1487 \r
1488   if (yyerrstatus == 3)\r
1489     {\r
1490       /* If just tried and failed to reuse lookahead token after an\r
1491          error, discard it.  */\r
1492 \r
1493       if (yychar <= YYEOF)\r
1494         {\r
1495           /* Return failure if at end of input.  */\r
1496           if (yychar == YYEOF)\r
1497             YYABORT;\r
1498         }\r
1499       else\r
1500         {\r
1501           yydestruct ("Error: discarding",\r
1502                       yytoken, &yylval, scanner, cb, name);\r
1503           yychar = YYEMPTY;\r
1504         }\r
1505     }\r
1506 \r
1507   /* Else will try to reuse lookahead token after shifting the error\r
1508      token.  */\r
1509   goto yyerrlab1;\r
1510 \r
1511 \r
1512 /*---------------------------------------------------.\r
1513 | yyerrorlab -- error raised explicitly by YYERROR.  |\r
1514 `---------------------------------------------------*/\r
1515 yyerrorlab:\r
1516 \r
1517   /* Pacify compilers like GCC when the user code never invokes\r
1518      YYERROR and the label yyerrorlab therefore never appears in user\r
1519      code.  */\r
1520   if (/*CONSTCOND*/ 0)\r
1521      goto yyerrorlab;\r
1522 \r
1523   /* Do not reclaim the symbols of the rule which action triggered\r
1524      this YYERROR.  */\r
1525   YYPOPSTACK (yylen);\r
1526   yylen = 0;\r
1527   YY_STACK_PRINT (yyss, yyssp);\r
1528   yystate = *yyssp;\r
1529   goto yyerrlab1;\r
1530 \r
1531 \r
1532 /*-------------------------------------------------------------.\r
1533 | yyerrlab1 -- common code for both syntax error and YYERROR.  |\r
1534 `-------------------------------------------------------------*/\r
1535 yyerrlab1:\r
1536   yyerrstatus = 3;      /* Each real token shifted decrements this.  */\r
1537 \r
1538   for (;;)\r
1539     {\r
1540       yyn = yypact[yystate];\r
1541       if (!yypact_value_is_default (yyn))\r
1542         {\r
1543           yyn += YYTERROR;\r
1544           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)\r
1545             {\r
1546               yyn = yytable[yyn];\r
1547               if (0 < yyn)\r
1548                 break;\r
1549             }\r
1550         }\r
1551 \r
1552       /* Pop the current state because it cannot handle the error token.  */\r
1553       if (yyssp == yyss)\r
1554         YYABORT;\r
1555 \r
1556 \r
1557       yydestruct ("Error: popping",\r
1558                   yystos[yystate], yyvsp, scanner, cb, name);\r
1559       YYPOPSTACK (1);\r
1560       yystate = *yyssp;\r
1561       YY_STACK_PRINT (yyss, yyssp);\r
1562     }\r
1563 \r
1564   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN\r
1565   *++yyvsp = yylval;\r
1566   YY_IGNORE_MAYBE_UNINITIALIZED_END\r
1567 \r
1568 \r
1569   /* Shift the error token.  */\r
1570   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);\r
1571 \r
1572   yystate = yyn;\r
1573   goto yynewstate;\r
1574 \r
1575 \r
1576 /*-------------------------------------.\r
1577 | yyacceptlab -- YYACCEPT comes here.  |\r
1578 `-------------------------------------*/\r
1579 yyacceptlab:\r
1580   yyresult = 0;\r
1581   goto yyreturn;\r
1582 \r
1583 /*-----------------------------------.\r
1584 | yyabortlab -- YYABORT comes here.  |\r
1585 `-----------------------------------*/\r
1586 yyabortlab:\r
1587   yyresult = 1;\r
1588   goto yyreturn;\r
1589 \r
1590 #if !defined yyoverflow || YYERROR_VERBOSE\r
1591 /*-------------------------------------------------.\r
1592 | yyexhaustedlab -- memory exhaustion comes here.  |\r
1593 `-------------------------------------------------*/\r
1594 yyexhaustedlab:\r
1595   yyerror (scanner, cb, name, YY_("memory exhausted"));\r
1596   yyresult = 2;\r
1597   /* Fall through.  */\r
1598 #endif\r
1599 \r
1600 yyreturn:\r
1601   if (yychar != YYEMPTY)\r
1602     {\r
1603       /* Make sure we have latest lookahead translation.  See comments at\r
1604          user semantic actions for why this is necessary.  */\r
1605       yytoken = YYTRANSLATE (yychar);\r
1606       yydestruct ("Cleanup: discarding lookahead",\r
1607                   yytoken, &yylval, scanner, cb, name);\r
1608     }\r
1609   /* Do not reclaim the symbols of the rule which action triggered\r
1610      this YYABORT or YYACCEPT.  */\r
1611   YYPOPSTACK (yylen);\r
1612   YY_STACK_PRINT (yyss, yyssp);\r
1613   while (yyssp != yyss)\r
1614     {\r
1615       yydestruct ("Cleanup: popping",\r
1616                   yystos[*yyssp], yyvsp, scanner, cb, name);\r
1617       YYPOPSTACK (1);\r
1618     }\r
1619 #ifndef yyoverflow\r
1620   if (yyss != yyssa)\r
1621     YYSTACK_FREE (yyss);\r
1622 #endif\r
1623 #if YYERROR_VERBOSE\r
1624   if (yymsg != yymsgbuf)\r
1625     YYSTACK_FREE (yymsg);\r
1626 #endif\r
1627   /* Make sure YYID is used.  */\r
1628   return YYID (yyresult);\r
1629 }\r
1630 \r
1631 \r
1632 \r