]> git.saurik.com Git - bison.git/blob - src/parse-gram.c
projects / bison.git / blob
? search:


4b6704f16a88e6a34b9868cb3fd68d2999c46683
[bison.git] / src / parse-gram.c
1 /* A Bison parser, made by GNU Bison 2.0a. */
2
3 /* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
21 /* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
25
26 /* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
28
29 /* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
35
36 /* Identify Bison output. */
37 #define YYBISON 1
38
39 /* Skeleton name. */
40 #define YYSKELETON_NAME "yacc.c"
41
42 /* Pure parsers. */
43 #define YYPURE 1
44
45 /* Using locations. */
46 #define YYLSP_NEEDED 1
47
48 /* Substitute the variable and function names. */
49 #define yyparse gram_parse
50 #define yylex gram_lex
51 #define yyerror gram_error
52 #define yylval gram_lval
53 #define yychar gram_char
54 #define yydebug gram_debug
55 #define yynerrs gram_nerrs
56 #define yylloc gram_lloc
57
58 /* Tokens. */
59 #ifndef YYTOKENTYPE
60 # define YYTOKENTYPE
61 /* Put the tokens into the symbol table, so that GDB and other debuggers
62 know about them. */
63 enum yytokentype {
64 GRAM_EOF = 0,
65 STRING = 258,
66 INT = 259,
67 PERCENT_TOKEN = 260,
68 PERCENT_NTERM = 261,
69 PERCENT_TYPE = 262,
70 PERCENT_DESTRUCTOR = 263,
71 PERCENT_PRINTER = 264,
72 PERCENT_UNION = 265,
73 PERCENT_LEFT = 266,
74 PERCENT_RIGHT = 267,
75 PERCENT_NONASSOC = 268,
76 PERCENT_PREC = 269,
77 PERCENT_DPREC = 270,
78 PERCENT_MERGE = 271,
79 PERCENT_DEBUG = 272,
80 PERCENT_DEFAULT_PREC = 273,
81 PERCENT_DEFINE = 274,
82 PERCENT_DEFINES = 275,
83 PERCENT_ERROR_VERBOSE = 276,
84 PERCENT_EXPECT = 277,
85 PERCENT_EXPECT_RR = 278,
86 PERCENT_FILE_PREFIX = 279,
87 PERCENT_GLR_PARSER = 280,
88 PERCENT_INITIAL_ACTION = 281,
89 PERCENT_LEX_PARAM = 282,
90 PERCENT_LOCATIONS = 283,
91 PERCENT_NAME_PREFIX = 284,
92 PERCENT_NO_DEFAULT_PREC = 285,
93 PERCENT_NO_LINES = 286,
94 PERCENT_NONDETERMINISTIC_PARSER = 287,
95 PERCENT_OUTPUT = 288,
96 PERCENT_PARSE_PARAM = 289,
97 PERCENT_PURE_PARSER = 290,
98 PERCENT_SKELETON = 291,
99 PERCENT_START = 292,
100 PERCENT_TOKEN_TABLE = 293,
101 PERCENT_VERBOSE = 294,
102 PERCENT_YACC = 295,
103 TYPE = 296,
104 EQUAL = 297,
105 SEMICOLON = 298,
106 PIPE = 299,
107 ID = 300,
108 ID_COLON = 301,
109 PERCENT_PERCENT = 302,
110 PROLOGUE = 303,
111 EPILOGUE = 304,
112 BRACED_CODE = 305
113 };
114 #endif
115 #define GRAM_EOF 0
116 #define STRING 258
117 #define INT 259
118 #define PERCENT_TOKEN 260
119 #define PERCENT_NTERM 261
120 #define PERCENT_TYPE 262
121 #define PERCENT_DESTRUCTOR 263
122 #define PERCENT_PRINTER 264
123 #define PERCENT_UNION 265
124 #define PERCENT_LEFT 266
125 #define PERCENT_RIGHT 267
126 #define PERCENT_NONASSOC 268
127 #define PERCENT_PREC 269
128 #define PERCENT_DPREC 270
129 #define PERCENT_MERGE 271
130 #define PERCENT_DEBUG 272
131 #define PERCENT_DEFAULT_PREC 273
132 #define PERCENT_DEFINE 274
133 #define PERCENT_DEFINES 275
134 #define PERCENT_ERROR_VERBOSE 276
135 #define PERCENT_EXPECT 277
136 #define PERCENT_EXPECT_RR 278
137 #define PERCENT_FILE_PREFIX 279
138 #define PERCENT_GLR_PARSER 280
139 #define PERCENT_INITIAL_ACTION 281
140 #define PERCENT_LEX_PARAM 282
141 #define PERCENT_LOCATIONS 283
142 #define PERCENT_NAME_PREFIX 284
143 #define PERCENT_NO_DEFAULT_PREC 285
144 #define PERCENT_NO_LINES 286
145 #define PERCENT_NONDETERMINISTIC_PARSER 287
146 #define PERCENT_OUTPUT 288
147 #define PERCENT_PARSE_PARAM 289
148 #define PERCENT_PURE_PARSER 290
149 #define PERCENT_SKELETON 291
150 #define PERCENT_START 292
151 #define PERCENT_TOKEN_TABLE 293
152 #define PERCENT_VERBOSE 294
153 #define PERCENT_YACC 295
154 #define TYPE 296
155 #define EQUAL 297
156 #define SEMICOLON 298
157 #define PIPE 299
158 #define ID 300
159 #define ID_COLON 301
160 #define PERCENT_PERCENT 302
161 #define PROLOGUE 303
162 #define EPILOGUE 304
163 #define BRACED_CODE 305
164
165
166
167
168 /* Copy the first part of user declarations. */
169 #line 1 "parse-gram.y"
170 /* Bison Grammar Parser -*- C -*-
171
172 Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
173
174 This file is part of Bison, the GNU Compiler Compiler.
175
176 This program is free software; you can redistribute it and/or modify
177 it under the terms of the GNU General Public License as published by
178 the Free Software Foundation; either version 2 of the License, or
179 (at your option) any later version.
180
181 This program is distributed in the hope that it will be useful,
182 but WITHOUT ANY WARRANTY; without even the implied warranty of
183 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
184 GNU General Public License for more details.
185
186 You should have received a copy of the GNU General Public License
187 along with this program; if not, write to the Free Software
188 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
189 02111-1307 USA
190 */
191
192 #include "system.h"
193
194 #include "complain.h"
195 #include "conflicts.h"
196 #include "files.h"
197 #include "getargs.h"
198 #include "gram.h"
199 #include "muscle_tab.h"
200 #include "output.h"
201 #include "quotearg.h"
202 #include "reader.h"
203 #include "symlist.h"
204
205 #define YYLLOC_DEFAULT(Current, Rhs, N) (Current) = lloc_default (Rhs, N)
206 static YYLTYPE lloc_default (YYLTYPE const *, int);
207
208 #define YY_LOCATION_PRINT(File, Loc) \
209 location_print (File, Loc)
210
211 /* Request detailed syntax error messages, and pass them to GRAM_ERROR.
212 FIXME: depends on the undocumented availability of YYLLOC. */
213 #undef yyerror
214 #define yyerror(Msg) \
215 gram_error (&yylloc, Msg)
216 static void gram_error (location const *, char const *);
217
218 #define YYPRINT(File, Type, Value) \
219 print_token_value (File, Type, &Value)
220 static void print_token_value (FILE *, int, YYSTYPE const *);
221
222 static void add_param (char const *, char *, location);
223
224 symbol_class current_class = unknown_sym;
225 uniqstr current_type = 0;
226 symbol *current_lhs;
227 location current_lhs_location;
228 assoc current_assoc;
229 int current_prec = 0;
230
231
232 /* Enabling traces. */
233 #ifndef YYDEBUG
234 # define YYDEBUG 1
235 #endif
236
237 /* Enabling verbose error messages. */
238 #ifdef YYERROR_VERBOSE
239 # undef YYERROR_VERBOSE
240 # define YYERROR_VERBOSE 1
241 #else
242 # define YYERROR_VERBOSE 1
243 #endif
244
245 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
246 #line 82 "parse-gram.y"
247 typedef union YYSTYPE {
248 symbol *symbol;
249 symbol_list *list;
250 int integer;
251 char *chars;
252 assoc assoc;
253 uniqstr uniqstr;
254 } YYSTYPE;
255 /* Line 191 of yacc.c. */
256 #line 257 "parse-gram.c"
257 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
258 # define YYSTYPE_IS_DECLARED 1
259 # define YYSTYPE_IS_TRIVIAL 1
260 #endif
261
262 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
263 typedef struct YYLTYPE
264 {
265 int first_line;
266 int first_column;
267 int last_line;
268 int last_column;
269 } YYLTYPE;
270 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
271 # define YYLTYPE_IS_DECLARED 1
272 # define YYLTYPE_IS_TRIVIAL 1
273 #endif
274
275
276 /* Copy the second part of user declarations. */
277
278
279 /* Line 214 of yacc.c. */
280 #line 281 "parse-gram.c"
281
282 #if ! defined (yyoverflow) || YYERROR_VERBOSE
283
284 # ifndef YYFREE
285 # define YYFREE free
286 # endif
287 # ifndef YYMALLOC
288 # define YYMALLOC malloc
289 # endif
290
291 /* The parser invokes alloca or malloc; define the necessary symbols. */
292
293 # ifdef YYSTACK_USE_ALLOCA
294 # if YYSTACK_USE_ALLOCA
295 # ifdef __GNUC__
296 # define YYSTACK_ALLOC __builtin_alloca
297 # else
298 # define YYSTACK_ALLOC alloca
299 # endif
300 # endif
301 # endif
302
303 # ifdef YYSTACK_ALLOC
304 /* Pacify GCC's `empty if-body' warning. */
305 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
306 # ifndef YYSTACK_ALLOC_MAXIMUM
307 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
308 # endif
309 # else
310 # if defined (__STDC__) || defined (__cplusplus)
311 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
312 # define YYSIZE_T size_t
313 # else
314 # define YYSIZE_T unsigned long int
315 # endif
316 # define YYSTACK_ALLOC YYMALLOC
317 # define YYSTACK_FREE YYFREE
318 # ifndef YYSTACK_ALLOC_MAXIMUM
319 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
320 # endif
321 # endif
322 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
323
324
325 #if (! defined (yyoverflow) \
326 && (! defined (__cplusplus) \
327 || (defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
328 && defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
329
330 /* A type that is properly aligned for any stack member. */
331 union yyalloc
332 {
333 short int yyss;
334 YYSTYPE yyvs;
335 YYLTYPE yyls;
336 };
337
338 /* The size of the maximum gap between one aligned stack and the next. */
339 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
340
341 /* The size of an array large to enough to hold all stacks, each with
342 N elements. */
343 # define YYSTACK_BYTES(N) \
344 ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
345 + 2 * YYSTACK_GAP_MAXIMUM)
346
347 /* Copy COUNT objects from FROM to TO. The source and destination do
348 not overlap. */
349 # ifndef YYCOPY
350 # if defined (__GNUC__) && 1 < __GNUC__
351 # define YYCOPY(To, From, Count) \
352 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
353 # else
354 # define YYCOPY(To, From, Count) \
355 do \
356 { \
357 YYSIZE_T yyi; \
358 for (yyi = 0; yyi < (Count); yyi++) \
359 (To)[yyi] = (From)[yyi]; \
360 } \
361 while (0)
362 # endif
363 # endif
364
365 /* Relocate STACK from its old location to the new one. The
366 local variables YYSIZE and YYSTACKSIZE give the old and new number of
367 elements in the stack, and YYPTR gives the new location of the
368 stack. Advance YYPTR to a properly aligned location for the next
369 stack. */
370 # define YYSTACK_RELOCATE(Stack) \
371 do \
372 { \
373 YYSIZE_T yynewbytes; \
374 YYCOPY (&yyptr->Stack, Stack, yysize); \
375 Stack = &yyptr->Stack; \
376 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
377 yyptr += yynewbytes / sizeof (*yyptr); \
378 } \
379 while (0)
380
381 #endif
382
383 #if defined (__STDC__) || defined (__cplusplus)
384 typedef signed char yysigned_char;
385 #else
386 typedef short int yysigned_char;
387 #endif
388
389 /* YYFINAL -- State number of the termination state. */
390 #define YYFINAL 3
391 /* YYLAST -- Last index in YYTABLE. */
392 #define YYLAST 158
393
394 /* YYNTOKENS -- Number of terminals. */
395 #define YYNTOKENS 51
396 /* YYNNTS -- Number of nonterminals. */
397 #define YYNNTS 25
398 /* YYNRULES -- Number of rules. */
399 #define YYNRULES 79
400 /* YYNRULES -- Number of states. */
401 #define YYNSTATES 108
402
403 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
404 #define YYUNDEFTOK 2
405 #define YYMAXUTOK 305
406
407 #define YYTRANSLATE(YYX) \
408 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
409
410 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
411 static const unsigned char yytranslate[] =
412 {
413 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
414 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
415 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
421 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
424 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
431 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
433 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
434 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
435 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
436 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
437 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
438 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
439 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
440 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
441 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
442 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
443 45, 46, 47, 48, 49, 50
444 };
445
446 #if YYDEBUG
447 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
448 YYRHS. */
449 static const unsigned char yyprhs[] =
450 {
451 0, 0, 3, 8, 9, 12, 14, 16, 18, 22,
452 24, 26, 29, 32, 36, 38, 40, 42, 44, 48,
453 50, 52, 56, 58, 60, 63, 65, 67, 69, 71,
454 73, 75, 78, 80, 83, 86, 88, 90, 91, 95,
455 96, 100, 104, 108, 110, 112, 114, 115, 117, 119,
456 122, 124, 126, 129, 132, 136, 138, 141, 143, 146,
457 148, 151, 154, 155, 159, 161, 165, 168, 169, 172,
458 175, 179, 183, 187, 189, 191, 193, 195, 197, 198
459 };
460
461 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
462 static const yysigned_char yyrhs[] =
463 {
464 52, 0, -1, 53, 47, 65, 75, -1, -1, 53,
465 54, -1, 55, -1, 48, -1, 17, -1, 19, 74,
466 74, -1, 20, -1, 21, -1, 22, 4, -1, 23,
467 4, -1, 24, 42, 74, -1, 25, -1, 26, -1,
468 27, -1, 28, -1, 29, 42, 74, -1, 31, -1,
469 32, -1, 33, 42, 74, -1, 34, -1, 35, -1,
470 36, 74, -1, 38, -1, 39, -1, 40, -1, 43,
471 -1, 59, -1, 56, -1, 37, 71, -1, 10, -1,
472 8, 62, -1, 9, 62, -1, 18, -1, 30, -1,
473 -1, 6, 57, 64, -1, -1, 5, 58, 64, -1,
474 7, 41, 62, -1, 60, 61, 62, -1, 11, -1,
475 12, -1, 13, -1, -1, 41, -1, 71, -1, 62,
476 71, -1, 41, -1, 45, -1, 45, 4, -1, 45,
477 73, -1, 45, 4, 73, -1, 63, -1, 64, 63,
478 -1, 66, -1, 65, 66, -1, 67, -1, 55, 43,
479 -1, 1, 43, -1, -1, 46, 68, 69, -1, 70,
480 -1, 69, 44, 70, -1, 69, 43, -1, -1, 70,
481 71, -1, 70, 72, -1, 70, 14, 71, -1, 70,
482 15, 4, -1, 70, 16, 41, -1, 45, -1, 73,
483 -1, 50, -1, 3, -1, 3, -1, -1, 47, 49,
484 -1
485 };
486
487 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
488 static const unsigned short int yyrline[] =
489 {
490 0, 175, 175, 183, 185, 189, 190, 191, 192, 193,
491 194, 195, 196, 197, 198, 203, 207, 208, 209, 210,
492 211, 212, 213, 214, 215, 216, 217, 218, 219, 223,
493 224, 225, 229, 235, 242, 249, 253, 260, 260, 265,
494 265, 270, 280, 295, 296, 297, 301, 302, 308, 309,
495 314, 318, 323, 329, 335, 346, 347, 356, 357, 363,
496 364, 369, 376, 376, 380, 381, 382, 387, 388, 390,
497 392, 394, 396, 401, 402, 406, 412, 421, 426, 428
498 };
499 #endif
500
501 #if YYDEBUG || YYERROR_VERBOSE
502 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
503 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
504 static const char *const yytname[] =
505 {
506 "end of file", "error", "$undefined", "string", "integer", "%token",
507 "%nterm", "%type", "%destructor {...}", "%printer {...}", "%union {...}",
508 "%left", "%right", "%nonassoc", "%prec", "%dprec", "%merge", "%debug",
509 "%default-prec", "%define", "%defines", "%error-verbose", "%expect",
510 "%expect-rr", "%file-prefix", "%glr-parser", "%initial-action {...}",
511 "%lex-param {...}", "%locations", "%name-prefix", "%no-default-prec",
512 "%no-lines", "%nondeterministic-parser", "%output", "%parse-param {...}",
513 "%pure-parser", "%skeleton", "%start", "%token-table", "%verbose",
514 "%yacc", "type", "=", ";", "|", "identifier", "identifier:", "%%",
515 "%{...%}", "epilogue", "{...}", "$accept", "input", "declarations",
516 "declaration", "grammar_declaration", "symbol_declaration", "@1", "@2",
517 "precedence_declaration", "precedence_declarator", "type.opt",
518 "symbols.1", "symbol_def", "symbol_defs.1", "grammar",
519 "rules_or_grammar_declaration", "rules", "@3", "rhses.1", "rhs",
520 "symbol", "action", "string_as_id", "string_content", "epilogue.opt", 0
521 };
522 #endif
523
524 /* INFRINGES ON USER NAME SPACE */
525 #ifndef _
526 # define _(msgid) msgid
527 #endif
528
529 # ifdef YYPRINT
530 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
531 token YYLEX-NUM. */
532 static const unsigned short int yytoknum[] =
533 {
534 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
535 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
536 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
537 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
538 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
539 305
540 };
541 # endif
542
543 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
544 static const unsigned char yyr1[] =
545 {
546 0, 51, 52, 53, 53, 54, 54, 54, 54, 54,
547 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
548 54, 54, 54, 54, 54, 54, 54, 54, 54, 55,
549 55, 55, 55, 55, 55, 55, 55, 57, 56, 58,
550 56, 56, 59, 60, 60, 60, 61, 61, 62, 62,
551 63, 63, 63, 63, 63, 64, 64, 65, 65, 66,
552 66, 66, 68, 67, 69, 69, 69, 70, 70, 70,
553 70, 70, 70, 71, 71, 72, 73, 74, 75, 75
554 };
555
556 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
557 static const unsigned char yyr2[] =
558 {
559 0, 2, 4, 0, 2, 1, 1, 1, 3, 1,
560 1, 2, 2, 3, 1, 1, 1, 1, 3, 1,
561 1, 3, 1, 1, 2, 1, 1, 1, 1, 1,
562 1, 2, 1, 2, 2, 1, 1, 0, 3, 0,
563 3, 3, 3, 1, 1, 1, 0, 1, 1, 2,
564 1, 1, 2, 2, 3, 1, 2, 1, 2, 1,
565 2, 2, 0, 3, 1, 3, 2, 0, 2, 2,
566 3, 3, 3, 1, 1, 1, 1, 1, 0, 2
567 };
568
569 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
570 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
571 means the default is an error. */
572 static const unsigned char yydefact[] =
573 {
574 3, 0, 0, 1, 39, 37, 0, 0, 0, 32,
575 43, 44, 45, 7, 35, 0, 9, 10, 0, 0,
576 0, 14, 15, 16, 17, 0, 36, 19, 20, 0,
577 22, 23, 0, 0, 25, 26, 27, 28, 0, 6,
578 4, 5, 30, 29, 46, 0, 0, 0, 76, 73,
579 33, 48, 74, 34, 77, 0, 11, 12, 0, 0,
580 0, 24, 31, 0, 62, 0, 0, 57, 59, 47,
581 0, 50, 51, 55, 40, 38, 41, 49, 8, 13,
582 18, 21, 61, 67, 60, 0, 58, 2, 42, 52,
583 53, 56, 63, 64, 79, 54, 66, 67, 0, 0,
584 0, 75, 68, 69, 65, 70, 71, 72
585 };
586
587 /* YYDEFGOTO[NTERM-NUM]. */
588 static const yysigned_char yydefgoto[] =
589 {
590 -1, 1, 2, 40, 65, 42, 46, 45, 43, 44,
591 70, 50, 73, 74, 66, 67, 68, 83, 92, 93,
592 51, 103, 52, 55, 87
593 };
594
595 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
596 STATE-NUM. */
597 #define YYPACT_NINF -67
598 static const yysigned_char yypact[] =
599 {
600 -67, 5, 110, -67, -67, -67, -34, 0, 0, -67,
601 -67, -67, -67, -67, -67, 13, -67, -67, 20, 31,
602 -17, -67, -67, -67, -67, -6, -67, -67, -67, -5,
603 -67, -67, 13, 0, -67, -67, -67, -67, 68, -67,
604 -67, -67, -67, -67, -3, -37, -37, 0, -67, -67,
605 0, -67, -67, 0, -67, 13, -67, -67, 13, 13,
606 13, -67, -67, -2, -67, 3, 21, -67, -67, -67,
607 0, -67, 6, -67, -37, -37, 0, -67, -67, -67,
608 -67, -67, -67, -67, -67, 1, -67, -67, 0, 39,
609 -67, -67, -32, -1, -67, -67, -67, -67, 0, 43,
610 7, -67, -67, -67, -1, -67, -67, -67
611 };
612
613 /* YYPGOTO[NTERM-NUM]. */
614 static const yysigned_char yypgoto[] =
615 {
616 -67, -67, -67, -67, 50, -67, -67, -67, -67, -67,
617 -67, -7, -56, 8, -67, -13, -67, -67, -67, -41,
618 -33, -67, -66, 29, -67
619 };
620
621 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
622 positive, shift that token. If negative, reduce the rule which
623 number is the opposite. If zero, do what YYDEFACT says.
624 If YYTABLE_NINF, syntax error. */
625 #define YYTABLE_NINF -79
626 static const yysigned_char yytable[] =
627 {
628 62, 53, 48, 48, 71, 3, 90, 47, 72, 48,
629 89, 96, 97, 98, 99, 100, 54, 77, 91, 91,
630 77, -78, 63, 95, 56, 58, 4, 5, 6, 7,
631 8, 9, 10, 11, 12, 57, 59, 60, 69, 14,
632 76, 82, 48, 77, 49, 49, 84, 106, 107, 101,
633 94, 26, 41, 86, 75, 77, 104, 0, 33, 0,
634 102, 61, 0, 88, 0, 105, 0, 64, 85, 63,
635 0, 102, 0, 4, 5, 6, 7, 8, 9, 10,
636 11, 12, 0, 0, 78, 0, 14, 79, 80, 81,
637 0, 0, 0, 0, 0, 0, 0, 0, 26, 0,
638 0, 0, 0, 0, 0, 33, 0, 0, 0, 0,
639 0, 0, 0, 0, 64, 4, 5, 6, 7, 8,
640 9, 10, 11, 12, 0, 0, 0, 13, 14, 15,
641 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
642 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
643 36, 0, 0, 37, 0, 0, 0, 38, 39
644 };
645
646 static const yysigned_char yycheck[] =
647 {
648 33, 8, 3, 3, 41, 0, 72, 41, 45, 3,
649 4, 43, 44, 14, 15, 16, 3, 50, 74, 75,
650 53, 0, 1, 89, 4, 42, 5, 6, 7, 8,
651 9, 10, 11, 12, 13, 4, 42, 42, 41, 18,
652 47, 43, 3, 76, 45, 45, 43, 4, 41, 50,
653 49, 30, 2, 66, 46, 88, 97, -1, 37, -1,
654 93, 32, -1, 70, -1, 98, -1, 46, 47, 1,
655 -1, 104, -1, 5, 6, 7, 8, 9, 10, 11,
656 12, 13, -1, -1, 55, -1, 18, 58, 59, 60,
657 -1, -1, -1, -1, -1, -1, -1, -1, 30, -1,
658 -1, -1, -1, -1, -1, 37, -1, -1, -1, -1,
659 -1, -1, -1, -1, 46, 5, 6, 7, 8, 9,
660 10, 11, 12, 13, -1, -1, -1, 17, 18, 19,
661 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
662 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
663 40, -1, -1, 43, -1, -1, -1, 47, 48
664 };
665
666 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
667 symbol of state STATE-NUM. */
668 static const unsigned char yystos[] =
669 {
670 0, 52, 53, 0, 5, 6, 7, 8, 9, 10,
671 11, 12, 13, 17, 18, 19, 20, 21, 22, 23,
672 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
673 34, 35, 36, 37, 38, 39, 40, 43, 47, 48,
674 54, 55, 56, 59, 60, 58, 57, 41, 3, 45,
675 62, 71, 73, 62, 3, 74, 4, 4, 42, 42,
676 42, 74, 71, 1, 46, 55, 65, 66, 67, 41,
677 61, 41, 45, 63, 64, 64, 62, 71, 74, 74,
678 74, 74, 43, 68, 43, 47, 66, 75, 62, 4,
679 73, 63, 69, 70, 49, 73, 43, 44, 14, 15,
680 16, 50, 71, 72, 70, 71, 4, 41
681 };
682
683 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
684 # define YYSIZE_T __SIZE_TYPE__
685 #endif
686 #if ! defined (YYSIZE_T) && defined (size_t)
687 # define YYSIZE_T size_t
688 #endif
689 #if ! defined (YYSIZE_T)
690 # if defined (__STDC__) || defined (__cplusplus)
691 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
692 # define YYSIZE_T size_t
693 # endif
694 #endif
695 #if ! defined (YYSIZE_T)
696 # define YYSIZE_T unsigned int
697 #endif
698
699 #define yyerrok (yyerrstatus = 0)
700 #define yyclearin (yychar = YYEMPTY)
701 #define YYEMPTY (-2)
702 #define YYEOF 0
703
704 #define YYACCEPT goto yyacceptlab
705 #define YYABORT goto yyabortlab
706 #define YYERROR goto yyerrorlab
707
708
709 /* Like YYERROR except do call yyerror. This remains here temporarily
710 to ease the transition to the new meaning of YYERROR, for GCC.
711 Once GCC version 2 has supplanted version 1, this can go. */
712
713 #define YYFAIL goto yyerrlab
714
715 #define YYRECOVERING() (!!yyerrstatus)
716
717 #define YYBACKUP(Token, Value) \
718 do \
719 if (yychar == YYEMPTY && yylen == 1) \
720 { \
721 yychar = (Token); \
722 yylval = (Value); \
723 yytoken = YYTRANSLATE (yychar); \
724 YYPOPSTACK; \
725 goto yybackup; \
726 } \
727 else \
728 { \
729 yyerror (_("syntax error: cannot back up")); \
730 YYERROR; \
731 } \
732 while (0)
733
734
735 #define YYTERROR 1
736 #define YYERRCODE 256
737
738
739 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
740 If N is 0, then set CURRENT to the empty location which ends
741 the previous symbol: RHS[0] (always defined). */
742
743 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
744 #ifndef YYLLOC_DEFAULT
745 # define YYLLOC_DEFAULT(Current, Rhs, N) \
746 do \
747 if (N) \
748 { \
749 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
750 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
751 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
752 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
753 } \
754 else \
755 { \
756 (Current).first_line = (Current).last_line = \
757 YYRHSLOC (Rhs, 0).last_line; \
758 (Current).first_column = (Current).last_column = \
759 YYRHSLOC (Rhs, 0).last_column; \
760 } \
761 while (0)
762 #endif
763
764
765 /* YY_LOCATION_PRINT -- Print the location on the stream.
766 This macro was not mandated originally: define only if we know
767 we won't break user code: when these are the locations we know. */
768
769 #ifndef YY_LOCATION_PRINT
770 # if YYLTYPE_IS_TRIVIAL
771 # define YY_LOCATION_PRINT(File, Loc) \
772 fprintf (File, "%d.%d-%d.%d", \
773 (Loc).first_line, (Loc).first_column, \
774 (Loc).last_line, (Loc).last_column)
775 # else
776 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
777 # endif
778 #endif
779
780
781 /* YYLEX -- calling `yylex' with the right arguments. */
782
783 #ifdef YYLEX_PARAM
784 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
785 #else
786 # define YYLEX yylex (&yylval, &yylloc)
787 #endif
788
789 /* Enable debugging if requested. */
790 #if YYDEBUG
791
792 # ifndef YYFPRINTF
793 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
794 # define YYFPRINTF fprintf
795 # endif
796
797 # define YYDPRINTF(Args) \
798 do { \
799 if (yydebug) \
800 YYFPRINTF Args; \
801 } while (0)
802
803 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
804 do { \
805 if (yydebug) \
806 { \
807 YYFPRINTF (stderr, "%s ", Title); \
808 yysymprint (stderr, \
809 Type, Value, Location); \
810 YYFPRINTF (stderr, "\n"); \
811 } \
812 } while (0)
813
814 /*------------------------------------------------------------------.
815 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
816 | TOP (included). |
817 `------------------------------------------------------------------*/
818
819 #if defined (__STDC__) || defined (__cplusplus)
820 static void
821 yy_stack_print (short int *bottom, short int *top)
822 #else
823 static void
824 yy_stack_print (bottom, top)
825 short int *bottom;
826 short int *top;
827 #endif
828 {
829 YYFPRINTF (stderr, _("Stack now"));
830 for (/* Nothing. */; bottom <= top; ++bottom)
831 YYFPRINTF (stderr, " %d", *bottom);
832 YYFPRINTF (stderr, "\n");
833 }
834
835 # define YY_STACK_PRINT(Bottom, Top) \
836 do { \
837 if (yydebug) \
838 yy_stack_print ((Bottom), (Top)); \
839 } while (0)
840
841
842 /*------------------------------------------------.
843 | Report that the YYRULE is going to be reduced. |
844 `------------------------------------------------*/
845
846 #if defined (__STDC__) || defined (__cplusplus)
847 static void
848 yy_reduce_print (int yyrule)
849 #else
850 static void
851 yy_reduce_print (yyrule)
852 int yyrule;
853 #endif
854 {
855 int yyi;
856 unsigned int yylno = yyrline[yyrule];
857 YYFPRINTF (stderr, _("Reducing stack by rule %d (line %u), "),
858 yyrule - 1, yylno);
859 /* Print the symbols being reduced, and their result. */
860 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
861 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
862 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
863 }
864
865 # define YY_REDUCE_PRINT(Rule) \
866 do { \
867 if (yydebug) \
868 yy_reduce_print (Rule); \
869 } while (0)
870
871 /* Nonzero means print parse trace. It is left uninitialized so that
872 multiple parsers can coexist. */
873 int yydebug;
874 #else /* !YYDEBUG */
875 # define YYDPRINTF(Args)
876 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
877 # define YY_STACK_PRINT(Bottom, Top)
878 # define YY_REDUCE_PRINT(Rule)
879 #endif /* !YYDEBUG */
880
881
882 /* YYINITDEPTH -- initial size of the parser's stacks. */
883 #ifndef YYINITDEPTH
884 # define YYINITDEPTH 200
885 #endif
886
887 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
888 if the built-in stack extension method is used).
889
890 Do not make this value too large; the results are undefined if
891 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
892 evaluated with infinite-precision integer arithmetic. */
893
894 #ifndef YYMAXDEPTH
895 # define YYMAXDEPTH 10000
896 #endif
897
898 \f
899
900 #if YYERROR_VERBOSE
901
902 # ifndef yystrlen
903 # if defined (__GLIBC__) && defined (_STRING_H)
904 # define yystrlen strlen
905 # else
906 /* Return the length of YYSTR. */
907 static YYSIZE_T
908 # if defined (__STDC__) || defined (__cplusplus)
909 yystrlen (const char *yystr)
910 # else
911 yystrlen (yystr)
912 const char *yystr;
913 # endif
914 {
915 const char *yys = yystr;
916
917 while (*yys++ != '\0')
918 continue;
919
920 return yys - yystr - 1;
921 }
922 # endif
923 # endif
924
925 # ifndef yystpcpy
926 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
927 # define yystpcpy stpcpy
928 # else
929 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
930 YYDEST. */
931 static char *
932 # if defined (__STDC__) || defined (__cplusplus)
933 yystpcpy (char *yydest, const char *yysrc)
934 # else
935 yystpcpy (yydest, yysrc)
936 char *yydest;
937 const char *yysrc;
938 # endif
939 {
940 char *yyd = yydest;
941 const char *yys = yysrc;
942
943 while ((*yyd++ = *yys++) != '\0')
944 continue;
945
946 return yyd - 1;
947 }
948 # endif
949 # endif
950
951 #endif /* !YYERROR_VERBOSE */
952
953 \f
954
955 #if YYDEBUG
956 /*--------------------------------.
957 | Print this symbol on YYOUTPUT. |
958 `--------------------------------*/
959
960 #if defined (__STDC__) || defined (__cplusplus)
961 static void
962 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
963 #else
964 static void
965 yysymprint (yyoutput, yytype, yyvaluep, yylocationp)
966 FILE *yyoutput;
967 int yytype;
968 YYSTYPE *yyvaluep;
969 YYLTYPE *yylocationp;
970 #endif
971 {
972 /* Pacify ``unused variable'' warnings. */
973 (void) yyvaluep;
974 (void) yylocationp;
975
976 if (yytype < YYNTOKENS)
977 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
978 else
979 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
980
981 YY_LOCATION_PRINT (yyoutput, *yylocationp);
982 fprintf (yyoutput, ": ");
983
984 # ifdef YYPRINT
985 if (yytype < YYNTOKENS)
986 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
987 # endif
988 switch (yytype)
989 {
990 default:
991 break;
992 }
993 YYFPRINTF (yyoutput, ")");
994 }
995
996 #endif /* ! YYDEBUG */
997 /*-----------------------------------------------.
998 | Release the memory associated to this symbol. |
999 `-----------------------------------------------*/
1000
1001 #if defined (__STDC__) || defined (__cplusplus)
1002 static void
1003 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1004 #else
1005 static void
1006 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
1007 const char *yymsg;
1008 int yytype;
1009 YYSTYPE *yyvaluep;
1010 YYLTYPE *yylocationp;
1011 #endif
1012 {
1013 /* Pacify ``unused variable'' warnings. */
1014 (void) yyvaluep;
1015 (void) yylocationp;
1016
1017 if (!yymsg)
1018 yymsg = "Deleting";
1019 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1020
1021 switch (yytype)
1022 {
1023
1024 default:
1025 break;
1026 }
1027 }
1028 \f
1029
1030 /* Prevent warnings from -Wmissing-prototypes. */
1031
1032 #ifdef YYPARSE_PARAM
1033 # if defined (__STDC__) || defined (__cplusplus)
1034 int yyparse (void *YYPARSE_PARAM);
1035 # else
1036 int yyparse ();
1037 # endif
1038 #else /* ! YYPARSE_PARAM */
1039 #if defined (__STDC__) || defined (__cplusplus)
1040 int yyparse (void);
1041 #else
1042 int yyparse ();
1043 #endif
1044 #endif /* ! YYPARSE_PARAM */
1045
1046
1047
1048
1049
1050
1051 /*----------.
1052 | yyparse. |
1053 `----------*/
1054
1055 #ifdef YYPARSE_PARAM
1056 # if defined (__STDC__) || defined (__cplusplus)
1057 int yyparse (void *YYPARSE_PARAM)
1058 # else
1059 int yyparse (YYPARSE_PARAM)
1060 void *YYPARSE_PARAM;
1061 # endif
1062 #else /* ! YYPARSE_PARAM */
1063 #if defined (__STDC__) || defined (__cplusplus)
1064 int
1065 yyparse (void)
1066 #else
1067 int
1068 yyparse ()
1069
1070 #endif
1071 #endif
1072 {
1073 /* The look-ahead symbol. */
1074 int yychar;
1075
1076 /* The semantic value of the look-ahead symbol. */
1077 YYSTYPE yylval;
1078
1079 /* Number of syntax errors so far. */
1080 int yynerrs;
1081 /* Location data for the look-ahead symbol. */
1082 YYLTYPE yylloc;
1083
1084 int yystate;
1085 int yyn;
1086 int yyresult;
1087 /* Number of tokens to shift before error messages enabled. */
1088 int yyerrstatus;
1089 /* Look-ahead token as an internal (translated) token number. */
1090 int yytoken = 0;
1091
1092 /* Three stacks and their tools:
1093 `yyss': related to states,
1094 `yyvs': related to semantic values,
1095 `yyls': related to locations.
1096
1097 Refer to the stacks thru separate pointers, to allow yyoverflow
1098 to reallocate them elsewhere. */
1099
1100 /* The state stack. */
1101 short int yyssa[YYINITDEPTH];
1102 short int *yyss = yyssa;
1103 short int *yyssp;
1104
1105 /* The semantic value stack. */
1106 YYSTYPE yyvsa[YYINITDEPTH];
1107 YYSTYPE *yyvs = yyvsa;
1108 YYSTYPE *yyvsp;
1109
1110 /* The location stack. */
1111 YYLTYPE yylsa[YYINITDEPTH];
1112 YYLTYPE *yyls = yylsa;
1113 YYLTYPE *yylsp;
1114 /* The locations where the error started and ended. */
1115 YYLTYPE yyerror_range[2];
1116
1117 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
1118
1119 YYSIZE_T yystacksize = YYINITDEPTH;
1120
1121 /* The variables used to return semantic value and location from the
1122 action routines. */
1123 YYSTYPE yyval;
1124 YYLTYPE yyloc;
1125
1126 /* When reducing, the number of symbols on the RHS of the reduced
1127 rule. */
1128 int yylen;
1129
1130 YYDPRINTF ((stderr, "Starting parse\n"));
1131
1132 yystate = 0;
1133 yyerrstatus = 0;
1134 yynerrs = 0;
1135 yychar = YYEMPTY; /* Cause a token to be read. */
1136
1137 /* Initialize stack pointers.
1138 Waste one element of value and location stack
1139 so that they stay on the same level as the state stack.
1140 The wasted elements are never initialized. */
1141
1142 yyssp = yyss;
1143 yyvsp = yyvs;
1144 yylsp = yyls;
1145 #if YYLTYPE_IS_TRIVIAL
1146 /* Initialize the default location before parsing starts. */
1147 yylloc.first_line = yylloc.last_line = 1;
1148 yylloc.first_column = yylloc.last_column = 0;
1149 #endif
1150
1151
1152 /* User initialization code. */
1153 #line 72 "parse-gram.y"
1154 {
1155 /* Bison's grammar can initial empty locations, hence a default
1156 location is needed. */
1157 yylloc.start.file = yylloc.end.file = current_file;
1158 yylloc.start.line = yylloc.end.line = 1;
1159 yylloc.start.column = yylloc.end.column = 0;
1160 }
1161 /* Line 856 of yacc.c. */
1162 #line 1163 "parse-gram.c"
1163 yyvsp[0] = yylval;
1164 yylsp[0] = yylloc;
1165
1166 goto yysetstate;
1167
1168 /*------------------------------------------------------------.
1169 | yynewstate -- Push a new state, which is found in yystate. |
1170 `------------------------------------------------------------*/
1171 yynewstate:
1172 /* In all cases, when you get here, the value and location stacks
1173 have just been pushed. so pushing a state here evens the stacks.
1174 */
1175 yyssp++;
1176
1177 yysetstate:
1178 *yyssp = yystate;
1179
1180 if (yyss + yystacksize - 1 <= yyssp)
1181 {
1182 /* Get the current used size of the three stacks, in elements. */
1183 YYSIZE_T yysize = yyssp - yyss + 1;
1184
1185 #ifdef yyoverflow
1186 {
1187 /* Give user a chance to reallocate the stack. Use copies of
1188 these so that the &'s don't force the real ones into
1189 memory. */
1190 YYSTYPE *yyvs1 = yyvs;
1191 short int *yyss1 = yyss;
1192 YYLTYPE *yyls1 = yyls;
1193
1194 /* Each stack pointer address is followed by the size of the
1195 data in use in that stack, in bytes. This used to be a
1196 conditional around just the two extra args, but that might
1197 be undefined if yyoverflow is a macro. */
1198 yyoverflow (_("parser stack overflow"),
1199 &yyss1, yysize * sizeof (*yyssp),
1200 &yyvs1, yysize * sizeof (*yyvsp),
1201 &yyls1, yysize * sizeof (*yylsp),
1202 &yystacksize);
1203 yyls = yyls1;
1204 yyss = yyss1;
1205 yyvs = yyvs1;
1206 }
1207 #else /* no yyoverflow */
1208 # ifndef YYSTACK_RELOCATE
1209 goto yyoverflowlab;
1210 # else
1211 /* Extend the stack our own way. */
1212 if (YYMAXDEPTH <= yystacksize)
1213 goto yyoverflowlab;
1214 yystacksize *= 2;
1215 if (YYMAXDEPTH < yystacksize)
1216 yystacksize = YYMAXDEPTH;
1217
1218 {
1219 short int *yyss1 = yyss;
1220 union yyalloc *yyptr =
1221 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1222 if (! yyptr)
1223 goto yyoverflowlab;
1224 YYSTACK_RELOCATE (yyss);
1225 YYSTACK_RELOCATE (yyvs);
1226 YYSTACK_RELOCATE (yyls);
1227 # undef YYSTACK_RELOCATE
1228 if (yyss1 != yyssa)
1229 YYSTACK_FREE (yyss1);
1230 }
1231 # endif
1232 #endif /* no yyoverflow */
1233
1234 yyssp = yyss + yysize - 1;
1235 yyvsp = yyvs + yysize - 1;
1236 yylsp = yyls + yysize - 1;
1237
1238 YYDPRINTF ((stderr, _("Stack size increased to %lu\n"),
1239 (unsigned long int) yystacksize));
1240
1241 if (yyss + yystacksize - 1 <= yyssp)
1242 YYABORT;
1243 }
1244
1245 YYDPRINTF ((stderr, _("Entering state %d\n"), yystate));
1246
1247 goto yybackup;
1248
1249 /*-----------.
1250 | yybackup. |
1251 `-----------*/
1252 yybackup:
1253
1254 /* Do appropriate processing given the current state. */
1255 /* Read a look-ahead token if we need one and don't already have one. */
1256 /* yyresume: */
1257
1258 /* First try to decide what to do without reference to look-ahead token. */
1259
1260 yyn = yypact[yystate];
1261 if (yyn == YYPACT_NINF)
1262 goto yydefault;
1263
1264 /* Not known => get a look-ahead token if don't already have one. */
1265
1266 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1267 if (yychar == YYEMPTY)
1268 {
1269 YYDPRINTF ((stderr, _("Reading a token: ")));
1270 yychar = YYLEX;
1271 }
1272
1273 if (yychar <= YYEOF)
1274 {
1275 yychar = yytoken = YYEOF;
1276 YYDPRINTF ((stderr, _("Now at end of input.\n")));
1277 }
1278 else
1279 {
1280 yytoken = YYTRANSLATE (yychar);
1281 YY_SYMBOL_PRINT (_("Next token is"), yytoken, &yylval, &yylloc);
1282 }
1283
1284 /* If the proper action on seeing token YYTOKEN is to reduce or to
1285 detect an error, take that action. */
1286 yyn += yytoken;
1287 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1288 goto yydefault;
1289 yyn = yytable[yyn];
1290 if (yyn <= 0)
1291 {
1292 if (yyn == 0 || yyn == YYTABLE_NINF)
1293 goto yyerrlab;
1294 yyn = -yyn;
1295 goto yyreduce;
1296 }
1297
1298 if (yyn == YYFINAL)
1299 YYACCEPT;
1300
1301 /* Shift the look-ahead token. */
1302 YY_SYMBOL_PRINT (_("Shifting"), yytoken, &yylval, &yylloc);
1303
1304 /* Discard the token being shifted unless it is eof. */
1305 if (yychar != YYEOF)
1306 yychar = YYEMPTY;
1307
1308 *++yyvsp = yylval;
1309 *++yylsp = yylloc;
1310
1311 /* Count tokens shifted since error; after three, turn off error
1312 status. */
1313 if (yyerrstatus)
1314 yyerrstatus--;
1315
1316 yystate = yyn;
1317 goto yynewstate;
1318
1319
1320 /*-----------------------------------------------------------.
1321 | yydefault -- do the default action for the current state. |
1322 `-----------------------------------------------------------*/
1323 yydefault:
1324 yyn = yydefact[yystate];
1325 if (yyn == 0)
1326 goto yyerrlab;
1327 goto yyreduce;
1328
1329
1330 /*-----------------------------.
1331 | yyreduce -- Do a reduction. |
1332 `-----------------------------*/
1333 yyreduce:
1334 /* yyn is the number of a rule to reduce with. */
1335 yylen = yyr2[yyn];
1336
1337 /* If YYLEN is nonzero, implement the default value of the action:
1338 `$$ = $1'.
1339
1340 Otherwise, the following line sets YYVAL to garbage.
1341 This behavior is undocumented and Bison
1342 users should not rely upon it. Assigning to YYVAL
1343 unconditionally makes the parser a bit smaller, and it avoids a
1344 GCC warning that YYVAL may be used uninitialized. */
1345 yyval = yyvsp[1-yylen];
1346
1347 /* Default location. */
1348 YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
1349 YY_REDUCE_PRINT (yyn);
1350 switch (yyn)
1351 {
1352 case 6:
1353 #line 190 "parse-gram.y"
1354 { prologue_augment ((yyvsp[0].chars), (yylsp[0])); }
1355 break;
1356
1357 case 7:
1358 #line 191 "parse-gram.y"
1359 { debug_flag = true; }
1360 break;
1361
1362 case 8:
1363 #line 192 "parse-gram.y"
1364 { muscle_insert ((yyvsp[-1].chars), (yyvsp[0].chars)); }
1365 break;
1366
1367 case 9:
1368 #line 193 "parse-gram.y"
1369 { defines_flag = true; }
1370 break;
1371
1372 case 10:
1373 #line 194 "parse-gram.y"
1374 { error_verbose = true; }
1375 break;
1376
1377 case 11:
1378 #line 195 "parse-gram.y"
1379 { expected_sr_conflicts = (yyvsp[0].integer); }
1380 break;
1381
1382 case 12:
1383 #line 196 "parse-gram.y"
1384 { expected_rr_conflicts = (yyvsp[0].integer); }
1385 break;
1386
1387 case 13:
1388 #line 197 "parse-gram.y"
1389 { spec_file_prefix = (yyvsp[0].chars); }
1390 break;
1391
1392 case 14:
1393 #line 199 "parse-gram.y"
1394 {
1395 nondeterministic_parser = true;
1396 glr_parser = true;
1397 }
1398 break;
1399
1400 case 15:
1401 #line 204 "parse-gram.y"
1402 {
1403 muscle_code_grow ("initial_action", (yyvsp[0].chars), (yylsp[0]));
1404 }
1405 break;
1406
1407 case 16:
1408 #line 207 "parse-gram.y"
1409 { add_param ("lex_param", (yyvsp[0].chars), (yylsp[0])); }
1410 break;
1411
1412 case 17:
1413 #line 208 "parse-gram.y"
1414 { locations_flag = true; }
1415 break;
1416
1417 case 18:
1418 #line 209 "parse-gram.y"
1419 { spec_name_prefix = (yyvsp[0].chars); }
1420 break;
1421
1422 case 19:
1423 #line 210 "parse-gram.y"
1424 { no_lines_flag = true; }
1425 break;
1426
1427 case 20:
1428 #line 211 "parse-gram.y"
1429 { nondeterministic_parser = true; }
1430 break;
1431
1432 case 21:
1433 #line 212 "parse-gram.y"
1434 { spec_outfile = (yyvsp[0].chars); }
1435 break;
1436
1437 case 22:
1438 #line 213 "parse-gram.y"
1439 { add_param ("parse_param", (yyvsp[0].chars), (yylsp[0])); }
1440 break;
1441
1442 case 23:
1443 #line 214 "parse-gram.y"
1444 { pure_parser = true; }
1445 break;
1446
1447 case 24:
1448 #line 215 "parse-gram.y"
1449 { skeleton = (yyvsp[0].chars); }
1450 break;
1451
1452 case 25:
1453 #line 216 "parse-gram.y"
1454 { token_table_flag = true; }
1455 break;
1456
1457 case 26:
1458 #line 217 "parse-gram.y"
1459 { report_flag = report_states; }
1460 break;
1461
1462 case 27:
1463 #line 218 "parse-gram.y"
1464 { yacc_flag = true; }
1465 break;
1466
1467 case 31:
1468 #line 226 "parse-gram.y"
1469 {
1470 grammar_start_symbol_set ((yyvsp[0].symbol), (yylsp[0]));
1471 }
1472 break;
1473
1474 case 32:
1475 #line 230 "parse-gram.y"
1476 {
1477 typed = true;
1478 MUSCLE_INSERT_INT ("stype_line", (yylsp[0]).start.line);
1479 muscle_insert ("stype", (yyvsp[0].chars));
1480 }
1481 break;
1482
1483 case 33:
1484 #line 236 "parse-gram.y"
1485 {
1486 symbol_list *list;
1487 for (list = (yyvsp[0].list); list; list = list->next)
1488 symbol_destructor_set (list->sym, (yyvsp[-1].chars), (yylsp[-1]));
1489 symbol_list_free ((yyvsp[0].list));
1490 }
1491 break;
1492
1493 case 34:
1494 #line 243 "parse-gram.y"
1495 {
1496 symbol_list *list;
1497 for (list = (yyvsp[0].list); list; list = list->next)
1498 symbol_printer_set (list->sym, (yyvsp[-1].chars), list->location);
1499 symbol_list_free ((yyvsp[0].list));
1500 }
1501 break;
1502
1503 case 35:
1504 #line 250 "parse-gram.y"
1505 {
1506 default_prec = true;
1507 }
1508 break;
1509
1510 case 36:
1511 #line 254 "parse-gram.y"
1512 {
1513 default_prec = false;
1514 }
1515 break;
1516
1517 case 37:
1518 #line 260 "parse-gram.y"
1519 { current_class = nterm_sym; }
1520 break;
1521
1522 case 38:
1523 #line 261 "parse-gram.y"
1524 {
1525 current_class = unknown_sym;
1526 current_type = NULL;
1527 }
1528 break;
1529
1530 case 39:
1531 #line 265 "parse-gram.y"
1532 { current_class = token_sym; }
1533 break;
1534
1535 case 40:
1536 #line 266 "parse-gram.y"
1537 {
1538 current_class = unknown_sym;
1539 current_type = NULL;
1540 }
1541 break;
1542
1543 case 41:
1544 #line 271 "parse-gram.y"
1545 {
1546 symbol_list *list;
1547 for (list = (yyvsp[0].list); list; list = list->next)
1548 symbol_type_set (list->sym, (yyvsp[-1].uniqstr), (yylsp[-1]));
1549 symbol_list_free ((yyvsp[0].list));
1550 }
1551 break;
1552
1553 case 42:
1554 #line 281 "parse-gram.y"
1555 {
1556 symbol_list *list;
1557 ++current_prec;
1558 for (list = (yyvsp[0].list); list; list = list->next)
1559 {
1560 symbol_type_set (list->sym, current_type, (yylsp[-1]));
1561 symbol_precedence_set (list->sym, current_prec, (yyvsp[-2].assoc), (yylsp[-2]));
1562 }
1563 symbol_list_free ((yyvsp[0].list));
1564 current_type = NULL;
1565 }
1566 break;
1567
1568 case 43:
1569 #line 295 "parse-gram.y"
1570 { (yyval.assoc) = left_assoc; }
1571 break;
1572
1573 case 44:
1574 #line 296 "parse-gram.y"
1575 { (yyval.assoc) = right_assoc; }
1576 break;
1577
1578 case 45:
1579 #line 297 "parse-gram.y"
1580 { (yyval.assoc) = non_assoc; }
1581 break;
1582
1583 case 46:
1584 #line 301 "parse-gram.y"
1585 { current_type = NULL; }
1586 break;
1587
1588 case 47:
1589 #line 302 "parse-gram.y"
1590 { current_type = (yyvsp[0].uniqstr); }
1591 break;
1592
1593 case 48:
1594 #line 308 "parse-gram.y"
1595 { (yyval.list) = symbol_list_new ((yyvsp[0].symbol), (yylsp[0])); }
1596 break;
1597
1598 case 49:
1599 #line 309 "parse-gram.y"
1600 { (yyval.list) = symbol_list_prepend ((yyvsp[-1].list), (yyvsp[0].symbol), (yylsp[0])); }
1601 break;
1602
1603 case 50:
1604 #line 315 "parse-gram.y"
1605 {
1606 current_type = (yyvsp[0].uniqstr);
1607 }
1608 break;
1609
1610 case 51:
1611 #line 319 "parse-gram.y"
1612 {
1613 symbol_class_set ((yyvsp[0].symbol), current_class, (yylsp[0]));
1614 symbol_type_set ((yyvsp[0].symbol), current_type, (yylsp[0]));
1615 }
1616 break;
1617
1618 case 52:
1619 #line 324 "parse-gram.y"
1620 {
1621 symbol_class_set ((yyvsp[-1].symbol), current_class, (yylsp[-1]));
1622 symbol_type_set ((yyvsp[-1].symbol), current_type, (yylsp[-1]));
1623 symbol_user_token_number_set ((yyvsp[-1].symbol), (yyvsp[0].integer), (yylsp[0]));
1624 }
1625 break;
1626
1627 case 53:
1628 #line 330 "parse-gram.y"
1629 {
1630 symbol_class_set ((yyvsp[-1].symbol), current_class, (yylsp[-1]));
1631 symbol_type_set ((yyvsp[-1].symbol), current_type, (yylsp[-1]));
1632 symbol_make_alias ((yyvsp[-1].symbol), (yyvsp[0].symbol), (yyloc));
1633 }
1634 break;
1635
1636 case 54:
1637 #line 336 "parse-gram.y"
1638 {
1639 symbol_class_set ((yyvsp[-2].symbol), current_class, (yylsp[-2]));
1640 symbol_type_set ((yyvsp[-2].symbol), current_type, (yylsp[-2]));
1641 symbol_user_token_number_set ((yyvsp[-2].symbol), (yyvsp[-1].integer), (yylsp[-1]));
1642 symbol_make_alias ((yyvsp[-2].symbol), (yyvsp[0].symbol), (yyloc));
1643 }
1644 break;
1645
1646 case 60:
1647 #line 365 "parse-gram.y"
1648 {
1649 if (yacc_flag)
1650 complain_at ((yyloc), _("POSIX forbids declarations in the grammar"));
1651 }
1652 break;
1653
1654 case 61:
1655 #line 370 "parse-gram.y"
1656 {
1657 yyerrok;
1658 }
1659 break;
1660
1661 case 62:
1662 #line 376 "parse-gram.y"
1663 { current_lhs = (yyvsp[0].symbol); current_lhs_location = (yylsp[0]); }
1664 break;
1665
1666 case 64:
1667 #line 380 "parse-gram.y"
1668 { grammar_rule_end ((yylsp[0])); }
1669 break;
1670
1671 case 65:
1672 #line 381 "parse-gram.y"
1673 { grammar_rule_end ((yylsp[0])); }
1674 break;
1675
1676 case 67:
1677 #line 387 "parse-gram.y"
1678 { grammar_rule_begin (current_lhs, current_lhs_location); }
1679 break;
1680
1681 case 68:
1682 #line 389 "parse-gram.y"
1683 { grammar_current_rule_symbol_append ((yyvsp[0].symbol), (yylsp[0])); }
1684 break;
1685
1686 case 69:
1687 #line 391 "parse-gram.y"
1688 { grammar_current_rule_action_append ((yyvsp[0].chars), (yylsp[0])); }
1689 break;
1690
1691 case 70:
1692 #line 393 "parse-gram.y"
1693 { grammar_current_rule_prec_set ((yyvsp[0].symbol), (yylsp[0])); }
1694 break;
1695
1696 case 71:
1697 #line 395 "parse-gram.y"
1698 { grammar_current_rule_dprec_set ((yyvsp[0].integer), (yylsp[0])); }
1699 break;
1700
1701 case 72:
1702 #line 397 "parse-gram.y"
1703 { grammar_current_rule_merge_set ((yyvsp[0].uniqstr), (yylsp[0])); }
1704 break;
1705
1706 case 73:
1707 #line 401 "parse-gram.y"
1708 { (yyval.symbol) = (yyvsp[0].symbol); }
1709 break;
1710
1711 case 74:
1712 #line 402 "parse-gram.y"
1713 { (yyval.symbol) = (yyvsp[0].symbol); }
1714 break;
1715
1716 case 75:
1717 #line 407 "parse-gram.y"
1718 { (yyval.chars) = (yyvsp[0].chars); }
1719 break;
1720
1721 case 76:
1722 #line 413 "parse-gram.y"
1723 {
1724 (yyval.symbol) = symbol_get (quotearg_style (c_quoting_style, (yyvsp[0].chars)), (yylsp[0]));
1725 symbol_class_set ((yyval.symbol), token_sym, (yylsp[0]));
1726 }
1727 break;
1728
1729 case 77:
1730 #line 422 "parse-gram.y"
1731 { (yyval.chars) = (yyvsp[0].chars); }
1732 break;
1733
1734 case 79:
1735 #line 429 "parse-gram.y"
1736 {
1737 muscle_code_grow ("epilogue", (yyvsp[0].chars), (yylsp[0]));
1738 scanner_last_string_free ();
1739 }
1740 break;
1741
1742
1743 default: break;
1744 }
1745
1746 /* Line 1052 of yacc.c. */
1747 #line 1748 "parse-gram.c"
1748 \f
1749 yyvsp -= yylen;
1750 yyssp -= yylen;
1751 yylsp -= yylen;
1752
1753 YY_STACK_PRINT (yyss, yyssp);
1754
1755 *++yyvsp = yyval;
1756 *++yylsp = yyloc;
1757
1758 /* Now `shift' the result of the reduction. Determine what state
1759 that goes to, based on the state we popped back to and the rule
1760 number reduced by. */
1761
1762 yyn = yyr1[yyn];
1763
1764 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1765 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1766 yystate = yytable[yystate];
1767 else
1768 yystate = yydefgoto[yyn - YYNTOKENS];
1769
1770 goto yynewstate;
1771
1772
1773 /*------------------------------------.
1774 | yyerrlab -- here on detecting error |
1775 `------------------------------------*/
1776 yyerrlab:
1777 /* If not already recovering from an error, report this error. */
1778 if (!yyerrstatus)
1779 {
1780 ++yynerrs;
1781 #if YYERROR_VERBOSE
1782 yyn = yypact[yystate];
1783
1784 if (YYPACT_NINF < yyn && yyn < YYLAST)
1785 {
1786 int yytype = YYTRANSLATE (yychar);
1787 YYSIZE_T yysize0 = yystrlen (yytname[yytype]);
1788 YYSIZE_T yysize = yysize0;
1789 YYSIZE_T yysize1;
1790 int yysize_overflow = 0;
1791 char *yymsg = 0;
1792 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
1793 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1794 int yyx;
1795
1796 #if 0
1797 /* This is so xgettext sees the translatable formats that are
1798 constructed on the fly. */
1799 _("syntax error, unexpected %s");
1800 _("syntax error, unexpected %s, expecting %s");
1801 _("syntax error, unexpected %s, expecting %s or %s");
1802 _("syntax error, unexpected %s, expecting %s or %s or %s");
1803 _("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1804 #endif
1805 char *yyfmt;
1806 char const *yyf;
1807 static char const yyunexpected[] = "syntax error, unexpected %s";
1808 static char const yyexpecting[] = ", expecting %s";
1809 static char const yyor[] = " or %s";
1810 char yyformat[sizeof yyunexpected
1811 + sizeof yyexpecting - 1
1812 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1813 * (sizeof yyor - 1))];
1814 char const *yyprefix = yyexpecting;
1815
1816 /* Start YYX at -YYN if negative to avoid negative indexes in
1817 YYCHECK. */
1818 int yyxbegin = yyn < 0 ? -yyn : 0;
1819
1820 /* Stay within bounds of both yycheck and yytname. */
1821 int yychecklim = YYLAST - yyn;
1822 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1823 int yycount = 1;
1824
1825 yyarg[0] = yytname[yytype];
1826 yyfmt = yystpcpy (yyformat, yyunexpected);
1827
1828 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1829 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1830 {
1831 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1832 {
1833 yycount = 1;
1834 yysize = yysize0;
1835 yyformat[sizeof yyunexpected - 1] = '\0';
1836 break;
1837 }
1838 yyarg[yycount++] = yytname[yyx];
1839 yysize1 = yysize + yystrlen (yytname[yyx]);
1840 yysize_overflow |= yysize1 < yysize;
1841 yysize = yysize1;
1842 yyfmt = yystpcpy (yyfmt, yyprefix);
1843 yyprefix = yyor;
1844 }
1845
1846 yyf = _(yyformat);
1847 yysize1 = yysize + strlen (yyf);
1848 yysize_overflow |= yysize1 < yysize;
1849 yysize = yysize1;
1850
1851 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
1852 yymsg = (char *) YYSTACK_ALLOC (yysize);
1853 if (yymsg)
1854 {
1855 /* Avoid sprintf, as that infringes on the user's name space.
1856 Don't have undefined behavior even if the translation
1857 produced a string with the wrong number of "%s"s. */
1858 char *yyp = yymsg;
1859 int yyi = 0;
1860 while ((*yyp = *yyf))
1861 {
1862 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1863 {
1864 yyp = yystpcpy (yyp, yyarg[yyi++]);
1865 yyf += 2;
1866 }
1867 else
1868 {
1869 yyp++;
1870 yyf++;
1871 }
1872 }
1873 yyerror (yymsg);
1874 YYSTACK_FREE (yymsg);
1875 }
1876 else
1877 yyerror (_("syntax error; also memory exhausted"));
1878 }
1879 else
1880 #endif /* YYERROR_VERBOSE */
1881 yyerror (_("syntax error"));
1882 }
1883
1884 yyerror_range[0] = yylloc;
1885
1886 if (yyerrstatus == 3)
1887 {
1888 /* If just tried and failed to reuse look-ahead token after an
1889 error, discard it. */
1890
1891 if (yychar <= YYEOF)
1892 {
1893 /* If at end of input, pop the error token,
1894 then the rest of the stack, then return failure. */
1895 if (yychar == YYEOF)
1896 for (;;)
1897 {
1898 yyerror_range[0] = *yylsp;
1899 YYPOPSTACK;
1900 if (yyssp == yyss)
1901 YYABORT;
1902 yydestruct (_("Error: popping"),
1903 yystos[*yyssp], yyvsp, yylsp);
1904 }
1905 }
1906 else
1907 {
1908 yydestruct (_("Error: discarding"), yytoken, &yylval, &yylloc);
1909 yychar = YYEMPTY;
1910 }
1911 }
1912
1913 /* Else will try to reuse look-ahead token after shifting the error
1914 token. */
1915 goto yyerrlab1;
1916
1917
1918 /*---------------------------------------------------.
1919 | yyerrorlab -- error raised explicitly by YYERROR. |
1920 `---------------------------------------------------*/
1921 yyerrorlab:
1922
1923 /* Pacify compilers like GCC when the user code never invokes
1924 YYERROR and the label yyerrorlab therefore never appears in user
1925 code. */
1926 if (0)
1927 goto yyerrorlab;
1928
1929 yyerror_range[0] = yylsp[1-yylen];
1930 yylsp -= yylen;
1931 yyvsp -= yylen;
1932 yyssp -= yylen;
1933 yystate = *yyssp;
1934 goto yyerrlab1;
1935
1936
1937 /*-------------------------------------------------------------.
1938 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1939 `-------------------------------------------------------------*/
1940 yyerrlab1:
1941 yyerrstatus = 3; /* Each real token shifted decrements this. */
1942
1943 for (;;)
1944 {
1945 yyn = yypact[yystate];
1946 if (yyn != YYPACT_NINF)
1947 {
1948 yyn += YYTERROR;
1949 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1950 {
1951 yyn = yytable[yyn];
1952 if (0 < yyn)
1953 break;
1954 }
1955 }
1956
1957 /* Pop the current state because it cannot handle the error token. */
1958 if (yyssp == yyss)
1959 YYABORT;
1960
1961 yyerror_range[0] = *yylsp;
1962 yydestruct (_("Error: popping"), yystos[yystate], yyvsp, yylsp);
1963 YYPOPSTACK;
1964 yystate = *yyssp;
1965 YY_STACK_PRINT (yyss, yyssp);
1966 }
1967
1968 if (yyn == YYFINAL)
1969 YYACCEPT;
1970
1971 *++yyvsp = yylval;
1972
1973 yyerror_range[1] = yylloc;
1974 /* Using YYLLOC is tempting, but would change the location of
1975 the look-ahead. YYLOC is available though. */
1976 YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
1977 *++yylsp = yyloc;
1978
1979 /* Shift the error token. */
1980 YY_SYMBOL_PRINT (_("Shifting"), yystos[yyn], yyvsp, yylsp);
1981
1982 yystate = yyn;
1983 goto yynewstate;
1984
1985
1986 /*-------------------------------------.
1987 | yyacceptlab -- YYACCEPT comes here. |
1988 `-------------------------------------*/
1989 yyacceptlab:
1990 yyresult = 0;
1991 goto yyreturn;
1992
1993 /*-----------------------------------.
1994 | yyabortlab -- YYABORT comes here. |
1995 `-----------------------------------*/
1996 yyabortlab:
1997 yydestruct (_("Error: discarding lookahead"),
1998 yytoken, &yylval, &yylloc);
1999 yychar = YYEMPTY;
2000 yyresult = 1;
2001 goto yyreturn;
2002
2003 #ifndef yyoverflow
2004 /*----------------------------------------------.
2005 | yyoverflowlab -- parser overflow comes here. |
2006 `----------------------------------------------*/
2007 yyoverflowlab:
2008 yyerror (_("parser stack overflow"));
2009 yyresult = 2;
2010 /* Fall through. */
2011 #endif
2012
2013 yyreturn:
2014 #ifndef yyoverflow
2015 if (yyss != yyssa)
2016 YYSTACK_FREE (yyss);
2017 #endif
2018 return yyresult;
2019 }
2020
2021
2022 #line 435 "parse-gram.y"
2023
2024
2025
2026 /* Return the location of the left-hand side of a rule whose
2027 right-hand side is RHS[1] ... RHS[N]. Ignore empty nonterminals in
2028 the right-hand side, and return an empty location equal to the end
2029 boundary of RHS[0] if the right-hand side is empty. */
2030
2031 static YYLTYPE
2032 lloc_default (YYLTYPE const *rhs, int n)
2033 {
2034 int i;
2035 YYLTYPE loc;
2036
2037 /* SGI MIPSpro 7.4.1m miscompiles "loc.start = loc.end = rhs[n].end;".
2038 The bug is fixed in 7.4.2m, but play it safe for now. */
2039 loc.start = rhs[n].end;
2040 loc.end = rhs[n].end;
2041
2042 /* Ignore empty nonterminals the start of the the right-hand side.
2043 Do not bother to ignore them at the end of the right-hand side,
2044 since empty nonterminals have the same end as their predecessors. */
2045 for (i = 1; i <= n; i++)
2046 if (! equal_boundaries (rhs[i].start, rhs[i].end))
2047 {
2048 loc.start = rhs[i].start;
2049 break;
2050 }
2051
2052 return loc;
2053 }
2054
2055
2056 /* Add a lex-param or a parse-param (depending on TYPE) with
2057 declaration DECL and location LOC. */
2058
2059 static void
2060 add_param (char const *type, char *decl, location loc)
2061 {
2062 static char const alphanum[26 + 26 + 1 + 10] =
2063 "abcdefghijklmnopqrstuvwxyz"
2064 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
2065 "_"
2066 "0123456789";
2067 char const *name_start = NULL;
2068 char *p;
2069
2070 /* Stop on last actual character. */
2071 for (p = decl; p[1]; p++)
2072 if ((p == decl
2073 || ! memchr (alphanum, p[-1], sizeof alphanum))
2074 && memchr (alphanum, p[0], sizeof alphanum - 10))
2075 name_start = p;
2076
2077 /* Strip the surrounding '{' and '}', and any blanks just inside
2078 the braces. */
2079 while (*--p == ' ' || *p == '\t')
2080 continue;
2081 p[1] = '\0';
2082 while (*++decl == ' ' || *decl == '\t')
2083 continue;
2084
2085 if (! name_start)
2086 complain_at (loc, _("missing identifier in parameter declaration"));
2087 else
2088 {
2089 char *name;
2090 size_t name_len;
2091
2092 for (name_len = 1;
2093 memchr (alphanum, name_start[name_len], sizeof alphanum);
2094 name_len++)
2095 continue;
2096
2097 name = xmalloc (name_len + 1);
2098 memcpy (name, name_start, name_len);
2099 name[name_len] = '\0';
2100 muscle_pair_list_grow (type, decl, name);
2101 free (name);
2102 }
2103
2104 scanner_last_string_free ();
2105 }
2106
2107 /*----------------------------------------------------.
2108 | When debugging the parser, display tokens' values. |
2109 `----------------------------------------------------*/
2110
2111 static void
2112 print_token_value (FILE *file, int type, YYSTYPE const *value)
2113 {
2114 fputc (' ', file);
2115 switch (type)
2116 {
2117 case ID:
2118 fprintf (file, " = %s", value->symbol->tag);
2119 break;
2120
2121 case INT:
2122 fprintf (file, " = %d", value->integer);
2123 break;
2124
2125 case STRING:
2126 fprintf (file, " = \"%s\"", value->chars);
2127 break;
2128
2129 case TYPE:
2130 fprintf (file, " = <%s>", value->uniqstr);
2131 break;
2132
2133 case BRACED_CODE:
2134 case PERCENT_DESTRUCTOR:
2135 case PERCENT_LEX_PARAM:
2136 case PERCENT_PARSE_PARAM:
2137 case PERCENT_PRINTER:
2138 case PERCENT_UNION:
2139 case PROLOGUE:
2140 case EPILOGUE:
2141 fprintf (file, " = {{ %s }}", value->chars);
2142 break;
2143
2144 default:
2145 fprintf (file, "unknown token type");
2146 break;
2147 }
2148 }
2149
2150 static void
2151 gram_error (location const *loc, char const *msg)
2152 {
2153 complain_at (*loc, "%s", msg);
2154 }
2155
2156 char const *
2157 token_name (int type)
2158 {
2159 return yytname[type];
2160 }
2161
bison