GNU Binutils v2.34
[binutils.git] / binutils / mcparse.c
1 /* A Bison parser, made by GNU Bison 3.0.5.  */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5    Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc.
6
7    This program is free software: you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation, either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 /* As a special exception, you may create a larger work that contains
21    part or all of the Bison parser skeleton and distribute that work
22    under terms of your choice, so long as that work isn't itself a
23    parser generator using the skeleton or a modified version thereof
24    as a parser skeleton.  Alternatively, if you modify or redistribute
25    the parser skeleton itself, you may (at your option) remove this
26    special exception, which will cause the skeleton and the resulting
27    Bison output files to be licensed under the GNU General Public
28    License without this special exception.
29
30    This special exception was added by the Free Software Foundation in
31    version 2.2 of Bison.  */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34    simplifying the original so-called "semantic" parser.  */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37    infringing on user name space.  This should be done even for local
38    variables, as they might otherwise be expanded by user macros.
39    There are some unavoidable exceptions within include files to
40    define necessary library symbols; they are noted "INFRINGES ON
41    USER NAME SPACE" below.  */
42
43 /* Identify Bison output.  */
44 #define YYBISON 1
45
46 /* Bison version.  */
47 #define YYBISON_VERSION "3.0.5"
48
49 /* Skeleton name.  */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers.  */
53 #define YYPURE 0
54
55 /* Push parsers.  */
56 #define YYPUSH 0
57
58 /* Pull parsers.  */
59 #define YYPULL 1
60
61
62
63
64 /* Copy the first part of user declarations.  */
65 #line 1 "mcparse.y" /* yacc.c:339  */
66  /* mcparse.y -- parser for Windows mc files
67   Copyright (C) 2007-2020 Free Software Foundation, Inc.
68
69   Parser for Windows mc files
70   Written by Kai Tietz, Onevision.
71
72   This file is part of GNU Binutils.
73
74   This program is free software; you can redistribute it and/or modify
75   it under the terms of the GNU General Public License as published by
76   the Free Software Foundation; either version 3 of the License, or
77   (at your option) any later version.
78
79   This program is distributed in the hope that it will be useful,
80   but WITHOUT ANY WARRANTY; without even the implied warranty of
81   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
82   GNU General Public License for more details.
83
84   You should have received a copy of the GNU General Public License
85   along with this program; if not, write to the Free Software
86   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
87   02110-1301, USA.  */
88
89 /* This is a parser for Windows rc files.  It is based on the parser
90    by Gunther Ebert <gunther.ebert@ixos-leipzig.de>.  */
91
92 #include "sysdep.h"
93 #include "bfd.h"
94 #include "bucomm.h"
95 #include "libiberty.h"
96 #include "windmc.h"
97 #include "safe-ctype.h"
98
99 static rc_uint_type mc_last_id = 0;
100 static rc_uint_type mc_sefa_val = 0;
101 static unichar *mc_last_symbol = NULL;
102 static const mc_keyword *mc_cur_severity = NULL;
103 static const mc_keyword *mc_cur_facility = NULL;
104 static mc_node *cur_node = NULL;
105
106
107 #line 108 "mcparse.c" /* yacc.c:339  */
108
109 # ifndef YY_NULLPTR
110 #  if defined __cplusplus && 201103L <= __cplusplus
111 #   define YY_NULLPTR nullptr
112 #  else
113 #   define YY_NULLPTR 0
114 #  endif
115 # endif
116
117 /* Enabling verbose error messages.  */
118 #ifdef YYERROR_VERBOSE
119 # undef YYERROR_VERBOSE
120 # define YYERROR_VERBOSE 1
121 #else
122 # define YYERROR_VERBOSE 0
123 #endif
124
125 /* In a future release of Bison, this section will be replaced
126    by #include "y.tab.h".  */
127 #ifndef YY_YY_MCPARSE_H_INCLUDED
128 # define YY_YY_MCPARSE_H_INCLUDED
129 /* Debug traces.  */
130 #ifndef YYDEBUG
131 # define YYDEBUG 0
132 #endif
133 #if YYDEBUG
134 extern int yydebug;
135 #endif
136
137 /* Token type.  */
138 #ifndef YYTOKENTYPE
139 # define YYTOKENTYPE
140   enum yytokentype
141   {
142     NL = 258,
143     MCIDENT = 259,
144     MCFILENAME = 260,
145     MCLINE = 261,
146     MCCOMMENT = 262,
147     MCTOKEN = 263,
148     MCENDLINE = 264,
149     MCLANGUAGENAMES = 265,
150     MCFACILITYNAMES = 266,
151     MCSEVERITYNAMES = 267,
152     MCOUTPUTBASE = 268,
153     MCMESSAGEIDTYPEDEF = 269,
154     MCLANGUAGE = 270,
155     MCMESSAGEID = 271,
156     MCSEVERITY = 272,
157     MCFACILITY = 273,
158     MCSYMBOLICNAME = 274,
159     MCNUMBER = 275
160   };
161 #endif
162 /* Tokens.  */
163 #define NL 258
164 #define MCIDENT 259
165 #define MCFILENAME 260
166 #define MCLINE 261
167 #define MCCOMMENT 262
168 #define MCTOKEN 263
169 #define MCENDLINE 264
170 #define MCLANGUAGENAMES 265
171 #define MCFACILITYNAMES 266
172 #define MCSEVERITYNAMES 267
173 #define MCOUTPUTBASE 268
174 #define MCMESSAGEIDTYPEDEF 269
175 #define MCLANGUAGE 270
176 #define MCMESSAGEID 271
177 #define MCSEVERITY 272
178 #define MCFACILITY 273
179 #define MCSYMBOLICNAME 274
180 #define MCNUMBER 275
181
182 /* Value type.  */
183 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
184
185 union YYSTYPE
186 {
187 #line 44 "mcparse.y" /* yacc.c:355  */
188
189   rc_uint_type ival;
190   unichar *ustr;
191   const mc_keyword *tok;
192   mc_node *nod;
193
194 #line 195 "mcparse.c" /* yacc.c:355  */
195 };
196
197 typedef union YYSTYPE YYSTYPE;
198 # define YYSTYPE_IS_TRIVIAL 1
199 # define YYSTYPE_IS_DECLARED 1
200 #endif
201
202
203 extern YYSTYPE yylval;
204
205 int yyparse (void);
206
207 #endif /* !YY_YY_MCPARSE_H_INCLUDED  */
208
209 /* Copy the second part of user declarations.  */
210
211 #line 212 "mcparse.c" /* yacc.c:358  */
212
213 #ifdef short
214 # undef short
215 #endif
216
217 #ifdef YYTYPE_UINT8
218 typedef YYTYPE_UINT8 yytype_uint8;
219 #else
220 typedef unsigned char yytype_uint8;
221 #endif
222
223 #ifdef YYTYPE_INT8
224 typedef YYTYPE_INT8 yytype_int8;
225 #else
226 typedef signed char yytype_int8;
227 #endif
228
229 #ifdef YYTYPE_UINT16
230 typedef YYTYPE_UINT16 yytype_uint16;
231 #else
232 typedef unsigned short int yytype_uint16;
233 #endif
234
235 #ifdef YYTYPE_INT16
236 typedef YYTYPE_INT16 yytype_int16;
237 #else
238 typedef short int yytype_int16;
239 #endif
240
241 #ifndef YYSIZE_T
242 # ifdef __SIZE_TYPE__
243 #  define YYSIZE_T __SIZE_TYPE__
244 # elif defined size_t
245 #  define YYSIZE_T size_t
246 # elif ! defined YYSIZE_T
247 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
248 #  define YYSIZE_T size_t
249 # else
250 #  define YYSIZE_T unsigned int
251 # endif
252 #endif
253
254 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
255
256 #ifndef YY_
257 # if defined YYENABLE_NLS && YYENABLE_NLS
258 #  if ENABLE_NLS
259 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
260 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
261 #  endif
262 # endif
263 # ifndef YY_
264 #  define YY_(Msgid) Msgid
265 # endif
266 #endif
267
268 #ifndef YY_ATTRIBUTE
269 # if (defined __GNUC__                                               \
270       && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
271      || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
272 #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
273 # else
274 #  define YY_ATTRIBUTE(Spec) /* empty */
275 # endif
276 #endif
277
278 #ifndef YY_ATTRIBUTE_PURE
279 # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
280 #endif
281
282 #ifndef YY_ATTRIBUTE_UNUSED
283 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
284 #endif
285
286 #if !defined _Noreturn \
287      && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
288 # if defined _MSC_VER && 1200 <= _MSC_VER
289 #  define _Noreturn __declspec (noreturn)
290 # else
291 #  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
292 # endif
293 #endif
294
295 /* Suppress unused-variable warnings by "using" E.  */
296 #if ! defined lint || defined __GNUC__
297 # define YYUSE(E) ((void) (E))
298 #else
299 # define YYUSE(E) /* empty */
300 #endif
301
302 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
303 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
304 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
305     _Pragma ("GCC diagnostic push") \
306     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
307     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
308 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
309     _Pragma ("GCC diagnostic pop")
310 #else
311 # define YY_INITIAL_VALUE(Value) Value
312 #endif
313 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
314 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
315 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
316 #endif
317 #ifndef YY_INITIAL_VALUE
318 # define YY_INITIAL_VALUE(Value) /* Nothing. */
319 #endif
320
321
322 #if ! defined yyoverflow || YYERROR_VERBOSE
323
324 /* The parser invokes alloca or malloc; define the necessary symbols.  */
325
326 # ifdef YYSTACK_USE_ALLOCA
327 #  if YYSTACK_USE_ALLOCA
328 #   ifdef __GNUC__
329 #    define YYSTACK_ALLOC __builtin_alloca
330 #   elif defined __BUILTIN_VA_ARG_INCR
331 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
332 #   elif defined _AIX
333 #    define YYSTACK_ALLOC __alloca
334 #   elif defined _MSC_VER
335 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
336 #    define alloca _alloca
337 #   else
338 #    define YYSTACK_ALLOC alloca
339 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
340 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
341       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
342 #     ifndef EXIT_SUCCESS
343 #      define EXIT_SUCCESS 0
344 #     endif
345 #    endif
346 #   endif
347 #  endif
348 # endif
349
350 # ifdef YYSTACK_ALLOC
351    /* Pacify GCC's 'empty if-body' warning.  */
352 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
353 #  ifndef YYSTACK_ALLOC_MAXIMUM
354     /* The OS might guarantee only one guard page at the bottom of the stack,
355        and a page size can be as small as 4096 bytes.  So we cannot safely
356        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
357        to allow for a few compiler-allocated temporary stack slots.  */
358 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
359 #  endif
360 # else
361 #  define YYSTACK_ALLOC YYMALLOC
362 #  define YYSTACK_FREE YYFREE
363 #  ifndef YYSTACK_ALLOC_MAXIMUM
364 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
365 #  endif
366 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
367        && ! ((defined YYMALLOC || defined malloc) \
368              && (defined YYFREE || defined free)))
369 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
370 #   ifndef EXIT_SUCCESS
371 #    define EXIT_SUCCESS 0
372 #   endif
373 #  endif
374 #  ifndef YYMALLOC
375 #   define YYMALLOC malloc
376 #   if ! defined malloc && ! defined EXIT_SUCCESS
377 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
378 #   endif
379 #  endif
380 #  ifndef YYFREE
381 #   define YYFREE free
382 #   if ! defined free && ! defined EXIT_SUCCESS
383 void free (void *); /* INFRINGES ON USER NAME SPACE */
384 #   endif
385 #  endif
386 # endif
387 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
388
389
390 #if (! defined yyoverflow \
391      && (! defined __cplusplus \
392          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
393
394 /* A type that is properly aligned for any stack member.  */
395 union yyalloc
396 {
397   yytype_int16 yyss_alloc;
398   YYSTYPE yyvs_alloc;
399 };
400
401 /* The size of the maximum gap between one aligned stack and the next.  */
402 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
403
404 /* The size of an array large to enough to hold all stacks, each with
405    N elements.  */
406 # define YYSTACK_BYTES(N) \
407      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
408       + YYSTACK_GAP_MAXIMUM)
409
410 # define YYCOPY_NEEDED 1
411
412 /* Relocate STACK from its old location to the new one.  The
413    local variables YYSIZE and YYSTACKSIZE give the old and new number of
414    elements in the stack, and YYPTR gives the new location of the
415    stack.  Advance YYPTR to a properly aligned location for the next
416    stack.  */
417 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
418     do                                                                  \
419       {                                                                 \
420         YYSIZE_T yynewbytes;                                            \
421         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
422         Stack = &yyptr->Stack_alloc;                                    \
423         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
424         yyptr += yynewbytes / sizeof (*yyptr);                          \
425       }                                                                 \
426     while (0)
427
428 #endif
429
430 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
431 /* Copy COUNT objects from SRC to DST.  The source and destination do
432    not overlap.  */
433 # ifndef YYCOPY
434 #  if defined __GNUC__ && 1 < __GNUC__
435 #   define YYCOPY(Dst, Src, Count) \
436       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
437 #  else
438 #   define YYCOPY(Dst, Src, Count)              \
439       do                                        \
440         {                                       \
441           YYSIZE_T yyi;                         \
442           for (yyi = 0; yyi < (Count); yyi++)   \
443             (Dst)[yyi] = (Src)[yyi];            \
444         }                                       \
445       while (0)
446 #  endif
447 # endif
448 #endif /* !YYCOPY_NEEDED */
449
450 /* YYFINAL -- State number of the termination state.  */
451 #define YYFINAL  3
452 /* YYLAST -- Last index in YYTABLE.  */
453 #define YYLAST   114
454
455 /* YYNTOKENS -- Number of terminals.  */
456 #define YYNTOKENS  26
457 /* YYNNTS -- Number of nonterminals.  */
458 #define YYNNTS  29
459 /* YYNRULES -- Number of rules.  */
460 #define YYNRULES  82
461 /* YYNSTATES -- Number of states.  */
462 #define YYNSTATES  125
463
464 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
465    by yylex, with out-of-bounds checking.  */
466 #define YYUNDEFTOK  2
467 #define YYMAXUTOK   275
468
469 #define YYTRANSLATE(YYX)                                                \
470   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
471
472 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
473    as returned by yylex, without out-of-bounds checking.  */
474 static const yytype_uint8 yytranslate[] =
475 {
476        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
477        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
478        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
479        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
480       22,    23,     2,    25,     2,     2,     2,     2,     2,     2,
481        2,     2,     2,     2,     2,     2,     2,     2,    24,     2,
482        2,    21,     2,     2,     2,     2,     2,     2,     2,     2,
483        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
484        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
485        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
486        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
487        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
488        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
489        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
490        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
491        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
492        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
493        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
494        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
495        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
496        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
497        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
498        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
499        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
500        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
501        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
502        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
503       15,    16,    17,    18,    19,    20
504 };
505
506 #if YYDEBUG
507   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
508 static const yytype_uint16 yyrline[] =
509 {
510        0,    66,    66,    69,    71,    73,    74,    75,    80,    84,
511       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
512       95,    96,   102,   106,   110,   117,   118,   119,   123,   127,
513      128,   132,   133,   134,   138,   142,   143,   147,   148,   149,
514      153,   157,   158,   159,   160,   165,   168,   172,   177,   176,
515      189,   190,   191,   195,   198,   202,   206,   211,   218,   224,
516      230,   238,   246,   254,   261,   262,   266,   276,   280,   292,
517      293,   296,   297,   311,   315,   320,   325,   330,   337,   338,
518      342,   346,   350
519 };
520 #endif
521
522 #if YYDEBUG || YYERROR_VERBOSE || 0
523 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
524    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
525 static const char *const yytname[] =
526 {
527   "$end", "error", "$undefined", "NL", "MCIDENT", "MCFILENAME", "MCLINE",
528   "MCCOMMENT", "MCTOKEN", "MCENDLINE", "MCLANGUAGENAMES",
529   "MCFACILITYNAMES", "MCSEVERITYNAMES", "MCOUTPUTBASE",
530   "MCMESSAGEIDTYPEDEF", "MCLANGUAGE", "MCMESSAGEID", "MCSEVERITY",
531   "MCFACILITY", "MCSYMBOLICNAME", "MCNUMBER", "'='", "'('", "')'", "':'",
532   "'+'", "$accept", "input", "entities", "entity", "global_section",
533   "severitymaps", "severitymap", "facilitymaps", "facilitymap", "langmaps",
534   "langmap", "alias_name", "message", "$@1", "id", "vid", "sefasy_def",
535   "severity", "facility", "symbol", "lang_entities", "lang_entity",
536   "lines", "comments", "lang", "token", "lex_want_nl", "lex_want_line",
537   "lex_want_filename", YY_NULLPTR
538 };
539 #endif
540
541 # ifdef YYPRINT
542 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
543    (internal) symbol number NUM (which must be that of a token).  */
544 static const yytype_uint16 yytoknum[] =
545 {
546        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
547      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
548      275,    61,    40,    41,    58,    43
549 };
550 # endif
551
552 #define YYPACT_NINF -34
553
554 #define yypact_value_is_default(Yystate) \
555   (!!((Yystate) == (-34)))
556
557 #define YYTABLE_NINF -83
558
559 #define yytable_value_is_error(Yytable_value) \
560   0
561
562   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
563      STATE-NUM.  */
564 static const yytype_int8 yypact[] =
565 {
566      -34,    62,    70,   -34,   -34,   -34,    15,    22,    30,   -15,
567       34,    37,   -34,   -34,   -34,   -34,    56,   -34,    10,   -34,
568       12,   -34,    20,    25,   -34,    52,   -34,     0,    80,   -34,
569      -34,    71,   -34,    84,   -34,    86,   -34,   -34,   -34,   -34,
570      -34,    45,   -34,     1,    68,    74,    76,   -34,   -34,   -34,
571      -34,   -34,   -34,     4,   -34,    38,   -34,     6,   -34,    39,
572      -34,    29,   -34,    40,   -34,   -34,    93,    94,    99,    43,
573       76,   -34,   -34,   -34,   -34,   -34,   -34,    46,   -34,   -34,
574      -34,   -34,    47,   -34,   -34,   -34,   -34,    49,   -34,   -34,
575      -34,   -34,    83,   -34,     3,   -34,     2,   -34,    81,   -34,
576       81,    92,   -34,   -34,    48,   -34,    82,    72,   -34,   -34,
577      -34,   104,   105,   108,   -34,   -34,   -34,    73,   -34,   -34,
578      -34,   -34,   -34,   -34,   -34
579 };
580
581   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
582      Performed when YYTABLE does not specify something else to do.  Zero
583      means the default is an error.  */
584 static const yytype_uint8 yydefact[] =
585 {
586        3,     0,     0,     1,     8,    71,     0,     0,     0,     0,
587        0,     0,     4,     5,     6,    57,     7,    16,     0,    20,
588        0,    12,     0,     0,    24,     0,    52,     0,    48,    72,
589       15,     0,    19,     0,    11,     0,    21,    23,    22,    51,
590       54,     0,    50,     0,     0,     0,     0,    58,    59,    60,
591       39,    78,    79,     0,    37,     0,    33,     0,    31,     0,
592       27,     0,    25,     0,    56,    55,     0,     0,     0,     0,
593       49,    64,    81,    14,    13,    38,    44,     0,    18,    17,
594       32,    36,     0,    10,     9,    26,    30,     0,    61,    62,
595       63,    77,     0,    65,     0,    43,     0,    35,    45,    29,
596       45,     0,    69,    67,     0,    42,     0,     0,    34,    28,
597       76,    78,    79,     0,    70,    68,    66,     0,    47,    46,
598       74,    73,    75,    41,    40
599 };
600
601   /* YYPGOTO[NTERM-NUM].  */
602 static const yytype_int8 yypgoto[] =
603 {
604      -34,   -34,   -34,   -34,   -34,   -34,    50,   -34,    53,   -34,
605       59,    13,   -34,   -34,   -34,   -34,   -34,   -34,   -34,   -34,
606      -34,    44,   -34,   -34,   -34,   -33,   -34,   -34,   -34
607 };
608
609   /* YYDEFGOTO[NTERM-NUM].  */
610 static const yytype_int8 yydefgoto[] =
611 {
612       -1,     1,     2,    12,    13,    61,    62,    57,    58,    53,
613       54,   108,    14,    46,    15,    42,    28,    47,    48,    49,
614       70,    71,   104,    16,    72,    55,    92,    94,   106
615 };
616
617   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
618      positive, shift that token.  If negative, reduce the rule whose
619      number is the opposite.  If YYTABLE_NINF, syntax error.  */
620 static const yytype_int8 yytable[] =
621 {
622       59,    39,    63,   105,   102,    73,    23,    78,    51,   103,
623       51,    30,    52,    32,    52,   -53,    17,   -53,   -53,   -53,
624       40,    34,    66,    19,    59,    41,   -82,    74,    63,    79,
625       83,    21,    31,    51,    33,    24,    18,    52,    26,    76,
626       81,    86,    35,    20,    91,    36,    64,    95,    97,   114,
627       99,    22,    84,    37,   115,    25,    38,   116,    27,    77,
628       82,    87,     3,    29,   -80,    65,    96,    98,   113,   100,
629       -2,     4,    50,   118,   123,    51,   119,     5,   124,    52,
630        6,     7,     8,     9,    10,    56,    11,    60,    51,    67,
631       51,    69,    52,   110,    52,    68,   111,    43,    44,    45,
632      112,    88,    89,    90,   101,   107,   117,   120,   121,   122,
633       80,    85,    75,   109,    93
634 };
635
636 static const yytype_uint8 yycheck[] =
637 {
638       33,     1,    35,     1,     1,     1,    21,     1,     4,     6,
639        4,     1,     8,     1,     8,    15,     1,    17,    18,    19,
640       20,     1,    21,     1,    57,    25,    24,    23,    61,    23,
641        1,     1,    22,     4,    22,     1,    21,     8,     1,     1,
642        1,     1,    22,    21,     1,    20,     1,     1,     1,     1,
643        1,    21,    23,     1,     6,    21,     4,     9,    21,    21,
644       21,    21,     0,     7,    21,    20,    20,    20,   101,    20,
645        0,     1,     1,     1,     1,     4,     4,     7,     5,     8,
646       10,    11,    12,    13,    14,     1,    16,     1,     4,    21,
647        4,    15,     8,     1,     8,    21,     4,    17,    18,    19,
648        8,     8,     8,     4,    21,    24,    24,     3,     3,     1,
649       57,    61,    53,   100,    70
650 };
651
652   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
653      symbol of state STATE-NUM.  */
654 static const yytype_uint8 yystos[] =
655 {
656        0,    27,    28,     0,     1,     7,    10,    11,    12,    13,
657       14,    16,    29,    30,    38,    40,    49,     1,    21,     1,
658       21,     1,    21,    21,     1,    21,     1,    21,    42,     7,
659        1,    22,     1,    22,     1,    22,    20,     1,     4,     1,
660       20,    25,    41,    17,    18,    19,    39,    43,    44,    45,
661        1,     4,     8,    35,    36,    51,     1,    33,    34,    51,
662        1,    31,    32,    51,     1,    20,    21,    21,    21,    15,
663       46,    47,    50,     1,    23,    36,     1,    21,     1,    23,
664       34,     1,    21,     1,    23,    32,     1,    21,     8,     8,
665        4,     1,    52,    47,    53,     1,    20,     1,    20,     1,
666       20,    21,     1,     6,    48,     1,    54,    24,    37,    37,
667        1,     4,     8,    51,     1,     6,     9,    24,     1,     4,
668        3,     3,     1,     1,     5
669 };
670
671   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
672 static const yytype_uint8 yyr1[] =
673 {
674        0,    26,    27,    28,    28,    29,    29,    29,    29,    30,
675       30,    30,    30,    30,    30,    30,    30,    30,    30,    30,
676       30,    30,    30,    30,    30,    31,    31,    31,    32,    32,
677       32,    33,    33,    33,    34,    34,    34,    35,    35,    35,
678       36,    36,    36,    36,    36,    37,    37,    37,    39,    38,
679       40,    40,    40,    41,    41,    41,    41,    42,    42,    42,
680       42,    43,    44,    45,    46,    46,    47,    48,    48,    48,
681       48,    49,    49,    50,    50,    50,    50,    50,    51,    51,
682       52,    53,    54
683 };
684
685   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
686 static const yytype_uint8 yyr2[] =
687 {
688        0,     2,     1,     0,     2,     1,     1,     1,     1,     5,
689        5,     3,     2,     5,     5,     3,     2,     5,     5,     3,
690        2,     3,     3,     3,     2,     1,     2,     1,     4,     3,
691        2,     1,     2,     1,     4,     3,     2,     1,     2,     1,
692        6,     6,     4,     3,     2,     0,     2,     2,     0,     4,
693        3,     3,     2,     0,     1,     2,     2,     0,     2,     2,
694        2,     3,     3,     3,     1,     2,     4,     1,     2,     1,
695        2,     1,     2,     5,     5,     5,     4,     2,     1,     1,
696        0,     0,     0
697 };
698
699
700 #define yyerrok         (yyerrstatus = 0)
701 #define yyclearin       (yychar = YYEMPTY)
702 #define YYEMPTY         (-2)
703 #define YYEOF           0
704
705 #define YYACCEPT        goto yyacceptlab
706 #define YYABORT         goto yyabortlab
707 #define YYERROR         goto yyerrorlab
708
709
710 #define YYRECOVERING()  (!!yyerrstatus)
711
712 #define YYBACKUP(Token, Value)                                  \
713 do                                                              \
714   if (yychar == YYEMPTY)                                        \
715     {                                                           \
716       yychar = (Token);                                         \
717       yylval = (Value);                                         \
718       YYPOPSTACK (yylen);                                       \
719       yystate = *yyssp;                                         \
720       goto yybackup;                                            \
721     }                                                           \
722   else                                                          \
723     {                                                           \
724       yyerror (YY_("syntax error: cannot back up")); \
725       YYERROR;                                                  \
726     }                                                           \
727 while (0)
728
729 /* Error token number */
730 #define YYTERROR        1
731 #define YYERRCODE       256
732
733
734
735 /* Enable debugging if requested.  */
736 #if YYDEBUG
737
738 # ifndef YYFPRINTF
739 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
740 #  define YYFPRINTF fprintf
741 # endif
742
743 # define YYDPRINTF(Args)                        \
744 do {                                            \
745   if (yydebug)                                  \
746     YYFPRINTF Args;                             \
747 } while (0)
748
749 /* This macro is provided for backward compatibility. */
750 #ifndef YY_LOCATION_PRINT
751 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
752 #endif
753
754
755 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
756 do {                                                                      \
757   if (yydebug)                                                            \
758     {                                                                     \
759       YYFPRINTF (stderr, "%s ", Title);                                   \
760       yy_symbol_print (stderr,                                            \
761                   Type, Value); \
762       YYFPRINTF (stderr, "\n");                                           \
763     }                                                                     \
764 } while (0)
765
766
767 /*----------------------------------------.
768 | Print this symbol's value on YYOUTPUT.  |
769 `----------------------------------------*/
770
771 static void
772 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
773 {
774   FILE *yyo = yyoutput;
775   YYUSE (yyo);
776   if (!yyvaluep)
777     return;
778 # ifdef YYPRINT
779   if (yytype < YYNTOKENS)
780     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
781 # endif
782   YYUSE (yytype);
783 }
784
785
786 /*--------------------------------.
787 | Print this symbol on YYOUTPUT.  |
788 `--------------------------------*/
789
790 static void
791 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
792 {
793   YYFPRINTF (yyoutput, "%s %s (",
794              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
795
796   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
797   YYFPRINTF (yyoutput, ")");
798 }
799
800 /*------------------------------------------------------------------.
801 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
802 | TOP (included).                                                   |
803 `------------------------------------------------------------------*/
804
805 static void
806 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
807 {
808   YYFPRINTF (stderr, "Stack now");
809   for (; yybottom <= yytop; yybottom++)
810     {
811       int yybot = *yybottom;
812       YYFPRINTF (stderr, " %d", yybot);
813     }
814   YYFPRINTF (stderr, "\n");
815 }
816
817 # define YY_STACK_PRINT(Bottom, Top)                            \
818 do {                                                            \
819   if (yydebug)                                                  \
820     yy_stack_print ((Bottom), (Top));                           \
821 } while (0)
822
823
824 /*------------------------------------------------.
825 | Report that the YYRULE is going to be reduced.  |
826 `------------------------------------------------*/
827
828 static void
829 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
830 {
831   unsigned long int yylno = yyrline[yyrule];
832   int yynrhs = yyr2[yyrule];
833   int yyi;
834   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
835              yyrule - 1, yylno);
836   /* The symbols being reduced.  */
837   for (yyi = 0; yyi < yynrhs; yyi++)
838     {
839       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
840       yy_symbol_print (stderr,
841                        yystos[yyssp[yyi + 1 - yynrhs]],
842                        &(yyvsp[(yyi + 1) - (yynrhs)])
843                                               );
844       YYFPRINTF (stderr, "\n");
845     }
846 }
847
848 # define YY_REDUCE_PRINT(Rule)          \
849 do {                                    \
850   if (yydebug)                          \
851     yy_reduce_print (yyssp, yyvsp, Rule); \
852 } while (0)
853
854 /* Nonzero means print parse trace.  It is left uninitialized so that
855    multiple parsers can coexist.  */
856 int yydebug;
857 #else /* !YYDEBUG */
858 # define YYDPRINTF(Args)
859 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
860 # define YY_STACK_PRINT(Bottom, Top)
861 # define YY_REDUCE_PRINT(Rule)
862 #endif /* !YYDEBUG */
863
864
865 /* YYINITDEPTH -- initial size of the parser's stacks.  */
866 #ifndef YYINITDEPTH
867 # define YYINITDEPTH 200
868 #endif
869
870 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
871    if the built-in stack extension method is used).
872
873    Do not make this value too large; the results are undefined if
874    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
875    evaluated with infinite-precision integer arithmetic.  */
876
877 #ifndef YYMAXDEPTH
878 # define YYMAXDEPTH 10000
879 #endif
880
881
882 #if YYERROR_VERBOSE
883
884 # ifndef yystrlen
885 #  if defined __GLIBC__ && defined _STRING_H
886 #   define yystrlen strlen
887 #  else
888 /* Return the length of YYSTR.  */
889 static YYSIZE_T
890 yystrlen (const char *yystr)
891 {
892   YYSIZE_T yylen;
893   for (yylen = 0; yystr[yylen]; yylen++)
894     continue;
895   return yylen;
896 }
897 #  endif
898 # endif
899
900 # ifndef yystpcpy
901 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
902 #   define yystpcpy stpcpy
903 #  else
904 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
905    YYDEST.  */
906 static char *
907 yystpcpy (char *yydest, const char *yysrc)
908 {
909   char *yyd = yydest;
910   const char *yys = yysrc;
911
912   while ((*yyd++ = *yys++) != '\0')
913     continue;
914
915   return yyd - 1;
916 }
917 #  endif
918 # endif
919
920 # ifndef yytnamerr
921 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
922    quotes and backslashes, so that it's suitable for yyerror.  The
923    heuristic is that double-quoting is unnecessary unless the string
924    contains an apostrophe, a comma, or backslash (other than
925    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
926    null, do not copy; instead, return the length of what the result
927    would have been.  */
928 static YYSIZE_T
929 yytnamerr (char *yyres, const char *yystr)
930 {
931   if (*yystr == '"')
932     {
933       YYSIZE_T yyn = 0;
934       char const *yyp = yystr;
935
936       for (;;)
937         switch (*++yyp)
938           {
939           case '\'':
940           case ',':
941             goto do_not_strip_quotes;
942
943           case '\\':
944             if (*++yyp != '\\')
945               goto do_not_strip_quotes;
946             /* Fall through.  */
947           default:
948             if (yyres)
949               yyres[yyn] = *yyp;
950             yyn++;
951             break;
952
953           case '"':
954             if (yyres)
955               yyres[yyn] = '\0';
956             return yyn;
957           }
958     do_not_strip_quotes: ;
959     }
960
961   if (! yyres)
962     return yystrlen (yystr);
963
964   return yystpcpy (yyres, yystr) - yyres;
965 }
966 # endif
967
968 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
969    about the unexpected token YYTOKEN for the state stack whose top is
970    YYSSP.
971
972    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
973    not large enough to hold the message.  In that case, also set
974    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
975    required number of bytes is too large to store.  */
976 static int
977 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
978                 yytype_int16 *yyssp, int yytoken)
979 {
980   YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
981   YYSIZE_T yysize = yysize0;
982   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
983   /* Internationalized format string. */
984   const char *yyformat = YY_NULLPTR;
985   /* Arguments of yyformat. */
986   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
987   /* Number of reported tokens (one for the "unexpected", one per
988      "expected"). */
989   int yycount = 0;
990
991   /* There are many possibilities here to consider:
992      - If this state is a consistent state with a default action, then
993        the only way this function was invoked is if the default action
994        is an error action.  In that case, don't check for expected
995        tokens because there are none.
996      - The only way there can be no lookahead present (in yychar) is if
997        this state is a consistent state with a default action.  Thus,
998        detecting the absence of a lookahead is sufficient to determine
999        that there is no unexpected or expected token to report.  In that
1000        case, just report a simple "syntax error".
1001      - Don't assume there isn't a lookahead just because this state is a
1002        consistent state with a default action.  There might have been a
1003        previous inconsistent state, consistent state with a non-default
1004        action, or user semantic action that manipulated yychar.
1005      - Of course, the expected token list depends on states to have
1006        correct lookahead information, and it depends on the parser not
1007        to perform extra reductions after fetching a lookahead from the
1008        scanner and before detecting a syntax error.  Thus, state merging
1009        (from LALR or IELR) and default reductions corrupt the expected
1010        token list.  However, the list is correct for canonical LR with
1011        one exception: it will still contain any token that will not be
1012        accepted due to an error action in a later state.
1013   */
1014   if (yytoken != YYEMPTY)
1015     {
1016       int yyn = yypact[*yyssp];
1017       yyarg[yycount++] = yytname[yytoken];
1018       if (!yypact_value_is_default (yyn))
1019         {
1020           /* Start YYX at -YYN if negative to avoid negative indexes in
1021              YYCHECK.  In other words, skip the first -YYN actions for
1022              this state because they are default actions.  */
1023           int yyxbegin = yyn < 0 ? -yyn : 0;
1024           /* Stay within bounds of both yycheck and yytname.  */
1025           int yychecklim = YYLAST - yyn + 1;
1026           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1027           int yyx;
1028
1029           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1030             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1031                 && !yytable_value_is_error (yytable[yyx + yyn]))
1032               {
1033                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1034                   {
1035                     yycount = 1;
1036                     yysize = yysize0;
1037                     break;
1038                   }
1039                 yyarg[yycount++] = yytname[yyx];
1040                 {
1041                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1042                   if (! (yysize <= yysize1
1043                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1044                     return 2;
1045                   yysize = yysize1;
1046                 }
1047               }
1048         }
1049     }
1050
1051   switch (yycount)
1052     {
1053 # define YYCASE_(N, S)                      \
1054       case N:                               \
1055         yyformat = S;                       \
1056       break
1057     default: /* Avoid compiler warnings. */
1058       YYCASE_(0, YY_("syntax error"));
1059       YYCASE_(1, YY_("syntax error, unexpected %s"));
1060       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1061       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1062       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1063       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1064 # undef YYCASE_
1065     }
1066
1067   {
1068     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1069     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1070       return 2;
1071     yysize = yysize1;
1072   }
1073
1074   if (*yymsg_alloc < yysize)
1075     {
1076       *yymsg_alloc = 2 * yysize;
1077       if (! (yysize <= *yymsg_alloc
1078              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1079         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1080       return 1;
1081     }
1082
1083   /* Avoid sprintf, as that infringes on the user's name space.
1084      Don't have undefined behavior even if the translation
1085      produced a string with the wrong number of "%s"s.  */
1086   {
1087     char *yyp = *yymsg;
1088     int yyi = 0;
1089     while ((*yyp = *yyformat) != '\0')
1090       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1091         {
1092           yyp += yytnamerr (yyp, yyarg[yyi++]);
1093           yyformat += 2;
1094         }
1095       else
1096         {
1097           yyp++;
1098           yyformat++;
1099         }
1100   }
1101   return 0;
1102 }
1103 #endif /* YYERROR_VERBOSE */
1104
1105 /*-----------------------------------------------.
1106 | Release the memory associated to this symbol.  |
1107 `-----------------------------------------------*/
1108
1109 static void
1110 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1111 {
1112   YYUSE (yyvaluep);
1113   if (!yymsg)
1114     yymsg = "Deleting";
1115   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1116
1117   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1118   YYUSE (yytype);
1119   YY_IGNORE_MAYBE_UNINITIALIZED_END
1120 }
1121
1122
1123
1124
1125 /* The lookahead symbol.  */
1126 int yychar;
1127
1128 /* The semantic value of the lookahead symbol.  */
1129 YYSTYPE yylval;
1130 /* Number of syntax errors so far.  */
1131 int yynerrs;
1132
1133
1134 /*----------.
1135 | yyparse.  |
1136 `----------*/
1137
1138 int
1139 yyparse (void)
1140 {
1141     int yystate;
1142     /* Number of tokens to shift before error messages enabled.  */
1143     int yyerrstatus;
1144
1145     /* The stacks and their tools:
1146        'yyss': related to states.
1147        'yyvs': related to semantic values.
1148
1149        Refer to the stacks through separate pointers, to allow yyoverflow
1150        to reallocate them elsewhere.  */
1151
1152     /* The state stack.  */
1153     yytype_int16 yyssa[YYINITDEPTH];
1154     yytype_int16 *yyss;
1155     yytype_int16 *yyssp;
1156
1157     /* The semantic value stack.  */
1158     YYSTYPE yyvsa[YYINITDEPTH];
1159     YYSTYPE *yyvs;
1160     YYSTYPE *yyvsp;
1161
1162     YYSIZE_T yystacksize;
1163
1164   int yyn;
1165   int yyresult;
1166   /* Lookahead token as an internal (translated) token number.  */
1167   int yytoken = 0;
1168   /* The variables used to return semantic value and location from the
1169      action routines.  */
1170   YYSTYPE yyval;
1171
1172 #if YYERROR_VERBOSE
1173   /* Buffer for error messages, and its allocated size.  */
1174   char yymsgbuf[128];
1175   char *yymsg = yymsgbuf;
1176   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1177 #endif
1178
1179 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1180
1181   /* The number of symbols on the RHS of the reduced rule.
1182      Keep to zero when no symbol should be popped.  */
1183   int yylen = 0;
1184
1185   yyssp = yyss = yyssa;
1186   yyvsp = yyvs = yyvsa;
1187   yystacksize = YYINITDEPTH;
1188
1189   YYDPRINTF ((stderr, "Starting parse\n"));
1190
1191   yystate = 0;
1192   yyerrstatus = 0;
1193   yynerrs = 0;
1194   yychar = YYEMPTY; /* Cause a token to be read.  */
1195   goto yysetstate;
1196
1197 /*------------------------------------------------------------.
1198 | yynewstate -- Push a new state, which is found in yystate.  |
1199 `------------------------------------------------------------*/
1200  yynewstate:
1201   /* In all cases, when you get here, the value and location stacks
1202      have just been pushed.  So pushing a state here evens the stacks.  */
1203   yyssp++;
1204
1205  yysetstate:
1206   *yyssp = yystate;
1207
1208   if (yyss + yystacksize - 1 <= yyssp)
1209     {
1210       /* Get the current used size of the three stacks, in elements.  */
1211       YYSIZE_T yysize = yyssp - yyss + 1;
1212
1213 #ifdef yyoverflow
1214       {
1215         /* Give user a chance to reallocate the stack.  Use copies of
1216            these so that the &'s don't force the real ones into
1217            memory.  */
1218         YYSTYPE *yyvs1 = yyvs;
1219         yytype_int16 *yyss1 = yyss;
1220
1221         /* Each stack pointer address is followed by the size of the
1222            data in use in that stack, in bytes.  This used to be a
1223            conditional around just the two extra args, but that might
1224            be undefined if yyoverflow is a macro.  */
1225         yyoverflow (YY_("memory exhausted"),
1226                     &yyss1, yysize * sizeof (*yyssp),
1227                     &yyvs1, yysize * sizeof (*yyvsp),
1228                     &yystacksize);
1229
1230         yyss = yyss1;
1231         yyvs = yyvs1;
1232       }
1233 #else /* no yyoverflow */
1234 # ifndef YYSTACK_RELOCATE
1235       goto yyexhaustedlab;
1236 # else
1237       /* Extend the stack our own way.  */
1238       if (YYMAXDEPTH <= yystacksize)
1239         goto yyexhaustedlab;
1240       yystacksize *= 2;
1241       if (YYMAXDEPTH < yystacksize)
1242         yystacksize = YYMAXDEPTH;
1243
1244       {
1245         yytype_int16 *yyss1 = yyss;
1246         union yyalloc *yyptr =
1247           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1248         if (! yyptr)
1249           goto yyexhaustedlab;
1250         YYSTACK_RELOCATE (yyss_alloc, yyss);
1251         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1252 #  undef YYSTACK_RELOCATE
1253         if (yyss1 != yyssa)
1254           YYSTACK_FREE (yyss1);
1255       }
1256 # endif
1257 #endif /* no yyoverflow */
1258
1259       yyssp = yyss + yysize - 1;
1260       yyvsp = yyvs + yysize - 1;
1261
1262       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1263                   (unsigned long int) yystacksize));
1264
1265       if (yyss + yystacksize - 1 <= yyssp)
1266         YYABORT;
1267     }
1268
1269   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1270
1271   if (yystate == YYFINAL)
1272     YYACCEPT;
1273
1274   goto yybackup;
1275
1276 /*-----------.
1277 | yybackup.  |
1278 `-----------*/
1279 yybackup:
1280
1281   /* Do appropriate processing given the current state.  Read a
1282      lookahead token if we need one and don't already have one.  */
1283
1284   /* First try to decide what to do without reference to lookahead token.  */
1285   yyn = yypact[yystate];
1286   if (yypact_value_is_default (yyn))
1287     goto yydefault;
1288
1289   /* Not known => get a lookahead token if don't already have one.  */
1290
1291   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1292   if (yychar == YYEMPTY)
1293     {
1294       YYDPRINTF ((stderr, "Reading a token: "));
1295       yychar = yylex ();
1296     }
1297
1298   if (yychar <= YYEOF)
1299     {
1300       yychar = yytoken = YYEOF;
1301       YYDPRINTF ((stderr, "Now at end of input.\n"));
1302     }
1303   else
1304     {
1305       yytoken = YYTRANSLATE (yychar);
1306       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1307     }
1308
1309   /* If the proper action on seeing token YYTOKEN is to reduce or to
1310      detect an error, take that action.  */
1311   yyn += yytoken;
1312   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1313     goto yydefault;
1314   yyn = yytable[yyn];
1315   if (yyn <= 0)
1316     {
1317       if (yytable_value_is_error (yyn))
1318         goto yyerrlab;
1319       yyn = -yyn;
1320       goto yyreduce;
1321     }
1322
1323   /* Count tokens shifted since error; after three, turn off error
1324      status.  */
1325   if (yyerrstatus)
1326     yyerrstatus--;
1327
1328   /* Shift the lookahead token.  */
1329   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1330
1331   /* Discard the shifted token.  */
1332   yychar = YYEMPTY;
1333
1334   yystate = yyn;
1335   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1336   *++yyvsp = yylval;
1337   YY_IGNORE_MAYBE_UNINITIALIZED_END
1338
1339   goto yynewstate;
1340
1341
1342 /*-----------------------------------------------------------.
1343 | yydefault -- do the default action for the current state.  |
1344 `-----------------------------------------------------------*/
1345 yydefault:
1346   yyn = yydefact[yystate];
1347   if (yyn == 0)
1348     goto yyerrlab;
1349   goto yyreduce;
1350
1351
1352 /*-----------------------------.
1353 | yyreduce -- Do a reduction.  |
1354 `-----------------------------*/
1355 yyreduce:
1356   /* yyn is the number of a rule to reduce with.  */
1357   yylen = yyr2[yyn];
1358
1359   /* If YYLEN is nonzero, implement the default value of the action:
1360      '$$ = $1'.
1361
1362      Otherwise, the following line sets YYVAL to garbage.
1363      This behavior is undocumented and Bison
1364      users should not rely upon it.  Assigning to YYVAL
1365      unconditionally makes the parser a bit smaller, and it avoids a
1366      GCC warning that YYVAL may be used uninitialized.  */
1367   yyval = yyvsp[1-yylen];
1368
1369
1370   YY_REDUCE_PRINT (yyn);
1371   switch (yyn)
1372     {
1373         case 7:
1374 #line 76 "mcparse.y" /* yacc.c:1648  */
1375     {
1376             cur_node = mc_add_node ();
1377             cur_node->user_text = (yyvsp[0].ustr);
1378           }
1379 #line 1380 "mcparse.c" /* yacc.c:1648  */
1380     break;
1381
1382   case 8:
1383 #line 80 "mcparse.y" /* yacc.c:1648  */
1384     { mc_fatal ("syntax error"); }
1385 #line 1386 "mcparse.c" /* yacc.c:1648  */
1386     break;
1387
1388   case 10:
1389 #line 85 "mcparse.y" /* yacc.c:1648  */
1390     { mc_fatal ("missing ')' in SeverityNames"); }
1391 #line 1392 "mcparse.c" /* yacc.c:1648  */
1392     break;
1393
1394   case 11:
1395 #line 86 "mcparse.y" /* yacc.c:1648  */
1396     { mc_fatal ("missing '(' in SeverityNames"); }
1397 #line 1398 "mcparse.c" /* yacc.c:1648  */
1398     break;
1399
1400   case 12:
1401 #line 87 "mcparse.y" /* yacc.c:1648  */
1402     { mc_fatal ("missing '=' for SeverityNames"); }
1403 #line 1404 "mcparse.c" /* yacc.c:1648  */
1404     break;
1405
1406   case 14:
1407 #line 89 "mcparse.y" /* yacc.c:1648  */
1408     { mc_fatal ("missing ')' in LanguageNames"); }
1409 #line 1410 "mcparse.c" /* yacc.c:1648  */
1410     break;
1411
1412   case 15:
1413 #line 90 "mcparse.y" /* yacc.c:1648  */
1414     { mc_fatal ("missing '(' in LanguageNames"); }
1415 #line 1416 "mcparse.c" /* yacc.c:1648  */
1416     break;
1417
1418   case 16:
1419 #line 91 "mcparse.y" /* yacc.c:1648  */
1420     { mc_fatal ("missing '=' for LanguageNames"); }
1421 #line 1422 "mcparse.c" /* yacc.c:1648  */
1422     break;
1423
1424   case 18:
1425 #line 93 "mcparse.y" /* yacc.c:1648  */
1426     { mc_fatal ("missing ')' in FacilityNames"); }
1427 #line 1428 "mcparse.c" /* yacc.c:1648  */
1428     break;
1429
1430   case 19:
1431 #line 94 "mcparse.y" /* yacc.c:1648  */
1432     { mc_fatal ("missing '(' in FacilityNames"); }
1433 #line 1434 "mcparse.c" /* yacc.c:1648  */
1434     break;
1435
1436   case 20:
1437 #line 95 "mcparse.y" /* yacc.c:1648  */
1438     { mc_fatal ("missing '=' for FacilityNames"); }
1439 #line 1440 "mcparse.c" /* yacc.c:1648  */
1440     break;
1441
1442   case 21:
1443 #line 97 "mcparse.y" /* yacc.c:1648  */
1444     {
1445             if ((yyvsp[0].ival) != 10 && (yyvsp[0].ival) != 16)
1446               mc_fatal ("OutputBase allows 10 or 16 as value");
1447             mcset_out_values_are_decimal = ((yyvsp[0].ival) == 10 ? 1 : 0);
1448           }
1449 #line 1450 "mcparse.c" /* yacc.c:1648  */
1450     break;
1451
1452   case 22:
1453 #line 103 "mcparse.y" /* yacc.c:1648  */
1454     {
1455             mcset_msg_id_typedef = (yyvsp[0].ustr);
1456           }
1457 #line 1458 "mcparse.c" /* yacc.c:1648  */
1458     break;
1459
1460   case 23:
1461 #line 107 "mcparse.y" /* yacc.c:1648  */
1462     {
1463             mc_fatal ("MessageIdTypedef expects an identifier");
1464           }
1465 #line 1466 "mcparse.c" /* yacc.c:1648  */
1466     break;
1467
1468   case 24:
1469 #line 111 "mcparse.y" /* yacc.c:1648  */
1470     {
1471             mc_fatal ("missing '=' for MessageIdTypedef");
1472           }
1473 #line 1474 "mcparse.c" /* yacc.c:1648  */
1474     break;
1475
1476   case 27:
1477 #line 119 "mcparse.y" /* yacc.c:1648  */
1478     { mc_fatal ("severity ident missing"); }
1479 #line 1480 "mcparse.c" /* yacc.c:1648  */
1480     break;
1481
1482   case 28:
1483 #line 124 "mcparse.y" /* yacc.c:1648  */
1484     {
1485             mc_add_keyword ((yyvsp[-3].ustr), MCTOKEN, "severity", (yyvsp[-1].ival), (yyvsp[0].ustr));
1486           }
1487 #line 1488 "mcparse.c" /* yacc.c:1648  */
1488     break;
1489
1490   case 29:
1491 #line 127 "mcparse.y" /* yacc.c:1648  */
1492     { mc_fatal ("severity number missing"); }
1493 #line 1494 "mcparse.c" /* yacc.c:1648  */
1494     break;
1495
1496   case 30:
1497 #line 128 "mcparse.y" /* yacc.c:1648  */
1498     { mc_fatal ("severity missing '='"); }
1499 #line 1500 "mcparse.c" /* yacc.c:1648  */
1500     break;
1501
1502   case 33:
1503 #line 134 "mcparse.y" /* yacc.c:1648  */
1504     { mc_fatal ("missing ident in FacilityNames"); }
1505 #line 1506 "mcparse.c" /* yacc.c:1648  */
1506     break;
1507
1508   case 34:
1509 #line 139 "mcparse.y" /* yacc.c:1648  */
1510     {
1511             mc_add_keyword ((yyvsp[-3].ustr), MCTOKEN, "facility", (yyvsp[-1].ival), (yyvsp[0].ustr));
1512           }
1513 #line 1514 "mcparse.c" /* yacc.c:1648  */
1514     break;
1515
1516   case 35:
1517 #line 142 "mcparse.y" /* yacc.c:1648  */
1518     { mc_fatal ("facility number missing"); }
1519 #line 1520 "mcparse.c" /* yacc.c:1648  */
1520     break;
1521
1522   case 36:
1523 #line 143 "mcparse.y" /* yacc.c:1648  */
1524     { mc_fatal ("facility missing '='"); }
1525 #line 1526 "mcparse.c" /* yacc.c:1648  */
1526     break;
1527
1528   case 39:
1529 #line 149 "mcparse.y" /* yacc.c:1648  */
1530     { mc_fatal ("missing ident in LanguageNames"); }
1531 #line 1532 "mcparse.c" /* yacc.c:1648  */
1532     break;
1533
1534   case 40:
1535 #line 154 "mcparse.y" /* yacc.c:1648  */
1536     {
1537             mc_add_keyword ((yyvsp[-5].ustr), MCTOKEN, "language", (yyvsp[-3].ival), (yyvsp[0].ustr));
1538           }
1539 #line 1540 "mcparse.c" /* yacc.c:1648  */
1540     break;
1541
1542   case 41:
1543 #line 157 "mcparse.y" /* yacc.c:1648  */
1544     { mc_fatal ("missing filename in LanguageNames"); }
1545 #line 1546 "mcparse.c" /* yacc.c:1648  */
1546     break;
1547
1548   case 42:
1549 #line 158 "mcparse.y" /* yacc.c:1648  */
1550     { mc_fatal ("missing ':' in LanguageNames"); }
1551 #line 1552 "mcparse.c" /* yacc.c:1648  */
1552     break;
1553
1554   case 43:
1555 #line 159 "mcparse.y" /* yacc.c:1648  */
1556     { mc_fatal ("missing language code in LanguageNames"); }
1557 #line 1558 "mcparse.c" /* yacc.c:1648  */
1558     break;
1559
1560   case 44:
1561 #line 160 "mcparse.y" /* yacc.c:1648  */
1562     { mc_fatal ("missing '=' for LanguageNames"); }
1563 #line 1564 "mcparse.c" /* yacc.c:1648  */
1564     break;
1565
1566   case 45:
1567 #line 165 "mcparse.y" /* yacc.c:1648  */
1568     {
1569             (yyval.ustr) = NULL;
1570           }
1571 #line 1572 "mcparse.c" /* yacc.c:1648  */
1572     break;
1573
1574   case 46:
1575 #line 169 "mcparse.y" /* yacc.c:1648  */
1576     {
1577             (yyval.ustr) = (yyvsp[0].ustr);
1578           }
1579 #line 1580 "mcparse.c" /* yacc.c:1648  */
1580     break;
1581
1582   case 47:
1583 #line 172 "mcparse.y" /* yacc.c:1648  */
1584     { mc_fatal ("illegal token in identifier"); (yyval.ustr) = NULL; }
1585 #line 1586 "mcparse.c" /* yacc.c:1648  */
1586     break;
1587
1588   case 48:
1589 #line 177 "mcparse.y" /* yacc.c:1648  */
1590     {
1591             cur_node = mc_add_node ();
1592             cur_node->symbol = mc_last_symbol;
1593             cur_node->facility = mc_cur_facility;
1594             cur_node->severity = mc_cur_severity;
1595             cur_node->id = ((yyvsp[-1].ival) & 0xffffUL);
1596             cur_node->vid = ((yyvsp[-1].ival) & 0xffffUL) | mc_sefa_val;
1597             mc_last_id = (yyvsp[-1].ival);
1598           }
1599 #line 1600 "mcparse.c" /* yacc.c:1648  */
1600     break;
1601
1602   case 50:
1603 #line 189 "mcparse.y" /* yacc.c:1648  */
1604     { (yyval.ival) = (yyvsp[0].ival); }
1605 #line 1606 "mcparse.c" /* yacc.c:1648  */
1606     break;
1607
1608   case 51:
1609 #line 190 "mcparse.y" /* yacc.c:1648  */
1610     { mc_fatal ("missing number in MessageId"); (yyval.ival) = 0; }
1611 #line 1612 "mcparse.c" /* yacc.c:1648  */
1612     break;
1613
1614   case 52:
1615 #line 191 "mcparse.y" /* yacc.c:1648  */
1616     { mc_fatal ("missing '=' for MessageId"); (yyval.ival) = 0; }
1617 #line 1618 "mcparse.c" /* yacc.c:1648  */
1618     break;
1619
1620   case 53:
1621 #line 195 "mcparse.y" /* yacc.c:1648  */
1622     {
1623             (yyval.ival) = ++mc_last_id;
1624           }
1625 #line 1626 "mcparse.c" /* yacc.c:1648  */
1626     break;
1627
1628   case 54:
1629 #line 199 "mcparse.y" /* yacc.c:1648  */
1630     {
1631             (yyval.ival) = (yyvsp[0].ival);
1632           }
1633 #line 1634 "mcparse.c" /* yacc.c:1648  */
1634     break;
1635
1636   case 55:
1637 #line 203 "mcparse.y" /* yacc.c:1648  */
1638     {
1639             (yyval.ival) = mc_last_id + (yyvsp[0].ival);
1640           }
1641 #line 1642 "mcparse.c" /* yacc.c:1648  */
1642     break;
1643
1644   case 56:
1645 #line 206 "mcparse.y" /* yacc.c:1648  */
1646     { mc_fatal ("missing number after MessageId '+'"); }
1647 #line 1648 "mcparse.c" /* yacc.c:1648  */
1648     break;
1649
1650   case 57:
1651 #line 211 "mcparse.y" /* yacc.c:1648  */
1652     {
1653             (yyval.ival) = 0;
1654             mc_sefa_val = (mcset_custom_bit ? 1 : 0) << 29;
1655             mc_last_symbol = NULL;
1656             mc_cur_severity = NULL;
1657             mc_cur_facility = NULL;
1658           }
1659 #line 1660 "mcparse.c" /* yacc.c:1648  */
1660     break;
1661
1662   case 58:
1663 #line 219 "mcparse.y" /* yacc.c:1648  */
1664     {
1665             if ((yyvsp[-1].ival) & 1)
1666               mc_warn (_("duplicate definition of Severity"));
1667             (yyval.ival) = (yyvsp[-1].ival) | 1;
1668           }
1669 #line 1670 "mcparse.c" /* yacc.c:1648  */
1670     break;
1671
1672   case 59:
1673 #line 225 "mcparse.y" /* yacc.c:1648  */
1674     {
1675             if ((yyvsp[-1].ival) & 2)
1676               mc_warn (_("duplicate definition of Facility"));
1677             (yyval.ival) = (yyvsp[-1].ival) | 2;
1678           }
1679 #line 1680 "mcparse.c" /* yacc.c:1648  */
1680     break;
1681
1682   case 60:
1683 #line 231 "mcparse.y" /* yacc.c:1648  */
1684     {
1685             if ((yyvsp[-1].ival) & 4)
1686               mc_warn (_("duplicate definition of SymbolicName"));
1687             (yyval.ival) = (yyvsp[-1].ival) | 4;
1688           }
1689 #line 1690 "mcparse.c" /* yacc.c:1648  */
1690     break;
1691
1692   case 61:
1693 #line 239 "mcparse.y" /* yacc.c:1648  */
1694     {
1695             mc_sefa_val &= ~ (0x3UL << 30);
1696             mc_sefa_val |= (((yyvsp[0].tok)->nval & 0x3UL) << 30);
1697             mc_cur_severity = (yyvsp[0].tok);
1698           }
1699 #line 1700 "mcparse.c" /* yacc.c:1648  */
1700     break;
1701
1702   case 62:
1703 #line 247 "mcparse.y" /* yacc.c:1648  */
1704     {
1705             mc_sefa_val &= ~ (0xfffUL << 16);
1706             mc_sefa_val |= (((yyvsp[0].tok)->nval & 0xfffUL) << 16);
1707             mc_cur_facility = (yyvsp[0].tok);
1708           }
1709 #line 1710 "mcparse.c" /* yacc.c:1648  */
1710     break;
1711
1712   case 63:
1713 #line 255 "mcparse.y" /* yacc.c:1648  */
1714     {
1715           mc_last_symbol = (yyvsp[0].ustr);
1716         }
1717 #line 1718 "mcparse.c" /* yacc.c:1648  */
1718     break;
1719
1720   case 66:
1721 #line 267 "mcparse.y" /* yacc.c:1648  */
1722     {
1723             mc_node_lang *h;
1724             h = mc_add_node_lang (cur_node, (yyvsp[-3].tok), cur_node->vid);
1725             h->message = (yyvsp[-1].ustr);
1726             if (mcset_max_message_length != 0 && unichar_len (h->message) > mcset_max_message_length)
1727               mc_warn ("message length to long");
1728           }
1729 #line 1730 "mcparse.c" /* yacc.c:1648  */
1730     break;
1731
1732   case 67:
1733 #line 277 "mcparse.y" /* yacc.c:1648  */
1734     {
1735             (yyval.ustr) = (yyvsp[0].ustr);
1736           }
1737 #line 1738 "mcparse.c" /* yacc.c:1648  */
1738     break;
1739
1740   case 68:
1741 #line 281 "mcparse.y" /* yacc.c:1648  */
1742     {
1743             unichar *h;
1744             rc_uint_type l1,l2;
1745             l1 = unichar_len ((yyvsp[-1].ustr));
1746             l2 = unichar_len ((yyvsp[0].ustr));
1747             h = (unichar *) res_alloc ((l1 + l2 + 1) * sizeof (unichar));
1748             if (l1) memcpy (h, (yyvsp[-1].ustr), l1 * sizeof (unichar));
1749             if (l2) memcpy (&h[l1], (yyvsp[0].ustr), l2 * sizeof (unichar));
1750             h[l1 + l2] = 0;
1751             (yyval.ustr) = h;
1752           }
1753 #line 1754 "mcparse.c" /* yacc.c:1648  */
1754     break;
1755
1756   case 69:
1757 #line 292 "mcparse.y" /* yacc.c:1648  */
1758     { mc_fatal ("missing end of message text"); (yyval.ustr) = NULL; }
1759 #line 1760 "mcparse.c" /* yacc.c:1648  */
1760     break;
1761
1762   case 70:
1763 #line 293 "mcparse.y" /* yacc.c:1648  */
1764     { mc_fatal ("missing end of message text"); (yyval.ustr) = (yyvsp[-1].ustr); }
1765 #line 1766 "mcparse.c" /* yacc.c:1648  */
1766     break;
1767
1768   case 71:
1769 #line 296 "mcparse.y" /* yacc.c:1648  */
1770     { (yyval.ustr) = (yyvsp[0].ustr); }
1771 #line 1772 "mcparse.c" /* yacc.c:1648  */
1772     break;
1773
1774   case 72:
1775 #line 298 "mcparse.y" /* yacc.c:1648  */
1776     {
1777             unichar *h;
1778             rc_uint_type l1,l2;
1779             l1 = unichar_len ((yyvsp[-1].ustr));
1780             l2 = unichar_len ((yyvsp[0].ustr));
1781             h = (unichar *) res_alloc ((l1 + l2 + 1) * sizeof (unichar));
1782             if (l1) memcpy (h, (yyvsp[-1].ustr), l1 * sizeof (unichar));
1783             if (l2) memcpy (&h[l1], (yyvsp[0].ustr), l2 * sizeof (unichar));
1784             h[l1 + l2] = 0;
1785             (yyval.ustr) = h;
1786           }
1787 #line 1788 "mcparse.c" /* yacc.c:1648  */
1788     break;
1789
1790   case 73:
1791 #line 312 "mcparse.y" /* yacc.c:1648  */
1792     {
1793             (yyval.tok) = (yyvsp[-1].tok);
1794           }
1795 #line 1796 "mcparse.c" /* yacc.c:1648  */
1796     break;
1797
1798   case 74:
1799 #line 316 "mcparse.y" /* yacc.c:1648  */
1800     {
1801             (yyval.tok) = NULL;
1802             mc_fatal (_("undeclared language identifier"));
1803           }
1804 #line 1805 "mcparse.c" /* yacc.c:1648  */
1805     break;
1806
1807   case 75:
1808 #line 321 "mcparse.y" /* yacc.c:1648  */
1809     {
1810             (yyval.tok) = NULL;
1811             mc_fatal ("missing newline after Language");
1812           }
1813 #line 1814 "mcparse.c" /* yacc.c:1648  */
1814     break;
1815
1816   case 76:
1817 #line 326 "mcparse.y" /* yacc.c:1648  */
1818     {
1819             (yyval.tok) = NULL;
1820             mc_fatal ("missing ident for Language");
1821           }
1822 #line 1823 "mcparse.c" /* yacc.c:1648  */
1823     break;
1824
1825   case 77:
1826 #line 331 "mcparse.y" /* yacc.c:1648  */
1827     {
1828             (yyval.tok) = NULL;
1829             mc_fatal ("missing '=' for Language");
1830           }
1831 #line 1832 "mcparse.c" /* yacc.c:1648  */
1832     break;
1833
1834   case 78:
1835 #line 337 "mcparse.y" /* yacc.c:1648  */
1836     { (yyval.ustr) = (yyvsp[0].ustr); }
1837 #line 1838 "mcparse.c" /* yacc.c:1648  */
1838     break;
1839
1840   case 79:
1841 #line 338 "mcparse.y" /* yacc.c:1648  */
1842     { (yyval.ustr) = (yyvsp[0].tok)->usz; }
1843 #line 1844 "mcparse.c" /* yacc.c:1648  */
1844     break;
1845
1846   case 80:
1847 #line 342 "mcparse.y" /* yacc.c:1648  */
1848     { mclex_want_nl = 1; }
1849 #line 1850 "mcparse.c" /* yacc.c:1648  */
1850     break;
1851
1852   case 81:
1853 #line 346 "mcparse.y" /* yacc.c:1648  */
1854     { mclex_want_line = 1; }
1855 #line 1856 "mcparse.c" /* yacc.c:1648  */
1856     break;
1857
1858   case 82:
1859 #line 350 "mcparse.y" /* yacc.c:1648  */
1860     { mclex_want_filename = 1; }
1861 #line 1862 "mcparse.c" /* yacc.c:1648  */
1862     break;
1863
1864
1865 #line 1866 "mcparse.c" /* yacc.c:1648  */
1866       default: break;
1867     }
1868   /* User semantic actions sometimes alter yychar, and that requires
1869      that yytoken be updated with the new translation.  We take the
1870      approach of translating immediately before every use of yytoken.
1871      One alternative is translating here after every semantic action,
1872      but that translation would be missed if the semantic action invokes
1873      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1874      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
1875      incorrect destructor might then be invoked immediately.  In the
1876      case of YYERROR or YYBACKUP, subsequent parser actions might lead
1877      to an incorrect destructor call or verbose syntax error message
1878      before the lookahead is translated.  */
1879   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1880
1881   YYPOPSTACK (yylen);
1882   yylen = 0;
1883   YY_STACK_PRINT (yyss, yyssp);
1884
1885   *++yyvsp = yyval;
1886
1887   /* Now 'shift' the result of the reduction.  Determine what state
1888      that goes to, based on the state we popped back to and the rule
1889      number reduced by.  */
1890
1891   yyn = yyr1[yyn];
1892
1893   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1894   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1895     yystate = yytable[yystate];
1896   else
1897     yystate = yydefgoto[yyn - YYNTOKENS];
1898
1899   goto yynewstate;
1900
1901
1902 /*--------------------------------------.
1903 | yyerrlab -- here on detecting error.  |
1904 `--------------------------------------*/
1905 yyerrlab:
1906   /* Make sure we have latest lookahead translation.  See comments at
1907      user semantic actions for why this is necessary.  */
1908   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1909
1910   /* If not already recovering from an error, report this error.  */
1911   if (!yyerrstatus)
1912     {
1913       ++yynerrs;
1914 #if ! YYERROR_VERBOSE
1915       yyerror (YY_("syntax error"));
1916 #else
1917 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1918                                         yyssp, yytoken)
1919       {
1920         char const *yymsgp = YY_("syntax error");
1921         int yysyntax_error_status;
1922         yysyntax_error_status = YYSYNTAX_ERROR;
1923         if (yysyntax_error_status == 0)
1924           yymsgp = yymsg;
1925         else if (yysyntax_error_status == 1)
1926           {
1927             if (yymsg != yymsgbuf)
1928               YYSTACK_FREE (yymsg);
1929             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1930             if (!yymsg)
1931               {
1932                 yymsg = yymsgbuf;
1933                 yymsg_alloc = sizeof yymsgbuf;
1934                 yysyntax_error_status = 2;
1935               }
1936             else
1937               {
1938                 yysyntax_error_status = YYSYNTAX_ERROR;
1939                 yymsgp = yymsg;
1940               }
1941           }
1942         yyerror (yymsgp);
1943         if (yysyntax_error_status == 2)
1944           goto yyexhaustedlab;
1945       }
1946 # undef YYSYNTAX_ERROR
1947 #endif
1948     }
1949
1950
1951
1952   if (yyerrstatus == 3)
1953     {
1954       /* If just tried and failed to reuse lookahead token after an
1955          error, discard it.  */
1956
1957       if (yychar <= YYEOF)
1958         {
1959           /* Return failure if at end of input.  */
1960           if (yychar == YYEOF)
1961             YYABORT;
1962         }
1963       else
1964         {
1965           yydestruct ("Error: discarding",
1966                       yytoken, &yylval);
1967           yychar = YYEMPTY;
1968         }
1969     }
1970
1971   /* Else will try to reuse lookahead token after shifting the error
1972      token.  */
1973   goto yyerrlab1;
1974
1975
1976 /*---------------------------------------------------.
1977 | yyerrorlab -- error raised explicitly by YYERROR.  |
1978 `---------------------------------------------------*/
1979 yyerrorlab:
1980
1981   /* Pacify compilers like GCC when the user code never invokes
1982      YYERROR and the label yyerrorlab therefore never appears in user
1983      code.  */
1984   if (/*CONSTCOND*/ 0)
1985      goto yyerrorlab;
1986
1987   /* Do not reclaim the symbols of the rule whose action triggered
1988      this YYERROR.  */
1989   YYPOPSTACK (yylen);
1990   yylen = 0;
1991   YY_STACK_PRINT (yyss, yyssp);
1992   yystate = *yyssp;
1993   goto yyerrlab1;
1994
1995
1996 /*-------------------------------------------------------------.
1997 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1998 `-------------------------------------------------------------*/
1999 yyerrlab1:
2000   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
2001
2002   for (;;)
2003     {
2004       yyn = yypact[yystate];
2005       if (!yypact_value_is_default (yyn))
2006         {
2007           yyn += YYTERROR;
2008           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2009             {
2010               yyn = yytable[yyn];
2011               if (0 < yyn)
2012                 break;
2013             }
2014         }
2015
2016       /* Pop the current state because it cannot handle the error token.  */
2017       if (yyssp == yyss)
2018         YYABORT;
2019
2020
2021       yydestruct ("Error: popping",
2022                   yystos[yystate], yyvsp);
2023       YYPOPSTACK (1);
2024       yystate = *yyssp;
2025       YY_STACK_PRINT (yyss, yyssp);
2026     }
2027
2028   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2029   *++yyvsp = yylval;
2030   YY_IGNORE_MAYBE_UNINITIALIZED_END
2031
2032
2033   /* Shift the error token.  */
2034   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2035
2036   yystate = yyn;
2037   goto yynewstate;
2038
2039
2040 /*-------------------------------------.
2041 | yyacceptlab -- YYACCEPT comes here.  |
2042 `-------------------------------------*/
2043 yyacceptlab:
2044   yyresult = 0;
2045   goto yyreturn;
2046
2047 /*-----------------------------------.
2048 | yyabortlab -- YYABORT comes here.  |
2049 `-----------------------------------*/
2050 yyabortlab:
2051   yyresult = 1;
2052   goto yyreturn;
2053
2054 #if !defined yyoverflow || YYERROR_VERBOSE
2055 /*-------------------------------------------------.
2056 | yyexhaustedlab -- memory exhaustion comes here.  |
2057 `-------------------------------------------------*/
2058 yyexhaustedlab:
2059   yyerror (YY_("memory exhausted"));
2060   yyresult = 2;
2061   /* Fall through.  */
2062 #endif
2063
2064 yyreturn:
2065   if (yychar != YYEMPTY)
2066     {
2067       /* Make sure we have latest lookahead translation.  See comments at
2068          user semantic actions for why this is necessary.  */
2069       yytoken = YYTRANSLATE (yychar);
2070       yydestruct ("Cleanup: discarding lookahead",
2071                   yytoken, &yylval);
2072     }
2073   /* Do not reclaim the symbols of the rule whose action triggered
2074      this YYABORT or YYACCEPT.  */
2075   YYPOPSTACK (yylen);
2076   YY_STACK_PRINT (yyss, yyssp);
2077   while (yyssp != yyss)
2078     {
2079       yydestruct ("Cleanup: popping",
2080                   yystos[*yyssp], yyvsp);
2081       YYPOPSTACK (1);
2082     }
2083 #ifndef yyoverflow
2084   if (yyss != yyssa)
2085     YYSTACK_FREE (yyss);
2086 #endif
2087 #if YYERROR_VERBOSE
2088   if (yymsg != yymsgbuf)
2089     YYSTACK_FREE (yymsg);
2090 #endif
2091   return yyresult;
2092 }
2093 #line 353 "mcparse.y" /* yacc.c:1907  */
2094
2095
2096 /* Something else.  */