src/ftacmp/xml.tab.cc

   1 /* A Bison parser, made by GNU Bison 1.875c.  */\r
   2 \r
   3 /* Skeleton parser for Yacc-like parsing with Bison,\r
   4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.\r
   5 \r
   6    This program is free software; you can redistribute it and/or modify\r
   7    it under the terms of the GNU General Public License as published by\r
   8    the Free Software Foundation; either version 2, or (at your option)\r
   9    any later version.\r
  10 \r
  11    This program is distributed in the hope that it will be useful,\r
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14    GNU General Public License for more details.\r
  15 \r
  16    You should have received a copy of the GNU General Public License\r
  17    along with this program; if not, write to the Free Software\r
  18    Foundation, Inc., 59 Temple Place - Suite 330,\r
  19    Boston, MA 02111-1307, USA.  */\r
  20 \r
  21 /* As a special exception, when this file is copied by Bison into a\r
  22    Bison output file, you may use that output file without restriction.\r
  23    This special exception was added by the Free Software Foundation\r
  24    in version 1.24 of Bison.  */\r
  25 \r
  26 /* Written by Richard Stallman by simplifying the original so called\r
  27    ``semantic'' parser.  */\r
  28 \r
  29 /* All symbols defined below should begin with yy or YY, to avoid\r
  30    infringing on user name space.  This should be done even for local\r
  31    variables, as they might otherwise be expanded by user macros.\r
  32    There are some unavoidable exceptions within include files to\r
  33    define necessary library symbols; they are noted "INFRINGES ON\r
  34    USER NAME SPACE" below.  */\r
  35 \r
  36 /* Identify Bison output.  */\r
  37 #define YYBISON 1\r
  38 \r
  39 /* Skeleton name.  */\r
  40 #define YYSKELETON_NAME "yacc.c"\r
  41 \r
  42 /* Pure parsers.  */\r
  43 #define YYPURE 0\r
  44 \r
  45 /* Using locations.  */\r
  46 #define YYLSP_NEEDED 0\r
  47 \r
  48 /* If NAME_PREFIX is specified substitute the variables and functions\r
  49    names.  */\r
  50 #define yyparse xmlParserparse\r
  51 #define yylex   xmlParserlex\r
  52 #define yyerror xmlParsererror\r
  53 #define yylval  xmlParserlval\r
  54 #define yychar  xmlParserchar\r
  55 #define yydebug xmlParserdebug\r
  56 #define yynerrs xmlParsernerrs\r
  57 \r
  58 \r
  59 /* Tokens.  */\r
  60 #ifndef YYTOKENTYPE\r
  61 # define YYTOKENTYPE\r
  62    /* Put the tokens into the symbol table, so that GDB and other debuggers\r
  63       know about them.  */\r
  64    enum yytokentype {\r
  65      NAME = 258,\r
  66      STRING_TOKEN = 259\r
  67    };\r
  68 #endif\r
  69 #define NAME 258\r
  70 #define STRING_TOKEN 259\r
  71 \r
  72 \r
  73 \r
  74 \r
  75 /* Copy the first part of user declarations.  */\r
  76 #line 8 "xml.y"\r
  77 \r
  78 \r
  79 \r
  80 #include <stdio.h>\r
  81 \r
  82 /*              Some addn'l includes, necessary but not included by the\r
  83                 bison generated code.\r
  84 */\r
  85 \r
  86 #include <stdlib.h>\r
  87 \r
  88 /*              prototypes for the parser callbacks.\r
  89 */\r
  90 \r
  91 #include "xml_t.h"\r
  92 \r
  93 \r
  94 extern std::vector<std::string> xml_attr_vec;\r
  95 extern std::vector<std::string> xml_val_vec;\r
  96 extern std::string xml_a, xml_v;\r
  97 extern xml_t *xml_leaves;\r
  98 \r
  99 extern int xmlParserdebug;\r
 100 extern void xmlParsererror(char *s);\r
 101 extern int xmlParserlex();\r
 102 \r
 103 \r
 104 #define YYDEBUG 1\r
 105 \r
 106 \r
 107 \r
 108 /* Enabling traces.  */\r
 109 #ifndef YYDEBUG\r
 110 # define YYDEBUG 0\r
 111 #endif\r
 112 \r
 113 /* Enabling verbose error messages.  */\r
 114 #ifdef YYERROR_VERBOSE\r
 115 # undef YYERROR_VERBOSE\r
 116 # define YYERROR_VERBOSE 1\r
 117 #else\r
 118 # define YYERROR_VERBOSE 0\r
 119 #endif\r
 120 \r
 121 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)\r
 122 #line 42 "xml.y"\r
 123 typedef union YYSTYPE {\r
 124         int intval;\r
 125         double floatval;\r
 126         char *strval;\r
 127         int subtok;\r
 128 \r
 129         /*                      for FTA definition.     */\r
 130 \r
 131 } YYSTYPE;\r
 132 /* Line 191 of yacc.c.  */\r
 133 #line 134 "xml.tab.cc"\r
 134 # define yystype YYSTYPE /* obsolescent; will be withdrawn */\r
 135 # define YYSTYPE_IS_DECLARED 1\r
 136 # define YYSTYPE_IS_TRIVIAL 1\r
 137 #endif\r
 138 \r
 139 \r
 140 \r
 141 /* Copy the second part of user declarations.  */\r
 142 \r
 143 \r
 144 /* Line 214 of yacc.c.  */\r
 145 #line 146 "xml.tab.cc"\r
 146 \r
 147 #if ! defined (yyoverflow) || YYERROR_VERBOSE\r
 148 \r
 149 /* The parser invokes alloca or malloc; define the necessary symbols.  */\r
 150 \r
 151 # ifdef YYSTACK_USE_ALLOCA\r
 152 #  if YYSTACK_USE_ALLOCA\r
 153 #   define YYSTACK_ALLOC alloca\r
 154 #  endif\r
 155 # else\r
 156 #  if defined (alloca) || defined (_ALLOCA_H)\r
 157 #   define YYSTACK_ALLOC alloca\r
 158 #  else\r
 159 #   ifdef __GNUC__\r
 160 #    define YYSTACK_ALLOC __builtin_alloca\r
 161 #   endif\r
 162 #  endif\r
 163 # endif\r
 164 \r
 165 # ifdef YYSTACK_ALLOC\r
 166    /* Pacify GCC's `empty if-body' warning. */\r
 167 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)\r
 168 # else\r
 169 #  if defined (__STDC__) || defined (__cplusplus)\r
 170 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */\r
 171 #   define YYSIZE_T size_t\r
 172 #  endif\r
 173 #  define YYSTACK_ALLOC malloc\r
 174 #  define YYSTACK_FREE free\r
 175 # endif\r
 176 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */\r
 177 \r
 178 \r
 179 #if (! defined (yyoverflow) \\r
 180      && (! defined (__cplusplus) \\r
 181          || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))\r
 182 \r
 183 /* A type that is properly aligned for any stack member.  */\r
 184 union yyalloc\r
 185 {\r
 186   short yyss;\r
 187   YYSTYPE yyvs;\r
 188   };\r
 189 \r
 190 /* The size of the maximum gap between one aligned stack and the next.  */\r
 191 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)\r
 192 \r
 193 /* The size of an array large to enough to hold all stacks, each with\r
 194    N elements.  */\r
 195 # define YYSTACK_BYTES(N) \\r
 196      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \\r
 197       + YYSTACK_GAP_MAXIMUM)\r
 198 \r
 199 /* Copy COUNT objects from FROM to TO.  The source and destination do\r
 200    not overlap.  */\r
 201 # ifndef YYCOPY\r
 202 #  if defined (__GNUC__) && 1 < __GNUC__\r
 203 #   define YYCOPY(To, From, Count) \\r
 204       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))\r
 205 #  else\r
 206 #   define YYCOPY(To, From, Count)              \\r
 207       do                                        \\r
 208         {                                       \\r
 209           register YYSIZE_T yyi;                \\r
 210           for (yyi = 0; yyi < (Count); yyi++)   \\r
 211             (To)[yyi] = (From)[yyi];            \\r
 212         }                                       \\r
 213       while (0)\r
 214 #  endif\r
 215 # endif\r
 216 \r
 217 /* Relocate STACK from its old location to the new one.  The\r
 218    local variables YYSIZE and YYSTACKSIZE give the old and new number of\r
 219    elements in the stack, and YYPTR gives the new location of the\r
 220    stack.  Advance YYPTR to a properly aligned location for the next\r
 221    stack.  */\r
 222 # define YYSTACK_RELOCATE(Stack)                                        \\r
 223     do                                                                  \\r
 224       {                                                                 \\r
 225         YYSIZE_T yynewbytes;                                            \\r
 226         YYCOPY (&yyptr->Stack, Stack, yysize);                          \\r
 227         Stack = &yyptr->Stack;                                          \\r
 228         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \\r
 229         yyptr += yynewbytes / sizeof (*yyptr);                          \\r
 230       }                                                                 \\r
 231     while (0)\r
 232 \r
 233 #endif\r
 234 \r
 235 #if defined (__STDC__) || defined (__cplusplus)\r
 236    typedef signed char yysigned_char;\r
 237 #else\r
 238    typedef short yysigned_char;\r
 239 #endif\r
 240 \r
 241 /* YYFINAL -- State number of the termination state. */\r
 242 #define YYFINAL  6\r
 243 /* YYLAST -- Last index in YYTABLE.  */\r
 244 #define YYLAST   25\r
 245 \r
 246 /* YYNTOKENS -- Number of terminals. */\r
 247 #define YYNTOKENS  9\r
 248 /* YYNNTS -- Number of nonterminals. */\r
 249 #define YYNNTS  9\r
 250 /* YYNRULES -- Number of rules. */\r
 251 #define YYNRULES  14\r
 252 /* YYNRULES -- Number of states. */\r
 253 #define YYNSTATES  26\r
 254 \r
 255 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */\r
 256 #define YYUNDEFTOK  2\r
 257 #define YYMAXUTOK   259\r
 258 \r
 259 #define YYTRANSLATE(YYX)                                                \\r
 260   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)\r
 261 \r
 262 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */\r
 263 static const unsigned char yytranslate[] =\r
 264 {\r
 265        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 266        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 267        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 268        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 269        2,     2,     2,     2,     2,     2,     2,     6,     2,     2,\r
 270        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 271        5,     8,     7,     2,     2,     2,     2,     2,     2,     2,\r
 272        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 273        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 274        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 275        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 276        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 277        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 278        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 279        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 280        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 281        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 282        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 283        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 284        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 285        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 286        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 287        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 288        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 289        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 290        2,     2,     2,     2,     2,     2,     1,     2,     3,     4\r
 291 };\r
 292 \r
 293 #if YYDEBUG\r
 294 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in\r
 295    YYRHS.  */\r
 296 static const unsigned char yyprhs[] =\r
 297 {\r
 298        0,     0,     3,     5,     9,    12,    18,    23,    28,    30,\r
 299       33,    35,    36,    38,    41\r
 300 };\r
 301 \r
 302 /* YYRHS -- A `-1'-separated list of the rules' RHS. */\r
 303 static const yysigned_char yyrhs[] =\r
 304 {\r
 305       10,     0,    -1,    11,    -1,    12,    14,    13,    -1,    12,\r
 306       13,    -1,     5,     3,    15,     6,     7,    -1,     5,     3,\r
 307       15,     7,    -1,     5,     6,     3,     7,    -1,    11,    -1,\r
 308       14,    11,    -1,    16,    -1,    -1,    17,    -1,    16,    17,\r
 309       -1,     3,     8,     4,    -1\r
 310 };\r
 311 \r
 312 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */\r
 313 static const unsigned char yyrline[] =\r
 314 {\r
 315        0,    60,    60,    64,    65,    66,    72,    76,    81,    82,\r
 316       86,    87,    91,    93,    98\r
 317 };\r
 318 #endif\r
 319 \r
 320 #if YYDEBUG || YYERROR_VERBOSE\r
 321 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.\r
 322    First, the terminals, then, starting at YYNTOKENS, nonterminals. */\r
 323 static const char *const yytname[] =\r
 324 {\r
 325   "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "'<'", "'/'",\r
 326   "'>'", "'='", "$accept", "parse_result", "resource", "start_tag",\r
 327   "end_tag", "xml_list", "opt_val_list", "val_list", "val", 0\r
 328 };\r
 329 #endif\r
 330 \r
 331 # ifdef YYPRINT\r
 332 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to\r
 333    token YYLEX-NUM.  */\r
 334 static const unsigned short yytoknum[] =\r
 335 {\r
 336        0,   256,   257,   258,   259,    60,    47,    62,    61\r
 337 };\r
 338 # endif\r
 339 \r
 340 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */\r
 341 static const unsigned char yyr1[] =\r
 342 {\r
 343        0,     9,    10,    11,    11,    11,    12,    13,    14,    14,\r
 344       15,    15,    16,    16,    17\r
 345 };\r
 346 \r
 347 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */\r
 348 static const unsigned char yyr2[] =\r
 349 {\r
 350        0,     2,     1,     3,     2,     5,     4,     4,     1,     2,\r
 351        1,     0,     1,     2,     3\r
 352 };\r
 353 \r
 354 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state\r
 355    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero\r
 356    means the default is an error.  */\r
 357 static const unsigned char yydefact[] =\r
 358 {\r
 359        0,     0,     0,     2,     0,    11,     1,     0,     8,     4,\r
 360        0,     0,     0,    10,    12,     0,     9,     3,     0,     0,\r
 361        6,    13,     0,    14,     5,     7\r
 362 };\r
 363 \r
 364 /* YYDEFGOTO[NTERM-NUM]. */\r
 365 static const yysigned_char yydefgoto[] =\r
 366 {\r
 367       -1,     2,     3,     4,     9,    10,    12,    13,    14\r
 368 };\r
 369 \r
 370 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing\r
 371    STATE-NUM.  */\r
 372 #define YYPACT_NINF -5\r
 373 static const yysigned_char yypact[] =\r
 374 {\r
 375       -3,     0,     5,    -5,     4,     7,    -5,    -2,    -5,    -5,\r
 376        4,     3,     1,     7,    -5,     9,    -5,    -5,    10,     6,\r
 377       -5,    -5,     8,    -5,    -5,    -5\r
 378 };\r
 379 \r
 380 /* YYPGOTO[NTERM-NUM].  */\r
 381 static const yysigned_char yypgoto[] =\r
 382 {\r
 383       -5,    -5,    -4,    -5,    11,    -5,    -5,    -5,    12\r
 384 };\r
 385 \r
 386 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If\r
 387    positive, shift that token.  If negative, reduce the rule which\r
 388    number is the opposite.  If zero, do what YYDEFACT says.\r
 389    If YYTABLE_NINF, syntax error.  */\r
 390 #define YYTABLE_NINF -1\r
 391 static const unsigned char yytable[] =\r
 392 {\r
 393        8,     5,     1,     5,    15,     6,    16,    19,    20,     7,\r
 394       11,    18,    22,    24,    23,    25,     0,     0,     0,     0,\r
 395        0,    17,     0,     0,     0,    21\r
 396 };\r
 397 \r
 398 static const yysigned_char yycheck[] =\r
 399 {\r
 400        4,     3,     5,     3,     6,     0,    10,     6,     7,     5,\r
 401        3,     8,     3,     7,     4,     7,    -1,    -1,    -1,    -1,\r
 402       -1,    10,    -1,    -1,    -1,    13\r
 403 };\r
 404 \r
 405 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing\r
 406    symbol of state STATE-NUM.  */\r
 407 static const unsigned char yystos[] =\r
 408 {\r
 409        0,     5,    10,    11,    12,     3,     0,     5,    11,    13,\r
 410       14,     3,    15,    16,    17,     6,    11,    13,     8,     6,\r
 411        7,    17,     3,     4,     7,     7\r
 412 };\r
 413 \r
 414 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)\r
 415 # define YYSIZE_T __SIZE_TYPE__\r
 416 #endif\r
 417 #if ! defined (YYSIZE_T) && defined (size_t)\r
 418 # define YYSIZE_T size_t\r
 419 #endif\r
 420 #if ! defined (YYSIZE_T)\r
 421 # if defined (__STDC__) || defined (__cplusplus)\r
 422 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */\r
 423 #  define YYSIZE_T size_t\r
 424 # endif\r
 425 #endif\r
 426 #if ! defined (YYSIZE_T)\r
 427 # define YYSIZE_T unsigned int\r
 428 #endif\r
 429 \r
 430 #define yyerrok         (yyerrstatus = 0)\r
 431 #define yyclearin       (yychar = YYEMPTY)\r
 432 #define YYEMPTY         (-2)\r
 433 #define YYEOF           0\r
 434 \r
 435 #define YYACCEPT        goto yyacceptlab\r
 436 #define YYABORT         goto yyabortlab\r
 437 #define YYERROR         goto yyerrorlab\r
 438 \r
 439 \r
 440 /* Like YYERROR except do call yyerror.  This remains here temporarily\r
 441    to ease the transition to the new meaning of YYERROR, for GCC.\r
 442    Once GCC version 2 has supplanted version 1, this can go.  */\r
 443 \r
 444 #define YYFAIL          goto yyerrlab\r
 445 \r
 446 #define YYRECOVERING()  (!!yyerrstatus)\r
 447 \r
 448 #define YYBACKUP(Token, Value)                                  \\r
 449 do                                                              \\r
 450   if (yychar == YYEMPTY && yylen == 1)                          \\r
 451     {                                                           \\r
 452       yychar = (Token);                                         \\r
 453       yylval = (Value);                                         \\r
 454       yytoken = YYTRANSLATE (yychar);                           \\r
 455       YYPOPSTACK;                                               \\r
 456       goto yybackup;                                            \\r
 457     }                                                           \\r
 458   else                                                          \\r
 459     {                                                           \\r
 460       yyerror ("syntax error: cannot back up");\\r
 461       YYERROR;                                                  \\r
 462     }                                                           \\r
 463 while (0)\r
 464 \r
 465 #define YYTERROR        1\r
 466 #define YYERRCODE       256\r
 467 \r
 468 /* YYLLOC_DEFAULT -- Compute the default location (before the actions\r
 469    are run).  */\r
 470 \r
 471 #ifndef YYLLOC_DEFAULT\r
 472 # define YYLLOC_DEFAULT(Current, Rhs, N)                \\r
 473    ((Current).first_line   = (Rhs)[1].first_line,       \\r
 474     (Current).first_column = (Rhs)[1].first_column,     \\r
 475     (Current).last_line    = (Rhs)[N].last_line,        \\r
 476     (Current).last_column  = (Rhs)[N].last_column)\r
 477 #endif\r
 478 \r
 479 /* YYLEX -- calling `yylex' with the right arguments.  */\r
 480 \r
 481 #ifdef YYLEX_PARAM\r
 482 # define YYLEX yylex (YYLEX_PARAM)\r
 483 #else\r
 484 # define YYLEX yylex ()\r
 485 #endif\r
 486 \r
 487 /* Enable debugging if requested.  */\r
 488 #if YYDEBUG\r
 489 \r
 490 # ifndef YYFPRINTF\r
 491 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */\r
 492 #  define YYFPRINTF fprintf\r
 493 # endif\r
 494 \r
 495 # define YYDPRINTF(Args)                        \\r
 496 do {                                            \\r
 497   if (yydebug)                                  \\r
 498     YYFPRINTF Args;                             \\r
 499 } while (0)\r
 500 \r
 501 # define YYDSYMPRINT(Args)                      \\r
 502 do {                                            \\r
 503   if (yydebug)                                  \\r
 504     yysymprint Args;                            \\r
 505 } while (0)\r
 506 \r
 507 # define YYDSYMPRINTF(Title, Token, Value, Location)            \\r
 508 do {                                                            \\r
 509   if (yydebug)                                                  \\r
 510     {                                                           \\r
 511       YYFPRINTF (stderr, "%s ", Title);                         \\r
 512       yysymprint (stderr,                                       \\r
 513                   Token, Value);        \\r
 514       YYFPRINTF (stderr, "\n");                                 \\r
 515     }                                                           \\r
 516 } while (0)\r
 517 \r
 518 /*------------------------------------------------------------------.\r
 519 | yy_stack_print -- Print the state stack from its BOTTOM up to its |\r
 520 | TOP (included).                                                   |\r
 521 `------------------------------------------------------------------*/\r
 522 \r
 523 #if defined (__STDC__) || defined (__cplusplus)\r
 524 static void\r
 525 yy_stack_print (short *bottom, short *top)\r
 526 #else\r
 527 static void\r
 528 yy_stack_print (bottom, top)\r
 529     short *bottom;\r
 530     short *top;\r
 531 #endif\r
 532 {\r
 533   YYFPRINTF (stderr, "Stack now");\r
 534   for (/* Nothing. */; bottom <= top; ++bottom)\r
 535     YYFPRINTF (stderr, " %d", *bottom);\r
 536   YYFPRINTF (stderr, "\n");\r
 537 }\r
 538 \r
 539 # define YY_STACK_PRINT(Bottom, Top)                            \\r
 540 do {                                                            \\r
 541   if (yydebug)                                                  \\r
 542     yy_stack_print ((Bottom), (Top));                           \\r
 543 } while (0)\r
 544 \r
 545 \r
 546 /*------------------------------------------------.\r
 547 | Report that the YYRULE is going to be reduced.  |\r
 548 `------------------------------------------------*/\r
 549 \r
 550 #if defined (__STDC__) || defined (__cplusplus)\r
 551 static void\r
 552 yy_reduce_print (int yyrule)\r
 553 #else\r
 554 static void\r
 555 yy_reduce_print (yyrule)\r
 556     int yyrule;\r
 557 #endif\r
 558 {\r
 559   int yyi;\r
 560   unsigned int yylno = yyrline[yyrule];\r
 561   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",\r
 562              yyrule - 1, yylno);\r
 563   /* Print the symbols being reduced, and their result.  */\r
 564   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)\r
 565     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);\r
 566   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);\r
 567 }\r
 568 \r
 569 # define YY_REDUCE_PRINT(Rule)          \\r
 570 do {                                    \\r
 571   if (yydebug)                          \\r
 572     yy_reduce_print (Rule);             \\r
 573 } while (0)\r
 574 \r
 575 /* Nonzero means print parse trace.  It is left uninitialized so that\r
 576    multiple parsers can coexist.  */\r
 577 int yydebug;\r
 578 #else /* !YYDEBUG */\r
 579 # define YYDPRINTF(Args)\r
 580 # define YYDSYMPRINT(Args)\r
 581 # define YYDSYMPRINTF(Title, Token, Value, Location)\r
 582 # define YY_STACK_PRINT(Bottom, Top)\r
 583 # define YY_REDUCE_PRINT(Rule)\r
 584 #endif /* !YYDEBUG */\r
 585 \r
 586 \r
 587 /* YYINITDEPTH -- initial size of the parser's stacks.  */\r
 588 #ifndef YYINITDEPTH\r
 589 # define YYINITDEPTH 200\r
 590 #endif\r
 591 \r
 592 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only\r
 593    if the built-in stack extension method is used).\r
 594 \r
 595    Do not make this value too large; the results are undefined if\r
 596    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)\r
 597    evaluated with infinite-precision integer arithmetic.  */\r
 598 \r
 599 #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0\r
 600 # undef YYMAXDEPTH\r
 601 #endif\r
 602 \r
 603 #ifndef YYMAXDEPTH\r
 604 # define YYMAXDEPTH 10000\r
 605 #endif\r
 606 \r
 607 \f\r
 608 \r
 609 #if YYERROR_VERBOSE\r
 610 \r
 611 # ifndef yystrlen\r
 612 #  if defined (__GLIBC__) && defined (_STRING_H)\r
 613 #   define yystrlen strlen\r
 614 #  else\r
 615 /* Return the length of YYSTR.  */\r
 616 static YYSIZE_T\r
 617 #   if defined (__STDC__) || defined (__cplusplus)\r
 618 yystrlen (const char *yystr)\r
 619 #   else\r
 620 yystrlen (yystr)\r
 621      const char *yystr;\r
 622 #   endif\r
 623 {\r
 624   register const char *yys = yystr;\r
 625 \r
 626   while (*yys++ != '\0')\r
 627     continue;\r
 628 \r
 629   return yys - yystr - 1;\r
 630 }\r
 631 #  endif\r
 632 # endif\r
 633 \r
 634 # ifndef yystpcpy\r
 635 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)\r
 636 #   define yystpcpy stpcpy\r
 637 #  else\r
 638 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in\r
 639    YYDEST.  */\r
 640 static char *\r
 641 #   if defined (__STDC__) || defined (__cplusplus)\r
 642 yystpcpy (char *yydest, const char *yysrc)\r
 643 #   else\r
 644 yystpcpy (yydest, yysrc)\r
 645      char *yydest;\r
 646      const char *yysrc;\r
 647 #   endif\r
 648 {\r
 649   register char *yyd = yydest;\r
 650   register const char *yys = yysrc;\r
 651 \r
 652   while ((*yyd++ = *yys++) != '\0')\r
 653     continue;\r
 654 \r
 655   return yyd - 1;\r
 656 }\r
 657 #  endif\r
 658 # endif\r
 659 \r
 660 #endif /* !YYERROR_VERBOSE */\r
 661 \r
 662 \f\r
 663 \r
 664 #if YYDEBUG\r
 665 /*--------------------------------.\r
 666 | Print this symbol on YYOUTPUT.  |\r
 667 `--------------------------------*/\r
 668 \r
 669 #if defined (__STDC__) || defined (__cplusplus)\r
 670 static void\r
 671 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)\r
 672 #else\r
 673 static void\r
 674 yysymprint (yyoutput, yytype, yyvaluep)\r
 675     FILE *yyoutput;\r
 676     int yytype;\r
 677     YYSTYPE *yyvaluep;\r
 678 #endif\r
 679 {\r
 680   /* Pacify ``unused variable'' warnings.  */\r
 681   (void) yyvaluep;\r
 682 \r
 683   if (yytype < YYNTOKENS)\r
 684     {\r
 685       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);\r
 686 # ifdef YYPRINT\r
 687       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);\r
 688 # endif\r
 689     }\r
 690   else\r
 691     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);\r
 692 \r
 693   switch (yytype)\r
 694     {\r
 695       default:\r
 696         break;\r
 697     }\r
 698   YYFPRINTF (yyoutput, ")");\r
 699 }\r
 700 \r
 701 #endif /* ! YYDEBUG */\r
 702 /*-----------------------------------------------.\r
 703 | Release the memory associated to this symbol.  |\r
 704 `-----------------------------------------------*/\r
 705 \r
 706 #if defined (__STDC__) || defined (__cplusplus)\r
 707 static void\r
 708 yydestruct (int yytype, YYSTYPE *yyvaluep)\r
 709 #else\r
 710 static void\r
 711 yydestruct (yytype, yyvaluep)\r
 712     int yytype;\r
 713     YYSTYPE *yyvaluep;\r
 714 #endif\r
 715 {\r
 716   /* Pacify ``unused variable'' warnings.  */\r
 717   (void) yyvaluep;\r
 718 \r
 719   switch (yytype)\r
 720     {\r
 721 \r
 722       default:\r
 723         break;\r
 724     }\r
 725 }\r
 726 \f\r
 727 \r
 728 /* Prevent warnings from -Wmissing-prototypes.  */\r
 729 \r
 730 #ifdef YYPARSE_PARAM\r
 731 # if defined (__STDC__) || defined (__cplusplus)\r
 732 int yyparse (void *YYPARSE_PARAM);\r
 733 # else\r
 734 int yyparse ();\r
 735 # endif\r
 736 #else /* ! YYPARSE_PARAM */\r
 737 #if defined (__STDC__) || defined (__cplusplus)\r
 738 int yyparse (void);\r
 739 #else\r
 740 int yyparse ();\r
 741 #endif\r
 742 #endif /* ! YYPARSE_PARAM */\r
 743 \r
 744 \r
 745 \r
 746 /* The lookahead symbol.  */\r
 747 int yychar;\r
 748 \r
 749 /* The semantic value of the lookahead symbol.  */\r
 750 YYSTYPE yylval;\r
 751 \r
 752 /* Number of syntax errors so far.  */\r
 753 int yynerrs;\r
 754 \r
 755 \r
 756 \r
 757 /*----------.\r
 758 | yyparse.  |\r
 759 `----------*/\r
 760 \r
 761 #ifdef YYPARSE_PARAM\r
 762 # if defined (__STDC__) || defined (__cplusplus)\r
 763 int yyparse (void *YYPARSE_PARAM)\r
 764 # else\r
 765 int yyparse (YYPARSE_PARAM)\r
 766   void *YYPARSE_PARAM;\r
 767 # endif\r
 768 #else /* ! YYPARSE_PARAM */\r
 769 #if defined (__STDC__) || defined (__cplusplus)\r
 770 int\r
 771 yyparse (void)\r
 772 #else\r
 773 int\r
 774 yyparse ()\r
 775 \r
 776 #endif\r
 777 #endif\r
 778 {\r
 779   \r
 780   register int yystate;\r
 781   register int yyn;\r
 782   int yyresult;\r
 783   /* Number of tokens to shift before error messages enabled.  */\r
 784   int yyerrstatus;\r
 785   /* Lookahead token as an internal (translated) token number.  */\r
 786   int yytoken = 0;\r
 787 \r
 788   /* Three stacks and their tools:\r
 789      `yyss': related to states,\r
 790      `yyvs': related to semantic values,\r
 791      `yyls': related to locations.\r
 792 \r
 793      Refer to the stacks thru separate pointers, to allow yyoverflow\r
 794      to reallocate them elsewhere.  */\r
 795 \r
 796   /* The state stack.  */\r
 797   short yyssa[YYINITDEPTH];\r
 798   short *yyss = yyssa;\r
 799   register short *yyssp;\r
 800 \r
 801   /* The semantic value stack.  */\r
 802   YYSTYPE yyvsa[YYINITDEPTH];\r
 803   YYSTYPE *yyvs = yyvsa;\r
 804   register YYSTYPE *yyvsp;\r
 805 \r
 806 \r
 807 \r
 808 #define YYPOPSTACK   (yyvsp--, yyssp--)\r
 809 \r
 810   YYSIZE_T yystacksize = YYINITDEPTH;\r
 811 \r
 812   /* The variables used to return semantic value and location from the\r
 813      action routines.  */\r
 814   YYSTYPE yyval;\r
 815 \r
 816 \r
 817   /* When reducing, the number of symbols on the RHS of the reduced\r
 818      rule.  */\r
 819   int yylen;\r
 820 \r
 821   YYDPRINTF ((stderr, "Starting parse\n"));\r
 822 \r
 823   yystate = 0;\r
 824   yyerrstatus = 0;\r
 825   yynerrs = 0;\r
 826   yychar = YYEMPTY;             /* Cause a token to be read.  */\r
 827 \r
 828   /* Initialize stack pointers.\r
 829      Waste one element of value and location stack\r
 830      so that they stay on the same level as the state stack.\r
 831      The wasted elements are never initialized.  */\r
 832 \r
 833   yyssp = yyss;\r
 834   yyvsp = yyvs;\r
 835 \r
 836   goto yysetstate;\r
 837 \r
 838 /*------------------------------------------------------------.\r
 839 | yynewstate -- Push a new state, which is found in yystate.  |\r
 840 `------------------------------------------------------------*/\r
 841  yynewstate:\r
 842   /* In all cases, when you get here, the value and location stacks\r
 843      have just been pushed. so pushing a state here evens the stacks.\r
 844      */\r
 845   yyssp++;\r
 846 \r
 847  yysetstate:\r
 848   *yyssp = yystate;\r
 849 \r
 850   if (yyss + yystacksize - 1 <= yyssp)\r
 851     {\r
 852       /* Get the current used size of the three stacks, in elements.  */\r
 853       YYSIZE_T yysize = yyssp - yyss + 1;\r
 854 \r
 855 #ifdef yyoverflow\r
 856       {\r
 857         /* Give user a chance to reallocate the stack. Use copies of\r
 858            these so that the &'s don't force the real ones into\r
 859            memory.  */\r
 860         YYSTYPE *yyvs1 = yyvs;\r
 861         short *yyss1 = yyss;\r
 862 \r
 863 \r
 864         /* Each stack pointer address is followed by the size of the\r
 865            data in use in that stack, in bytes.  This used to be a\r
 866            conditional around just the two extra args, but that might\r
 867            be undefined if yyoverflow is a macro.  */\r
 868         yyoverflow ("parser stack overflow",\r
 869                     &yyss1, yysize * sizeof (*yyssp),\r
 870                     &yyvs1, yysize * sizeof (*yyvsp),\r
 871 \r
 872                     &yystacksize);\r
 873 \r
 874         yyss = yyss1;\r
 875         yyvs = yyvs1;\r
 876       }\r
 877 #else /* no yyoverflow */\r
 878 # ifndef YYSTACK_RELOCATE\r
 879       goto yyoverflowlab;\r
 880 # else\r
 881       /* Extend the stack our own way.  */\r
 882       if (YYMAXDEPTH <= yystacksize)\r
 883         goto yyoverflowlab;\r
 884       yystacksize *= 2;\r
 885       if (YYMAXDEPTH < yystacksize)\r
 886         yystacksize = YYMAXDEPTH;\r
 887 \r
 888       {\r
 889         short *yyss1 = yyss;\r
 890         union yyalloc *yyptr =\r
 891           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));\r
 892         if (! yyptr)\r
 893           goto yyoverflowlab;\r
 894         YYSTACK_RELOCATE (yyss);\r
 895         YYSTACK_RELOCATE (yyvs);\r
 896 \r
 897 #  undef YYSTACK_RELOCATE\r
 898         if (yyss1 != yyssa)\r
 899           YYSTACK_FREE (yyss1);\r
 900       }\r
 901 # endif\r
 902 #endif /* no yyoverflow */\r
 903 \r
 904       yyssp = yyss + yysize - 1;\r
 905       yyvsp = yyvs + yysize - 1;\r
 906 \r
 907 \r
 908       YYDPRINTF ((stderr, "Stack size increased to %lu\n",\r
 909                   (unsigned long int) yystacksize));\r
 910 \r
 911       if (yyss + yystacksize - 1 <= yyssp)\r
 912         YYABORT;\r
 913     }\r
 914 \r
 915   YYDPRINTF ((stderr, "Entering state %d\n", yystate));\r
 916 \r
 917   goto yybackup;\r
 918 \r
 919 /*-----------.\r
 920 | yybackup.  |\r
 921 `-----------*/\r
 922 yybackup:\r
 923 \r
 924 /* Do appropriate processing given the current state.  */\r
 925 /* Read a lookahead token if we need one and don't already have one.  */\r
 926 /* yyresume: */\r
 927 \r
 928   /* First try to decide what to do without reference to lookahead token.  */\r
 929 \r
 930   yyn = yypact[yystate];\r
 931   if (yyn == YYPACT_NINF)\r
 932     goto yydefault;\r
 933 \r
 934   /* Not known => get a lookahead token if don't already have one.  */\r
 935 \r
 936   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */\r
 937   if (yychar == YYEMPTY)\r
 938     {\r
 939       YYDPRINTF ((stderr, "Reading a token: "));\r
 940       yychar = YYLEX;\r
 941     }\r
 942 \r
 943   if (yychar <= YYEOF)\r
 944     {\r
 945       yychar = yytoken = YYEOF;\r
 946       YYDPRINTF ((stderr, "Now at end of input.\n"));\r
 947     }\r
 948   else\r
 949     {\r
 950       yytoken = YYTRANSLATE (yychar);\r
 951       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);\r
 952     }\r
 953 \r
 954   /* If the proper action on seeing token YYTOKEN is to reduce or to\r
 955      detect an error, take that action.  */\r
 956   yyn += yytoken;\r
 957   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)\r
 958     goto yydefault;\r
 959   yyn = yytable[yyn];\r
 960   if (yyn <= 0)\r
 961     {\r
 962       if (yyn == 0 || yyn == YYTABLE_NINF)\r
 963         goto yyerrlab;\r
 964       yyn = -yyn;\r
 965       goto yyreduce;\r
 966     }\r
 967 \r
 968   if (yyn == YYFINAL)\r
 969     YYACCEPT;\r
 970 \r
 971   /* Shift the lookahead token.  */\r
 972   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));\r
 973 \r
 974   /* Discard the token being shifted unless it is eof.  */\r
 975   if (yychar != YYEOF)\r
 976     yychar = YYEMPTY;\r
 977 \r
 978   *++yyvsp = yylval;\r
 979 \r
 980 \r
 981   /* Count tokens shifted since error; after three, turn off error\r
 982      status.  */\r
 983   if (yyerrstatus)\r
 984     yyerrstatus--;\r
 985 \r
 986   yystate = yyn;\r
 987   goto yynewstate;\r
 988 \r
 989 \r
 990 /*-----------------------------------------------------------.\r
 991 | yydefault -- do the default action for the current state.  |\r
 992 `-----------------------------------------------------------*/\r
 993 yydefault:\r
 994   yyn = yydefact[yystate];\r
 995   if (yyn == 0)\r
 996     goto yyerrlab;\r
 997   goto yyreduce;\r
 998 \r
 999 \r
1000 /*-----------------------------.\r
1001 | yyreduce -- Do a reduction.  |\r
1002 `-----------------------------*/\r
1003 yyreduce:\r
1004   /* yyn is the number of a rule to reduce with.  */\r
1005   yylen = yyr2[yyn];\r
1006 \r
1007   /* If YYLEN is nonzero, implement the default value of the action:\r
1008      `$$ = $1'.\r
1009 \r
1010      Otherwise, the following line sets YYVAL to garbage.\r
1011      This behavior is undocumented and Bison\r
1012      users should not rely upon it.  Assigning to YYVAL\r
1013      unconditionally makes the parser a bit smaller, and it avoids a\r
1014      GCC warning that YYVAL may be used uninitialized.  */\r
1015   yyval = yyvsp[1-yylen];\r
1016 \r
1017 \r
1018   YY_REDUCE_PRINT (yyn);\r
1019   switch (yyn)\r
1020     {\r
1021         case 5:\r
1022 #line 67 "xml.y"\r
1023     {xml_leaves->add_leaf(new xml_leaf_t(yyvsp[-3].strval, xml_attr_vec, xml_val_vec));\r
1024                 ;}\r
1025     break;\r
1026 \r
1027   case 11:\r
1028 #line 87 "xml.y"\r
1029     {xml_attr_vec.clear(); xml_val_vec.clear();;}\r
1030     break;\r
1031 \r
1032   case 12:\r
1033 #line 91 "xml.y"\r
1034     {xml_attr_vec.clear();  xml_attr_vec.push_back(xml_a);\r
1035                          xml_val_vec.clear(); xml_val_vec.push_back(xml_v); ;}\r
1036     break;\r
1037 \r
1038   case 13:\r
1039 #line 93 "xml.y"\r
1040     {xml_attr_vec.push_back(xml_a);\r
1041                                         xml_val_vec.push_back(xml_v); ;}\r
1042     break;\r
1043 \r
1044   case 14:\r
1045 #line 98 "xml.y"\r
1046     {xml_a = yyvsp[-2].strval; xml_v = yyvsp[0].strval;;}\r
1047     break;\r
1048 \r
1049 \r
1050     }\r
1051 \r
1052 /* Line 993 of yacc.c.  */\r
1053 #line 1054 "xml.tab.cc"\r
1054 \f\r
1055   yyvsp -= yylen;\r
1056   yyssp -= yylen;\r
1057 \r
1058 \r
1059   YY_STACK_PRINT (yyss, yyssp);\r
1060 \r
1061   *++yyvsp = yyval;\r
1062 \r
1063 \r
1064   /* Now `shift' the result of the reduction.  Determine what state\r
1065      that goes to, based on the state we popped back to and the rule\r
1066      number reduced by.  */\r
1067 \r
1068   yyn = yyr1[yyn];\r
1069 \r
1070   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;\r
1071   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)\r
1072     yystate = yytable[yystate];\r
1073   else\r
1074     yystate = yydefgoto[yyn - YYNTOKENS];\r
1075 \r
1076   goto yynewstate;\r
1077 \r
1078 \r
1079 /*------------------------------------.\r
1080 | yyerrlab -- here on detecting error |\r
1081 `------------------------------------*/\r
1082 yyerrlab:\r
1083   /* If not already recovering from an error, report this error.  */\r
1084   if (!yyerrstatus)\r
1085     {\r
1086       ++yynerrs;\r
1087 #if YYERROR_VERBOSE\r
1088       yyn = yypact[yystate];\r
1089 \r
1090       if (YYPACT_NINF < yyn && yyn < YYLAST)\r
1091         {\r
1092           YYSIZE_T yysize = 0;\r
1093           int yytype = YYTRANSLATE (yychar);\r
1094           const char* yyprefix;\r
1095           char *yymsg;\r
1096           int yyx;\r
1097 \r
1098           /* Start YYX at -YYN if negative to avoid negative indexes in\r
1099              YYCHECK.  */\r
1100           int yyxbegin = yyn < 0 ? -yyn : 0;\r
1101 \r
1102           /* Stay within bounds of both yycheck and yytname.  */\r
1103           int yychecklim = YYLAST - yyn;\r
1104           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;\r
1105           int yycount = 0;\r
1106 \r
1107           yyprefix = ", expecting ";\r
1108           for (yyx = yyxbegin; yyx < yyxend; ++yyx)\r
1109             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)\r
1110               {\r
1111                 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);\r
1112                 yycount += 1;\r
1113                 if (yycount == 5)\r
1114                   {\r
1115                     yysize = 0;\r
1116                     break;\r
1117                   }\r
1118               }\r
1119           yysize += (sizeof ("syntax error, unexpected ")\r
1120                      + yystrlen (yytname[yytype]));\r
1121           yymsg = (char *) YYSTACK_ALLOC (yysize);\r
1122           if (yymsg != 0)\r
1123             {\r
1124               char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");\r
1125               yyp = yystpcpy (yyp, yytname[yytype]);\r
1126 \r
1127               if (yycount < 5)\r
1128                 {\r
1129                   yyprefix = ", expecting ";\r
1130                   for (yyx = yyxbegin; yyx < yyxend; ++yyx)\r
1131                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)\r
1132                       {\r
1133                         yyp = yystpcpy (yyp, yyprefix);\r
1134                         yyp = yystpcpy (yyp, yytname[yyx]);\r
1135                         yyprefix = " or ";\r
1136                       }\r
1137                 }\r
1138               yyerror (yymsg);\r
1139               YYSTACK_FREE (yymsg);\r
1140             }\r
1141           else\r
1142             yyerror ("syntax error; also virtual memory exhausted");\r
1143         }\r
1144       else\r
1145 #endif /* YYERROR_VERBOSE */\r
1146         yyerror ("syntax error");\r
1147     }\r
1148 \r
1149 \r
1150 \r
1151   if (yyerrstatus == 3)\r
1152     {\r
1153       /* If just tried and failed to reuse lookahead token after an\r
1154          error, discard it.  */\r
1155 \r
1156       if (yychar <= YYEOF)\r
1157         {\r
1158           /* If at end of input, pop the error token,\r
1159              then the rest of the stack, then return failure.  */\r
1160           if (yychar == YYEOF)\r
1161              for (;;)\r
1162                {\r
1163                  YYPOPSTACK;\r
1164                  if (yyssp == yyss)\r
1165                    YYABORT;\r
1166                  YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);\r
1167                  yydestruct (yystos[*yyssp], yyvsp);\r
1168                }\r
1169         }\r
1170       else\r
1171         {\r
1172           YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);\r
1173           yydestruct (yytoken, &yylval);\r
1174           yychar = YYEMPTY;\r
1175 \r
1176         }\r
1177     }\r
1178 \r
1179   /* Else will try to reuse lookahead token after shifting the error\r
1180      token.  */\r
1181   goto yyerrlab1;\r
1182 \r
1183 \r
1184 /*---------------------------------------------------.\r
1185 | yyerrorlab -- error raised explicitly by YYERROR.  |\r
1186 `---------------------------------------------------*/\r
1187 yyerrorlab:\r
1188 \r
1189 #ifdef __GNUC__\r
1190   /* Pacify GCC when the user code never invokes YYERROR and the label\r
1191      yyerrorlab therefore never appears in user code.  */\r
1192   if (0)\r
1193      goto yyerrorlab;\r
1194 #endif\r
1195 \r
1196   yyvsp -= yylen;\r
1197   yyssp -= yylen;\r
1198   yystate = *yyssp;\r
1199   goto yyerrlab1;\r
1200 \r
1201 \r
1202 /*-------------------------------------------------------------.\r
1203 | yyerrlab1 -- common code for both syntax error and YYERROR.  |\r
1204 `-------------------------------------------------------------*/\r
1205 yyerrlab1:\r
1206   yyerrstatus = 3;      /* Each real token shifted decrements this.  */\r
1207 \r
1208   for (;;)\r
1209     {\r
1210       yyn = yypact[yystate];\r
1211       if (yyn != YYPACT_NINF)\r
1212         {\r
1213           yyn += YYTERROR;\r
1214           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)\r
1215             {\r
1216               yyn = yytable[yyn];\r
1217               if (0 < yyn)\r
1218                 break;\r
1219             }\r
1220         }\r
1221 \r
1222       /* Pop the current state because it cannot handle the error token.  */\r
1223       if (yyssp == yyss)\r
1224         YYABORT;\r
1225 \r
1226       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);\r
1227       yydestruct (yystos[yystate], yyvsp);\r
1228       YYPOPSTACK;\r
1229       yystate = *yyssp;\r
1230       YY_STACK_PRINT (yyss, yyssp);\r
1231     }\r
1232 \r
1233   if (yyn == YYFINAL)\r
1234     YYACCEPT;\r
1235 \r
1236   YYDPRINTF ((stderr, "Shifting error token, "));\r
1237 \r
1238   *++yyvsp = yylval;\r
1239 \r
1240 \r
1241   yystate = yyn;\r
1242   goto yynewstate;\r
1243 \r
1244 \r
1245 /*-------------------------------------.\r
1246 | yyacceptlab -- YYACCEPT comes here.  |\r
1247 `-------------------------------------*/\r
1248 yyacceptlab:\r
1249   yyresult = 0;\r
1250   goto yyreturn;\r
1251 \r
1252 /*-----------------------------------.\r
1253 | yyabortlab -- YYABORT comes here.  |\r
1254 `-----------------------------------*/\r
1255 yyabortlab:\r
1256   yyresult = 1;\r
1257   goto yyreturn;\r
1258 \r
1259 #ifndef yyoverflow\r
1260 /*----------------------------------------------.\r
1261 | yyoverflowlab -- parser overflow comes here.  |\r
1262 `----------------------------------------------*/\r
1263 yyoverflowlab:\r
1264   yyerror ("parser stack overflow");\r
1265   yyresult = 2;\r
1266   /* Fall through.  */\r
1267 #endif\r
1268 \r
1269 yyreturn:\r
1270 #ifndef yyoverflow\r
1271   if (yyss != yyssa)\r
1272     YYSTACK_FREE (yyss);\r
1273 #endif\r
1274   return yyresult;\r
1275 }\r
1276 \r
1277 \r
1278 #line 105 "xml.y"\r
1279 \r
1280 \r
1281 \r
1282 \r