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