]> git.saurik.com Git - bison.git/blame - data/yacc.c
(Torturing the Scanner): Adjust to lack of quotes in diagnostics.
[bison.git] / data / yacc.c
CommitLineData
007a50a4 1m4_divert(-1) -*- C -*-
a8289c62 2
60491a94 3# Yacc compatible skeleton for Bison
c7a65b99
PE
4
5# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005
12b0043a 6# Free Software Foundation, Inc.
60491a94
AD
7
8# This program is free software; you can redistribute it and/or modify
9# it under the terms of the GNU General Public License as published by
10# the Free Software Foundation; either version 2 of the License, or
11# (at your option) any later version.
12
13# This program is distributed in the hope that it will be useful,
14# but WITHOUT ANY WARRANTY; without even the implied warranty of
15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16# GNU General Public License for more details.
17
18# You should have received a copy of the GNU General Public License
19# along with this program; if not, write to the Free Software
20# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
21# 02111-1307 USA
22
66d30cd4
AD
23
24
25## ---------------- ##
26## Default values. ##
27## ---------------- ##
28
29# Stack parameters.
30m4_define_default([b4_stack_depth_max], [10000])
31m4_define_default([b4_stack_depth_init], [200])
32
2a8d363a
AD
33
34## ------------------------ ##
35## Pure/impure interfaces. ##
36## ------------------------ ##
37
38
947427ae 39# b4_pure_if(IF-TRUE, IF-FALSE)
2a8d363a
AD
40# -----------------------------
41# Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
42m4_define([b4_Pure_if],
43[b4_pure_if([m4_ifset([b4_parse_param],
44 [$1], [$2])],
45 [$2])])
46
47
93724f13
AD
48# b4_yyerror_args
49# ---------------
2a8d363a 50# Arguments passed to yyerror: user args plus yylloc.
93724f13
AD
51m4_define([b4_yyerror_args],
52[b4_Pure_if([b4_location_if([&yylloc, ])])dnl
53m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
2a8d363a
AD
54
55
56# b4_lex_param
57# ------------
d42f69cd 58# Accumulate in b4_lex_param all the yylex arguments.
2a8d363a 59# b4_lex_param arrives quoted twice, but we want to keep only one level.
21964f43
AD
60m4_define([b4_lex_param],
61m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
68cdf747
PE
62b4_location_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
63m4_ifdef([b4_lex_param], b4_lex_param)))
66d30cd4
AD
64
65
f1886bb2
AD
66
67## ------------ ##
68## Data Types. ##
69## ------------ ##
70
71# b4_int_type(MIN, MAX)
72# ---------------------
73# Return the smallest int type able to handle numbers ranging from
74# MIN to MAX (included). We overwrite the version from c.m4 which relies
2a8d363a 75# on "signed char" which is not portable to old K&R compilers.
f1886bb2
AD
76m4_define([b4_int_type],
77[m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char],
78 b4_ints_in($@, [-128], [127]), [1], [yysigned_char],
79
779e7ceb
PE
80 b4_ints_in($@, [0], [65535]), [1], [unsigned short int],
81 b4_ints_in($@, [-32768], [32767]), [1], [short int],
f1886bb2
AD
82
83 m4_eval([0 <= $1]), [1], [unsigned int],
84
85 [int])])
86
87
66d30cd4
AD
88## ----------------- ##
89## Semantic Values. ##
90## ----------------- ##
91
92
82b6cb3f
AD
93# b4_lhs_value([TYPE])
94# --------------------
95# Expansion of $<TYPE>$.
96m4_define([b4_lhs_value],
bc82c5a5 97[(yyval[]m4_ifval([$1], [.$1]))])
82b6cb3f
AD
98
99
100# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
101# --------------------------------------
102# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
103# symbols on RHS.
104m4_define([b4_rhs_value],
bc82c5a5 105[(yyvsp@{m4_eval([$2 - $1])@}m4_ifval([$3], [.$3]))])
82b6cb3f
AD
106
107
58612f1d
AD
108
109## ----------- ##
110## Locations. ##
111## ----------- ##
112
82b6cb3f
AD
113# b4_lhs_location()
114# -----------------
115# Expansion of @$.
116m4_define([b4_lhs_location],
bc82c5a5 117[(yyloc)])
82b6cb3f
AD
118
119
120# b4_rhs_location(RULE-LENGTH, NUM)
121# ---------------------------------
122# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
123# on RHS.
124m4_define([b4_rhs_location],
bc82c5a5 125[(yylsp@{m4_eval([$2 - $1])@})])
be2a1a68 126
0d8bed56 127
0d8bed56 128
1ae72863
AD
129## --------------------------------------------------------- ##
130## Defining symbol actions, e.g., printers and destructors. ##
131## --------------------------------------------------------- ##
132
b526ee61
AD
133# We do want M4 expansion after # for CPP macros.
134m4_changecom()
be2a1a68 135m4_divert(0)dnl
947427ae 136@output @output_parser_name@
fb8135fa 137b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
779e7ceb 138 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004])[
fb8135fa 139
0252b55c
PE
140/* As a special exception, when this file is copied by Bison into a
141 Bison output file, you may use that output file without restriction.
142 This special exception was added by the Free Software Foundation
143 in version 1.24 of Bison. */
144
fb8135fa
AD
145/* Written by Richard Stallman by simplifying the original so called
146 ``semantic'' parser. */
444fbf65 147
cf44a9ae
PE
148/* All symbols defined below should begin with yy or YY, to avoid
149 infringing on user name space. This should be done even for local
150 variables, as they might otherwise be expanded by user macros.
151 There are some unavoidable exceptions within include files to
152 define necessary library symbols; they are noted "INFRINGES ON
153 USER NAME SPACE" below. */
154
9c1e26bd 155]b4_identification
be2a1a68 156m4_if(b4_prefix[], [yy], [],
c5b95ccf 157[/* Substitute the variable and function names. */
be2a1a68
AD
158#define yyparse b4_prefix[]parse
159#define yylex b4_prefix[]lex
160#define yyerror b4_prefix[]error
161#define yylval b4_prefix[]lval
162#define yychar b4_prefix[]char
163#define yydebug b4_prefix[]debug
164#define yynerrs b4_prefix[]nerrs
9c1e26bd 165b4_location_if([#define yylloc b4_prefix[]lloc])])[
17da6427 166
9c1e26bd 167]b4_token_defines(b4_tokens)[
17acead5 168
0dd1580a 169/* Copy the first part of user declarations. */
9c1e26bd 170]b4_pre_prologue[
cce71710 171
d99361e6
AD
172/* Enabling traces. */
173#ifndef YYDEBUG
9c1e26bd 174# define YYDEBUG ]b4_debug[
d99361e6
AD
175#endif
176
177/* Enabling verbose error messages. */
178#ifdef YYERROR_VERBOSE
179# undef YYERROR_VERBOSE
180# define YYERROR_VERBOSE 1
181#else
9c1e26bd 182# define YYERROR_VERBOSE ]b4_error_verbose[
d99361e6
AD
183#endif
184
050c471b 185#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
9c1e26bd 186]m4_ifdef([b4_stype],
437c2d80 187[b4_syncline([b4_stype_line], [b4_filename])
050c471b 188typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
996b1c7e 189/* Line __line__ of yacc.c. */
947427ae 190b4_syncline([@oline@], [@ofile@])],
050c471b
PE
191[typedef int YYSTYPE;])[
192# define yystype YYSTYPE /* obsolescent; will be withdrawn */
193# define YYSTYPE_IS_DECLARED 1
71cd15d4 194# define YYSTYPE_IS_TRIVIAL 1
fd51e5ff
AD
195#endif
196
050c471b
PE
197]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
198typedef struct YYLTYPE
fd51e5ff
AD
199{
200 int first_line;
201 int first_column;
202 int last_line;
203 int last_column;
050c471b
PE
204} YYLTYPE;
205# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
206# define YYLTYPE_IS_DECLARED 1
71cd15d4 207# define YYLTYPE_IS_TRIVIAL 1
fd51e5ff 208#endif
1915f133 209])[
fd51e5ff 210
0dd1580a 211/* Copy the second part of user declarations. */
ee41006f 212]b4_post_prologue
0dd1580a 213
996b1c7e 214/* Line __line__ of yacc.c. */
ee41006f 215b4_syncline([@oline@], [@ofile@])[
7093d0f5 216
cf44a9ae 217#if ! defined (yyoverflow) || YYERROR_VERBOSE
7093d0f5 218
2779e383
PE
219# ifndef YYFREE
220# define YYFREE free
221# endif
222# ifndef YYMALLOC
223# define YYMALLOC malloc
224# endif
225
7093d0f5
AD
226/* The parser invokes alloca or malloc; define the necessary symbols. */
227
b929851a
PE
228# ifdef YYSTACK_USE_ALLOCA
229# if YYSTACK_USE_ALLOCA
b929851a
PE
230# ifdef __GNUC__
231# define YYSTACK_ALLOC __builtin_alloca
d7e14fc0
PE
232# else
233# define YYSTACK_ALLOC alloca
7093d0f5
AD
234# endif
235# endif
236# endif
237
238# ifdef YYSTACK_ALLOC
239 /* Pacify GCC's `empty if-body' warning. */
240# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
506ffb1f
PE
241# ifndef YYSTACK_ALLOC_MAXIMUM
242# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
243# endif
7093d0f5 244# else
45119af1
PE
245# if defined (__STDC__) || defined (__cplusplus)
246# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
247# define YYSIZE_T size_t
506ffb1f
PE
248# else
249# define YYSIZE_T unsigned long int
7093d0f5 250# endif
2779e383
PE
251# define YYSTACK_ALLOC YYMALLOC
252# define YYSTACK_FREE YYFREE
506ffb1f
PE
253# ifndef YYSTACK_ALLOC_MAXIMUM
254# define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
255# endif
7093d0f5 256# endif
cf44a9ae
PE
257#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
258
259
260#if (! defined (yyoverflow) \
261 && (! defined (__cplusplus) \
d7aa6ec1
PE
262 || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
263 && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
7093d0f5 264
600f9b0c
PE
265/* A type that is properly aligned for any stack member. */
266union yyalloc
267{
779e7ceb 268 short int yyss;
2729e106 269 YYSTYPE yyvs;
9c1e26bd 270 ]b4_location_if([ YYLTYPE yyls;
58612f1d 271])dnl
9c1e26bd 272[};
600f9b0c
PE
273
274/* The size of the maximum gap between one aligned stack and the next. */
17836590 275# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
600f9b0c
PE
276
277/* The size of an array large to enough to hold all stacks, each with
278 N elements. */
9c1e26bd 279]b4_location_if(
58612f1d 280[# define YYSTACK_BYTES(N) \
779e7ceb 281 ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
17836590 282 + 2 * YYSTACK_GAP_MAXIMUM)],
58612f1d 283[# define YYSTACK_BYTES(N) \
779e7ceb 284 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
17836590 285 + YYSTACK_GAP_MAXIMUM)])[
600f9b0c 286
5b041382
PE
287/* Copy COUNT objects from FROM to TO. The source and destination do
288 not overlap. */
289# ifndef YYCOPY
d7aa6ec1 290# if defined (__GNUC__) && 1 < __GNUC__
5b041382
PE
291# define YYCOPY(To, From, Count) \
292 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
293# else
294# define YYCOPY(To, From, Count) \
295 do \
296 { \
cb530ce9 297 YYSIZE_T yyi; \
5b041382 298 for (yyi = 0; yyi < (Count); yyi++) \
9c1e26bd 299 (To)[yyi] = (From)[yyi]; \
5b041382
PE
300 } \
301 while (0)
302# endif
303# endif
304
305/* Relocate STACK from its old location to the new one. The
7093d0f5 306 local variables YYSIZE and YYSTACKSIZE give the old and new number of
600f9b0c
PE
307 elements in the stack, and YYPTR gives the new location of the
308 stack. Advance YYPTR to a properly aligned location for the next
309 stack. */
5b041382 310# define YYSTACK_RELOCATE(Stack) \
7093d0f5
AD
311 do \
312 { \
313 YYSIZE_T yynewbytes; \
5b041382 314 YYCOPY (&yyptr->Stack, Stack, yysize); \
2729e106 315 Stack = &yyptr->Stack; \
17836590 316 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2729e106 317 yyptr += yynewbytes / sizeof (*yyptr); \
7093d0f5
AD
318 } \
319 while (0)
320
cf44a9ae 321#endif
8850be4b 322
768eb43f
PE
323#if defined (__STDC__) || defined (__cplusplus)
324 typedef signed char yysigned_char;
325#else
779e7ceb 326 typedef short int yysigned_char;
768eb43f
PE
327#endif
328
7742ddeb 329/* YYFINAL -- State number of the termination state. */
9c1e26bd 330#define YYFINAL ]b4_final_state_number[
39912f52 331/* YYLAST -- Last index in YYTABLE. */
9c1e26bd 332#define YYLAST ]b4_last[
7742ddeb
AD
333
334/* YYNTOKENS -- Number of terminals. */
9c1e26bd 335#define YYNTOKENS ]b4_tokens_number[
7742ddeb 336/* YYNNTS -- Number of nonterminals. */
9c1e26bd 337#define YYNNTS ]b4_nterms_number[
7742ddeb 338/* YYNRULES -- Number of rules. */
9c1e26bd 339#define YYNRULES ]b4_rules_number[
7742ddeb 340/* YYNRULES -- Number of states. */
9c1e26bd 341#define YYNSTATES ]b4_states_number[
7742ddeb
AD
342
343/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
9c1e26bd
AD
344#define YYUNDEFTOK ]b4_undef_token_number[
345#define YYMAXUTOK ]b4_user_token_number_max[
007a50a4 346
b0400cc6 347#define YYTRANSLATE(YYX) \
a20713a4 348 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
a8289c62 349
b0400cc6
AD
350/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
351static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
a8289c62 352{
c5e3e510 353 ]b4_translate[
a8289c62
RA
354};
355
356#if YYDEBUG
c5e3e510 357/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
7742ddeb 358 YYRHS. */
c5e3e510 359static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
a8289c62 360{
c5e3e510 361 ]b4_prhs[
a8289c62
RA
362};
363
3db472b9 364/* YYRHS -- A `-1'-separated list of the rules' RHS. */
c5e3e510 365static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
a8289c62 366{
c5e3e510 367 ]b4_rhs[
a8289c62
RA
368};
369
c5e3e510
AD
370/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
371static const ]b4_int_type_for([b4_rline])[ yyrline[] =
a8289c62 372{
c5e3e510 373 ]b4_rline[
a8289c62
RA
374};
375#endif
376
5504898e 377#if YYDEBUG || YYERROR_VERBOSE
c5e3e510 378/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
7742ddeb 379 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
c5e3e510 380static const char *const yytname[] =
a8289c62 381{
c5e3e510 382 ]b4_tname[
a8289c62
RA
383};
384#endif
385
1ce59070
PE
386/* INFRINGES ON USER NAME SPACE */
387#ifndef _
388# define _(msgid) msgid
389#endif
390
c0ad8bf3 391# ifdef YYPRINT
c5e3e510 392/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
769b430f 393 token YYLEX-NUM. */
c5e3e510 394static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
a8289c62 395{
c5e3e510 396 ]b4_toknum[
a8289c62 397};
c0ad8bf3 398# endif
a8289c62 399
c5e3e510
AD
400/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
401static const ]b4_int_type_for([b4_r1])[ yyr1[] =
a8289c62 402{
c5e3e510 403 ]b4_r1[
a8289c62
RA
404};
405
c5e3e510
AD
406/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
407static const ]b4_int_type_for([b4_r2])[ yyr2[] =
a8289c62 408{
c5e3e510 409 ]b4_r2[
a8289c62
RA
410};
411
c5e3e510 412/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
5504898e
AD
413 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
414 means the default is an error. */
c5e3e510 415static const ]b4_int_type_for([b4_defact])[ yydefact[] =
a8289c62 416{
c5e3e510 417 ]b4_defact[
a8289c62
RA
418};
419
c5e3e510
AD
420/* YYDEFGOTO[NTERM-NUM]. */
421static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
a8289c62 422{
c5e3e510 423 ]b4_defgoto[
a8289c62
RA
424};
425
c5e3e510 426/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
7742ddeb 427 STATE-NUM. */
c5e3e510
AD
428#define YYPACT_NINF ]b4_pact_ninf[
429static const ]b4_int_type_for([b4_pact])[ yypact[] =
a8289c62 430{
c5e3e510 431 ]b4_pact[
a8289c62
RA
432};
433
c5e3e510
AD
434/* YYPGOTO[NTERM-NUM]. */
435static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
a8289c62 436{
c5e3e510 437 ]b4_pgoto[
a8289c62
RA
438};
439
c5e3e510 440/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
7742ddeb 441 positive, shift that token. If negative, reduce the rule which
f50adbbd 442 number is the opposite. If zero, do what YYDEFACT says.
6e649e65 443 If YYTABLE_NINF, syntax error. */
c5e3e510
AD
444#define YYTABLE_NINF ]b4_table_ninf[
445static const ]b4_int_type_for([b4_table])[ yytable[] =
a8289c62 446{
c5e3e510 447 ]b4_table[
a8289c62
RA
448};
449
c5e3e510 450static const ]b4_int_type_for([b4_check])[ yycheck[] =
a8289c62 451{
c5e3e510 452 ]b4_check[
a8289c62
RA
453};
454
c5e3e510 455/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
5504898e 456 symbol of state STATE-NUM. */
c5e3e510 457static const ]b4_int_type_for([b4_stos])[ yystos[] =
5504898e 458{
c5e3e510 459 ]b4_stos[
5504898e 460};
7093d0f5
AD
461
462#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
463# define YYSIZE_T __SIZE_TYPE__
464#endif
465#if ! defined (YYSIZE_T) && defined (size_t)
466# define YYSIZE_T size_t
467#endif
b7575ffe 468#if ! defined (YYSIZE_T)
45119af1
PE
469# if defined (__STDC__) || defined (__cplusplus)
470# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
471# define YYSIZE_T size_t
b7575ffe 472# endif
7093d0f5
AD
473#endif
474#if ! defined (YYSIZE_T)
475# define YYSIZE_T unsigned int
476#endif
477
10fa2066 478#define yyerrok (yyerrstatus = 0)
a20713a4
PE
479#define yyclearin (yychar = YYEMPTY)
480#define YYEMPTY (-2)
10fa2066 481#define YYEOF 0
a8289c62 482
70ddf897 483#define YYACCEPT goto yyacceptlab
a8289c62 484#define YYABORT goto yyabortlab
a6b89bb2 485#define YYERROR goto yyerrorlab
8a3eb3c8 486
a8289c62 487
71da9eea
AD
488/* Like YYERROR except do call yyerror. This remains here temporarily
489 to ease the transition to the new meaning of YYERROR, for GCC.
10fa2066 490 Once GCC version 2 has supplanted version 1, this can go. */
a8289c62 491
10fa2066 492#define YYFAIL goto yyerrlab
a8289c62 493
10fa2066 494#define YYRECOVERING() (!!yyerrstatus)
a8289c62 495
69b4e0c5 496#define YYBACKUP(Token, Value) \
10fa2066 497do \
a20713a4 498 if (yychar == YYEMPTY && yylen == 1) \
71da9eea 499 { \
17da6427 500 yychar = (Token); \
7742ddeb 501 yylval = (Value); \
b0400cc6 502 yytoken = YYTRANSLATE (yychar); \
10fa2066
RS
503 YYPOPSTACK; \
504 goto yybackup; \
505 } \
506 else \
71da9eea 507 { \
1ce59070 508 yyerror (]b4_yyerror_args[_("syntax error: cannot back up")); \
71da9eea
AD
509 YYERROR; \
510 } \
10fa2066
RS
511while (0)
512
3fc16193 513
10fa2066
RS
514#define YYTERROR 1
515#define YYERRCODE 256
516
3fc16193 517
b4a20338
AD
518/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
519 If N is 0, then set CURRENT to the empty location which ends
520 the previous symbol: RHS[0] (always defined). */
3abcd459 521
24e0cbd0 522#define YYRHSLOC(Rhs, K) ((Rhs)[K])
3abcd459 523#ifndef YYLLOC_DEFAULT
24e0cbd0
PE
524# define YYLLOC_DEFAULT(Current, Rhs, N) \
525 do \
526 if (N) \
527 { \
9bec482e
PE
528 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
529 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
530 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
531 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
24e0cbd0
PE
532 } \
533 else \
534 { \
535 (Current).first_line = (Current).last_line = \
9bec482e 536 YYRHSLOC (Rhs, 0).last_line; \
24e0cbd0 537 (Current).first_column = (Current).last_column = \
9bec482e 538 YYRHSLOC (Rhs, 0).last_column; \
24e0cbd0
PE
539 } \
540 while (0)
b8458aa5
AD
541#endif
542
3fc16193
AD
543
544/* YY_LOCATION_PRINT -- Print the location on the stream.
545 This macro was not mandated originally: define only if we know
546 we won't break user code: when these are the locations we know. */
547
3fc16193 548#ifndef YY_LOCATION_PRINT
b8458aa5
AD
549# if YYLTYPE_IS_TRIVIAL
550# define YY_LOCATION_PRINT(File, Loc) \
551 fprintf (File, "%d.%d-%d.%d", \
552 (Loc).first_line, (Loc).first_column, \
553 (Loc).last_line, (Loc).last_column)
0dcca5c2
AD
554# else
555# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
b8458aa5 556# endif
3abcd459
AD
557#endif
558
3fc16193 559
3abcd459 560/* YYLEX -- calling `yylex' with the right arguments. */
553e2b22 561
ae7453f2 562#ifdef YYLEX_PARAM
9c1e26bd 563# define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)
74310291 564#else
9c1e26bd 565# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
ae7453f2 566#endif
553e2b22 567
5a35a6cb 568/* Enable debugging if requested. */
0d533154 569#if YYDEBUG
b7575ffe
PE
570
571# ifndef YYFPRINTF
45119af1
PE
572# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
573# define YYFPRINTF fprintf
b7575ffe
PE
574# endif
575
5a35a6cb
AD
576# define YYDPRINTF(Args) \
577do { \
17da6427 578 if (yydebug) \
b7575ffe 579 YYFPRINTF Args; \
5a35a6cb 580} while (0)
c5e3e510 581
284acc8b 582# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
9c1e26bd
AD
583do { \
584 if (yydebug) \
585 { \
586 YYFPRINTF (stderr, "%s ", Title); \
587 yysymprint (stderr, \
284acc8b 588 Type, Value]b4_location_if([, Location])[); \
9c1e26bd
AD
589 YYFPRINTF (stderr, "\n"); \
590 } \
591} while (0)
592
b0937b22
AD
593/*------------------------------------------------------------------.
594| yy_stack_print -- Print the state stack from its BOTTOM up to its |
5348bfbe 595| TOP (included). |
b0937b22
AD
596`------------------------------------------------------------------*/
597
598]b4_c_function_def([yy_stack_print], [static void],
779e7ceb
PE
599 [[short int *bottom], [bottom]],
600 [[short int *top], [top]])[
b0937b22 601{
1ce59070 602 YYFPRINTF (stderr, _("Stack now"));
b0937b22
AD
603 for (/* Nothing. */; bottom <= top; ++bottom)
604 YYFPRINTF (stderr, " %d", *bottom);
605 YYFPRINTF (stderr, "\n");
606}
607
608# define YY_STACK_PRINT(Bottom, Top) \
609do { \
610 if (yydebug) \
611 yy_stack_print ((Bottom), (Top)); \
612} while (0)
613
614
615/*------------------------------------------------.
616| Report that the YYRULE is going to be reduced. |
617`------------------------------------------------*/
618
619]b4_c_function_def([yy_reduce_print], [static void],
620 [[int yyrule], [yyrule]])[
621{
622 int yyi;
52f32190 623 unsigned int yylno = yyrline[yyrule];
1ce59070 624 YYFPRINTF (stderr, _("Reducing stack by rule %d (line %u), "),
52f32190 625 yyrule - 1, yylno);
b0937b22
AD
626 /* Print the symbols being reduced, and their result. */
627 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
628 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
629 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
630}
631
632# define YY_REDUCE_PRINT(Rule) \
633do { \
634 if (yydebug) \
635 yy_reduce_print (Rule); \
636} while (0)
637
cf44a9ae
PE
638/* Nonzero means print parse trace. It is left uninitialized so that
639 multiple parsers can coexist. */
17da6427 640int yydebug;
5a35a6cb
AD
641#else /* !YYDEBUG */
642# define YYDPRINTF(Args)
284acc8b 643# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
b0937b22
AD
644# define YY_STACK_PRINT(Bottom, Top)
645# define YY_REDUCE_PRINT(Rule)
5a35a6cb
AD
646#endif /* !YYDEBUG */
647
b0937b22 648
5a35a6cb 649/* YYINITDEPTH -- initial size of the parser's stacks. */
10fa2066 650#ifndef YYINITDEPTH
9c1e26bd 651# define YYINITDEPTH ]b4_stack_depth_init[
10fa2066
RS
652#endif
653
5a35a6cb 654/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
600f9b0c
PE
655 if the built-in stack extension method is used).
656
657 Do not make this value too large; the results are undefined if
506ffb1f 658 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
600f9b0c
PE
659 evaluated with infinite-precision integer arithmetic. */
660
10fa2066 661#ifndef YYMAXDEPTH
9c1e26bd 662# define YYMAXDEPTH ]b4_stack_depth_max[
10fa2066 663#endif
a8289c62 664
10fa2066 665\f
a8289c62 666
7093d0f5
AD
667#if YYERROR_VERBOSE
668
669# ifndef yystrlen
670# if defined (__GLIBC__) && defined (_STRING_H)
671# define yystrlen strlen
672# else
673/* Return the length of YYSTR. */
674static YYSIZE_T
675# if defined (__STDC__) || defined (__cplusplus)
676yystrlen (const char *yystr)
677# else
678yystrlen (yystr)
679 const char *yystr;
680# endif
681{
cb530ce9 682 const char *yys = yystr;
7093d0f5
AD
683
684 while (*yys++ != '\0')
685 continue;
686
687 return yys - yystr - 1;
688}
689# endif
690# endif
691
692# ifndef yystpcpy
693# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
694# define yystpcpy stpcpy
695# else
696/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
697 YYDEST. */
698static char *
f11966ff
PE
699# if defined (__STDC__) || defined (__cplusplus)
700yystpcpy (char *yydest, const char *yysrc)
701# else
7093d0f5
AD
702yystpcpy (yydest, yysrc)
703 char *yydest;
704 const char *yysrc;
7093d0f5
AD
705# endif
706{
cb530ce9
PE
707 char *yyd = yydest;
708 const char *yys = yysrc;
7093d0f5
AD
709
710 while ((*yyd++ = *yys++) != '\0')
711 continue;
712
713 return yyd - 1;
714}
715# endif
716# endif
717
718#endif /* !YYERROR_VERBOSE */
719
10fa2066 720\f
a8289c62 721
b8df3223 722#if YYDEBUG
9c1e26bd 723]b4_yysymprint_generate([b4_c_function_def])[
c5e3e510 724#endif /* ! YYDEBUG */
9c1e26bd 725]b4_yydestruct_generate([b4_c_function_def])
4a2a22f4
AD
726\f
727
0245f82d 728/* Prevent warnings from -Wmissing-prototypes. */
4a2a22f4
AD
729
730#ifdef YYPARSE_PARAM
731# if defined (__STDC__) || defined (__cplusplus)
0245f82d 732int yyparse (void *YYPARSE_PARAM);
4a2a22f4 733# else
0245f82d 734int yyparse ();
4a2a22f4 735# endif
0245f82d
AD
736#else /* ! YYPARSE_PARAM */
737b4_c_function_decl([yyparse], [int], b4_parse_param)
c5e3e510 738#endif /* ! YYPARSE_PARAM */
1b181651 739
0245f82d 740
74310291
AD
741m4_divert_push([KILL])# ======================== M4 code.
742# b4_declare_parser_variables
743# ---------------------------
744# Declare the variables that are global, or local to YYPARSE if
0245f82d 745# pure-parser.
74310291 746m4_define([b4_declare_parser_variables],
8dd162d3 747[/* The look-ahead symbol. */
74310291
AD
748int yychar;
749
8dd162d3 750/* The semantic value of the look-ahead symbol. */
74310291
AD
751YYSTYPE yylval;
752
6e649e65 753/* Number of syntax errors so far. */
74310291 754int yynerrs;b4_location_if([
8dd162d3 755/* Location data for the look-ahead symbol. */
58612f1d 756YYLTYPE yylloc;])
74310291
AD
757])
758m4_divert_pop([KILL])dnl# ====================== End of M4 code.
58612f1d 759
74310291
AD
760b4_pure_if([],
761 [b4_declare_parser_variables])
a35f64ea 762
0245f82d
AD
763
764/*----------.
765| yyparse. |
766`----------*/
767
768#ifdef YYPARSE_PARAM
769# if defined (__STDC__) || defined (__cplusplus)
770int yyparse (void *YYPARSE_PARAM)
771# else
772int yyparse (YYPARSE_PARAM)
773 void *YYPARSE_PARAM;
774# endif
775#else /* ! YYPARSE_PARAM */
776b4_c_function_def([yyparse], [int], b4_parse_param)
777#endif
be2a1a68 778{[
74310291 779 ]b4_pure_if([b4_declare_parser_variables])[
cb530ce9
PE
780 int yystate;
781 int yyn;
600f9b0c 782 int yyresult;
b07b484a
AD
783 /* Number of tokens to shift before error messages enabled. */
784 int yyerrstatus;
8dd162d3 785 /* Look-ahead token as an internal (translated) token number. */
b0400cc6 786 int yytoken = 0;
10fa2066 787
bb10be54
AD
788 /* Three stacks and their tools:
789 `yyss': related to states,
e9e4c321 790 `yyvs': related to semantic values,
bb10be54
AD
791 `yyls': related to locations.
792
793 Refer to the stacks thru separate pointers, to allow yyoverflow
794 to reallocate them elsewhere. */
795
e8cb70b9 796 /* The state stack. */
779e7ceb
PE
797 short int yyssa[YYINITDEPTH];
798 short int *yyss = yyssa;
cb530ce9 799 short int *yyssp;
bb10be54 800
b07b484a
AD
801 /* The semantic value stack. */
802 YYSTYPE yyvsa[YYINITDEPTH];
b07b484a 803 YYSTYPE *yyvs = yyvsa;
cb530ce9 804 YYSTYPE *yyvsp;
10fa2066 805
58612f1d
AD
806]b4_location_if(
807[[ /* The location stack. */
b07b484a 808 YYLTYPE yylsa[YYINITDEPTH];
10fa2066 809 YYLTYPE *yyls = yylsa;
d42f69cd 810 YYLTYPE *yylsp;
3fc16193
AD
811 /* The locations where the error started and ended. */
812 YYLTYPE yyerror_range[2];]])[
10fa2066 813
58612f1d 814#define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
10fa2066 815
7093d0f5 816 YYSIZE_T yystacksize = YYINITDEPTH;
10fa2066 817
6666f98f
AD
818 /* The variables used to return semantic value and location from the
819 action routines. */
bb10be54 820 YYSTYPE yyval;
58612f1d 821]b4_location_if([ YYLTYPE yyloc;])[
10fa2066 822
6666f98f 823 /* When reducing, the number of symbols on the RHS of the reduced
e8cb70b9 824 rule. */
10fa2066
RS
825 int yylen;
826
7ea5e977 827 YYDPRINTF ((stderr, "Starting parse\n"));
10fa2066
RS
828
829 yystate = 0;
830 yyerrstatus = 0;
17da6427 831 yynerrs = 0;
a20713a4 832 yychar = YYEMPTY; /* Cause a token to be read. */
10fa2066
RS
833
834 /* Initialize stack pointers.
835 Waste one element of value and location stack
836 so that they stay on the same level as the state stack.
837 The wasted elements are never initialized. */
838
cbd89906 839 yyssp = yyss;
10fa2066 840 yyvsp = yyvs;
b8458aa5
AD
841]b4_location_if([[ yylsp = yyls;
842#if YYLTYPE_IS_TRIVIAL
843 /* Initialize the default location before parsing starts. */
451364ed
AD
844 yylloc.first_line = yylloc.last_line = 1;
845 yylloc.first_column = yylloc.last_column = 0;
b8458aa5
AD
846#endif
847]])
848m4_ifdef([b4_initial_action], [
0092f063
AD
849m4_pushdef([b4_at_dollar], [yylloc])dnl
850m4_pushdef([b4_dollar_dollar], [yylval])dnl
cd3684cf 851 /* User initialization code. */
baf073c6 852b4_initial_action
cd3684cf
AD
853m4_popdef([b4_dollar_dollar])dnl
854m4_popdef([b4_at_dollar])dnl
855/* Line __line__ of yacc.c. */
856b4_syncline([@oline@], [@ofile@])])dnl
451364ed
AD
857[
858 yyvsp[0] = yylval;
859]b4_location_if([[ yylsp[0] = yylloc;
860]])
cd3684cf 861[ goto yysetstate;
10fa2066 862
71da9eea
AD
863/*------------------------------------------------------------.
864| yynewstate -- Push a new state, which is found in yystate. |
865`------------------------------------------------------------*/
342b8b6e 866 yynewstate:
71da9eea
AD
867 /* In all cases, when you get here, the value and location stacks
868 have just been pushed. so pushing a state here evens the stacks.
869 */
cbd89906
PE
870 yyssp++;
871
342b8b6e 872 yysetstate:
cbd89906 873 *yyssp = yystate;
10fa2066 874
39912f52 875 if (yyss + yystacksize - 1 <= yyssp)
10fa2066 876 {
10fa2066 877 /* Get the current used size of the three stacks, in elements. */
7093d0f5 878 YYSIZE_T yysize = yyssp - yyss + 1;
10fa2066
RS
879
880#ifdef yyoverflow
3d76b07d
AD
881 {
882 /* Give user a chance to reallocate the stack. Use copies of
883 these so that the &'s don't force the real ones into
884 memory. */
885 YYSTYPE *yyvs1 = yyvs;
779e7ceb 886 short int *yyss1 = yyss;
58612f1d 887]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
3d76b07d
AD
888
889 /* Each stack pointer address is followed by the size of the
58612f1d
AD
890 data in use in that stack, in bytes. This used to be a
891 conditional around just the two extra args, but that might
892 be undefined if yyoverflow is a macro. */
1ce59070 893 yyoverflow (_("parser stack overflow"),
7093d0f5
AD
894 &yyss1, yysize * sizeof (*yyssp),
895 &yyvs1, yysize * sizeof (*yyvsp),
58612f1d 896]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
3d76b07d 897 &yystacksize);
58612f1d 898]b4_location_if([ yyls = yyls1;])[
3d76b07d
AD
899 yyss = yyss1;
900 yyvs = yyvs1;
901 }
10fa2066 902#else /* no yyoverflow */
cf44a9ae
PE
903# ifndef YYSTACK_RELOCATE
904 goto yyoverflowlab;
905# else
10fa2066 906 /* Extend the stack our own way. */
39912f52 907 if (YYMAXDEPTH <= yystacksize)
600f9b0c 908 goto yyoverflowlab;
10fa2066 909 yystacksize *= 2;
39912f52 910 if (YYMAXDEPTH < yystacksize)
10fa2066 911 yystacksize = YYMAXDEPTH;
e9e4c321 912
600f9b0c 913 {
779e7ceb 914 short int *yyss1 = yyss;
2729e106
PE
915 union yyalloc *yyptr =
916 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
600f9b0c
PE
917 if (! yyptr)
918 goto yyoverflowlab;
5b041382
PE
919 YYSTACK_RELOCATE (yyss);
920 YYSTACK_RELOCATE (yyvs);
58612f1d 921]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
cf44a9ae 922# undef YYSTACK_RELOCATE
600f9b0c
PE
923 if (yyss1 != yyssa)
924 YYSTACK_FREE (yyss1);
925 }
cf44a9ae 926# endif
10fa2066
RS
927#endif /* no yyoverflow */
928
7093d0f5
AD
929 yyssp = yyss + yysize - 1;
930 yyvsp = yyvs + yysize - 1;
58612f1d 931]b4_location_if([ yylsp = yyls + yysize - 1;])[
10fa2066 932
1ce59070 933 YYDPRINTF ((stderr, _("Stack size increased to %lu\n"),
600f9b0c 934 (unsigned long int) yystacksize));
10fa2066 935
39912f52 936 if (yyss + yystacksize - 1 <= yyssp)
10fa2066
RS
937 YYABORT;
938 }
939
1ce59070 940 YYDPRINTF ((stderr, _("Entering state %d\n"), yystate));
10fa2066
RS
941
942 goto yybackup;
71da9eea 943
71da9eea
AD
944/*-----------.
945| yybackup. |
946`-----------*/
947yybackup:
10fa2066
RS
948
949/* Do appropriate processing given the current state. */
8dd162d3 950/* Read a look-ahead token if we need one and don't already have one. */
10fa2066
RS
951/* yyresume: */
952
8dd162d3 953 /* First try to decide what to do without reference to look-ahead token. */
10fa2066
RS
954
955 yyn = yypact[yystate];
12b0043a 956 if (yyn == YYPACT_NINF)
10fa2066
RS
957 goto yydefault;
958
8dd162d3 959 /* Not known => get a look-ahead token if don't already have one. */
10fa2066 960
8dd162d3 961 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
a20713a4 962 if (yychar == YYEMPTY)
10fa2066 963 {
1ce59070 964 YYDPRINTF ((stderr, _("Reading a token: ")));
17da6427 965 yychar = YYLEX;
10fa2066
RS
966 }
967
a20713a4 968 if (yychar <= YYEOF)
10fa2066 969 {
a20713a4 970 yychar = yytoken = YYEOF;
1ce59070 971 YYDPRINTF ((stderr, _("Now at end of input.\n")));
10fa2066
RS
972 }
973 else
974 {
a20713a4 975 yytoken = YYTRANSLATE (yychar);
1ce59070 976 YY_SYMBOL_PRINT (_("Next token is"), yytoken, &yylval, &yylloc);
10fa2066
RS
977 }
978
b0400cc6 979 /* If the proper action on seeing token YYTOKEN is to reduce or to
e5cfd9d8 980 detect an error, take that action. */
b0400cc6
AD
981 yyn += yytoken;
982 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
e5cfd9d8
PE
983 goto yydefault;
984 yyn = yytable[yyn];
985 if (yyn <= 0)
10fa2066 986 {
e5cfd9d8
PE
987 if (yyn == 0 || yyn == YYTABLE_NINF)
988 goto yyerrlab;
10fa2066
RS
989 yyn = -yyn;
990 goto yyreduce;
991 }
10fa2066
RS
992
993 if (yyn == YYFINAL)
994 YYACCEPT;
995
8dd162d3 996 /* Shift the look-ahead token. */
1ce59070 997 YY_SYMBOL_PRINT (_("Shifting"), yytoken, &yylval, &yylloc);
10fa2066
RS
998
999 /* Discard the token being shifted unless it is eof. */
a20713a4
PE
1000 if (yychar != YYEOF)
1001 yychar = YYEMPTY;
10fa2066 1002
17da6427 1003 *++yyvsp = yylval;
58612f1d 1004]b4_location_if([ *++yylsp = yylloc;])[
10fa2066 1005
71da9eea
AD
1006 /* Count tokens shifted since error; after three, turn off error
1007 status. */
1008 if (yyerrstatus)
1009 yyerrstatus--;
10fa2066
RS
1010
1011 yystate = yyn;
1012 goto yynewstate;
1013
10fa2066 1014
71da9eea
AD
1015/*-----------------------------------------------------------.
1016| yydefault -- do the default action for the current state. |
1017`-----------------------------------------------------------*/
1018yydefault:
10fa2066
RS
1019 yyn = yydefact[yystate];
1020 if (yyn == 0)
1021 goto yyerrlab;
71da9eea 1022 goto yyreduce;
10fa2066 1023
71da9eea
AD
1024
1025/*-----------------------------.
1026| yyreduce -- Do a reduction. |
1027`-----------------------------*/
10fa2066 1028yyreduce:
71da9eea 1029 /* yyn is the number of a rule to reduce with. */
10fa2066 1030 yylen = yyr2[yyn];
da9abf43
AD
1031
1032 /* If YYLEN is nonzero, implement the default value of the action:
573c1d9f 1033 `$$ = $1'.
da9abf43 1034
accea6db
PE
1035 Otherwise, the following line sets YYVAL to garbage.
1036 This behavior is undocumented and Bison
da9abf43
AD
1037 users should not rely upon it. Assigning to YYVAL
1038 unconditionally makes the parser a bit smaller, and it avoids a
1039 GCC warning that YYVAL may be used uninitialized. */
1040 yyval = yyvsp[1-yylen];
3abcd459 1041
58612f1d 1042]b4_location_if(
b8458aa5 1043[[ /* Default location. */
b4a20338 1044 YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);]])[
b0937b22 1045 YY_REDUCE_PRINT (yyn);
a8289c62 1046 switch (yyn)
be2a1a68
AD
1047 ]{
1048 b4_actions
95f22ad2 1049 default: break;
a8289c62 1050 }
897668ee 1051
996b1c7e 1052/* Line __line__ of yacc.c. */
947427ae 1053b4_syncline([@oline@], [@ofile@])
10fa2066 1054\f
be2a1a68 1055[ yyvsp -= yylen;
10fa2066 1056 yyssp -= yylen;
58612f1d 1057]b4_location_if([ yylsp -= yylen;])[
10fa2066 1058
b0937b22 1059 YY_STACK_PRINT (yyss, yyssp);
10fa2066
RS
1060
1061 *++yyvsp = yyval;
58612f1d 1062]b4_location_if([ *++yylsp = yyloc;])[
10fa2066 1063
41aca2e0
AD
1064 /* Now `shift' the result of the reduction. Determine what state
1065 that goes to, based on the state we popped back to and the rule
1066 number reduced by. */
10fa2066
RS
1067
1068 yyn = yyr1[yyn];
1069
7742ddeb 1070 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
12b0043a 1071 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10fa2066
RS
1072 yystate = yytable[yystate];
1073 else
7742ddeb 1074 yystate = yydefgoto[yyn - YYNTOKENS];
10fa2066
RS
1075
1076 goto yynewstate;
1077
10fa2066 1078
71da9eea
AD
1079/*------------------------------------.
1080| yyerrlab -- here on detecting error |
1081`------------------------------------*/
1082yyerrlab:
1083 /* If not already recovering from an error, report this error. */
1084 if (!yyerrstatus)
10fa2066 1085 {
17da6427 1086 ++yynerrs;
df5aed8c
PE
1087#if YYERROR_VERBOSE
1088 yyn = yypact[yystate];
1089
1090 if (YYPACT_NINF < yyn && yyn < YYLAST)
1091 {
df5aed8c 1092 int yytype = YYTRANSLATE (yychar);
506ffb1f
PE
1093 YYSIZE_T yysize0 = yystrlen (yytname[yytype]);
1094 YYSIZE_T yysize = yysize0;
1095 YYSIZE_T yysize1;
1096 int yysize_overflow = 0;
1097 char *yymsg = 0;
1098# define YYERROR_VERBOSE_ARGS_MAXIMUM 5
1099 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
3aa2f55d 1100 int yyx;
df5aed8c 1101
506ffb1f
PE
1102#if 0
1103 /* This is so xgettext sees the translatable formats that are
1104 constructed on the fly. */
1105 _("syntax error, unexpected %s");
1106 _("syntax error, unexpected %s, expecting %s");
1107 _("syntax error, unexpected %s, expecting %s or %s");
1108 _("syntax error, unexpected %s, expecting %s or %s or %s");
1109 _("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1110#endif
1111 char *yyfmt;
1112 char const *yyf;
1113 static char const yyunexpected[] = "syntax error, unexpected %s";
1114 static char const yyexpecting[] = ", expecting %s";
1115 static char const yyor[] = " or %s";
1116 char yyformat[sizeof yyunexpected
1117 + sizeof yyexpecting - 1
1118 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1119 * (sizeof yyor - 1))];
1120 char const *yyprefix = yyexpecting;
1121
df5aed8c
PE
1122 /* Start YYX at -YYN if negative to avoid negative indexes in
1123 YYCHECK. */
c4749565 1124 int yyxbegin = yyn < 0 ? -yyn : 0;
3aa2f55d
PE
1125
1126 /* Stay within bounds of both yycheck and yytname. */
1127 int yychecklim = YYLAST - yyn;
c4749565 1128 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
506ffb1f
PE
1129 int yycount = 1;
1130
1131 yyarg[0] = yytname[yytype];
1132 yyfmt = yystpcpy (yyformat, yyunexpected);
3aa2f55d 1133
c4749565 1134 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
df5aed8c 1135 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3aa2f55d 1136 {
506ffb1f 1137 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3aa2f55d 1138 {
506ffb1f
PE
1139 yycount = 1;
1140 yysize = yysize0;
1141 yyformat[sizeof yyunexpected - 1] = '\0';
3aa2f55d 1142 break;
c4749565 1143 }
506ffb1f
PE
1144 yyarg[yycount++] = yytname[yyx];
1145 yysize1 = yysize + yystrlen (yytname[yyx]);
1146 yysize_overflow |= yysize1 < yysize;
1147 yysize = yysize1;
1148 yyfmt = yystpcpy (yyfmt, yyprefix);
1149 yyprefix = yyor;
3aa2f55d 1150 }
df5aed8c 1151
506ffb1f
PE
1152 yyf = _(yyformat);
1153 yysize1 = yysize + strlen (yyf);
1154 yysize_overflow |= yysize1 < yysize;
1155 yysize = yysize1;
1156
1157 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
1158 yymsg = (char *) YYSTACK_ALLOC (yysize);
1159 if (yymsg)
1160 {
1161 /* Avoid sprintf, as that infringes on the user's name space.
1162 Don't have undefined behavior even if the translation
1163 produced a string with the wrong number of "%s"s. */
1164 char *yyp = yymsg;
1165 int yyi = 0;
1166 while ((*yyp = *yyf))
df5aed8c 1167 {
506ffb1f
PE
1168 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1169 {
1170 yyp = yystpcpy (yyp, yyarg[yyi++]);
1171 yyf += 2;
1172 }
1173 else
1174 {
1175 yyp++;
1176 yyf++;
1177 }
df5aed8c 1178 }
93724f13 1179 yyerror (]b4_yyerror_args[yymsg);
df5aed8c
PE
1180 YYSTACK_FREE (yymsg);
1181 }
1182 else
506ffb1f 1183 yyerror (]b4_yyerror_args[_("syntax error; also memory exhausted"));
df5aed8c
PE
1184 }
1185 else
1186#endif /* YYERROR_VERBOSE */
1ce59070 1187 yyerror (]b4_yyerror_args[_("syntax error"));
10fa2066 1188 }
71da9eea 1189
3fc16193 1190]b4_location_if([[ yyerror_range[0] = yylloc;]])[
d42f69cd 1191
10fa2066
RS
1192 if (yyerrstatus == 3)
1193 {
8dd162d3 1194 /* If just tried and failed to reuse look-ahead token after an
71da9eea 1195 error, discard it. */
10fa2066 1196
a6b89bb2 1197 if (yychar <= YYEOF)
5719c109 1198 {
a6b89bb2
PE
1199 /* If at end of input, pop the error token,
1200 then the rest of the stack, then return failure. */
1201 if (yychar == YYEOF)
1202 for (;;)
1203 {
3fc16193 1204]b4_location_if([[ yyerror_range[0] = *yylsp;]])[
a6b89bb2
PE
1205 YYPOPSTACK;
1206 if (yyssp == yyss)
1207 YYABORT;
1ce59070 1208 yydestruct (_("Error: popping"),
a0e68930 1209 yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
a6b89bb2 1210 }
5719c109 1211 }
a6b89bb2
PE
1212 else
1213 {
1ce59070 1214 yydestruct (_("Error: discarding"), yytoken, &yylval]b4_location_if([, &yylloc])[);
a6b89bb2 1215 yychar = YYEMPTY;
a6b89bb2 1216 }
10fa2066
RS
1217 }
1218
8dd162d3 1219 /* Else will try to reuse look-ahead token after shifting the error
71da9eea 1220 token. */
8a3eb3c8 1221 goto yyerrlab1;
300a7966 1222
10fa2066 1223
a6b89bb2
PE
1224/*---------------------------------------------------.
1225| yyerrorlab -- error raised explicitly by YYERROR. |
1226`---------------------------------------------------*/
1227yyerrorlab:
1228
c7a65b99
PE
1229 /* Pacify compilers like GCC when the user code never invokes
1230 YYERROR and the label yyerrorlab therefore never appears in user
1231 code. */
a6b89bb2
PE
1232 if (0)
1233 goto yyerrorlab;
a6b89bb2 1234
3fc16193
AD
1235]b4_location_if([[ yyerror_range[0] = yylsp[1-yylen];
1236 yylsp -= yylen;
1237 ]])[yyvsp -= yylen;
a6b89bb2
PE
1238 yyssp -= yylen;
1239 yystate = *yyssp;
3fc16193 1240 goto yyerrlab1;
a6b89bb2
PE
1241
1242
1243/*-------------------------------------------------------------.
1244| yyerrlab1 -- common code for both syntax error and YYERROR. |
1245`-------------------------------------------------------------*/
300a7966 1246yyerrlab1:
cf44a9ae 1247 yyerrstatus = 3; /* Each real token shifted decrements this. */
10fa2066 1248
660bc8dd
PE
1249 for (;;)
1250 {
1251 yyn = yypact[yystate];
12b0043a 1252 if (yyn != YYPACT_NINF)
660bc8dd
PE
1253 {
1254 yyn += YYTERROR;
1255 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1256 {
1257 yyn = yytable[yyn];
1258 if (0 < yyn)
1259 break;
1260 }
1261 }
10fa2066 1262
660bc8dd
PE
1263 /* Pop the current state because it cannot handle the error token. */
1264 if (yyssp == yyss)
1265 YYABORT;
5504898e 1266
3fc16193 1267]b4_location_if([[ yyerror_range[0] = *yylsp;]])[
1ce59070 1268 yydestruct (_("Error: popping"), yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
a6b89bb2
PE
1269 YYPOPSTACK;
1270 yystate = *yyssp;
b0937b22 1271 YY_STACK_PRINT (yyss, yyssp);
10fa2066 1272 }
10fa2066
RS
1273
1274 if (yyn == YYFINAL)
1275 YYACCEPT;
1276
17da6427 1277 *++yyvsp = yylval;
3fc16193
AD
1278]b4_location_if([[
1279 yyerror_range[1] = yylloc;
1280 /* Using YYLLOC is tempting, but would change the location of
1281 the look-ahead. YYLOC is available though. */
1282 YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
1283 *++yylsp = yyloc;]])[
10fa2066 1284
1576d44d 1285 /* Shift the error token. */
1ce59070 1286 YY_SYMBOL_PRINT (_("Shifting"), yystos[yyn], yyvsp, yylsp);
1576d44d 1287
10fa2066
RS
1288 yystate = yyn;
1289 goto yynewstate;
70ddf897 1290
71da9eea
AD
1291
1292/*-------------------------------------.
1293| yyacceptlab -- YYACCEPT comes here. |
1294`-------------------------------------*/
1295yyacceptlab:
600f9b0c
PE
1296 yyresult = 0;
1297 goto yyreturn;
71da9eea
AD
1298
1299/*-----------------------------------.
1300| yyabortlab -- YYABORT comes here. |
1301`-----------------------------------*/
1302yyabortlab:
1ce59070 1303 yydestruct (_("Error: discarding lookahead"),
a0e68930 1304 yytoken, &yylval]b4_location_if([, &yylloc])[);
e757bb10 1305 yychar = YYEMPTY;
600f9b0c
PE
1306 yyresult = 1;
1307 goto yyreturn;
1308
0bfb02ff 1309#ifndef yyoverflow
ca98bf57
AD
1310/*----------------------------------------------.
1311| yyoverflowlab -- parser overflow comes here. |
1312`----------------------------------------------*/
600f9b0c 1313yyoverflowlab:
1ce59070 1314 yyerror (]b4_yyerror_args[_("parser stack overflow"));
600f9b0c
PE
1315 yyresult = 2;
1316 /* Fall through. */
0bfb02ff 1317#endif
600f9b0c
PE
1318
1319yyreturn:
1320#ifndef yyoverflow
1321 if (yyss != yyssa)
1322 YYSTACK_FREE (yyss);
70ddf897 1323#endif
600f9b0c 1324 return yyresult;
be2a1a68
AD
1325]}
1326
24c0aad7 1327
be2a1a68
AD
1328b4_epilogue
1329m4_if(b4_defines_flag, 0, [],
947427ae 1330[@output @output_header_name@
c76e14da 1331b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
779e7ceb 1332 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004])
0252b55c
PE
1333
1334/* As a special exception, when this file is copied by Bison into a
1335 Bison output file, you may use that output file without restriction.
1336 This special exception was added by the Free Software Foundation
1337 in version 1.24 of Bison. */
c76e14da 1338
0d8bed56 1339b4_token_defines(b4_tokens)
be2a1a68 1340
050c471b 1341#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
e9955c83 1342m4_ifdef([b4_stype],
437c2d80 1343[b4_syncline([b4_stype_line], [b4_filename])
050c471b 1344typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
996b1c7e 1345/* Line __line__ of yacc.c. */
947427ae 1346b4_syncline([@oline@], [@ofile@])],
050c471b
PE
1347[typedef int YYSTYPE;])
1348# define yystype YYSTYPE /* obsolescent; will be withdrawn */
1349# define YYSTYPE_IS_DECLARED 1
947427ae 1350# define YYSTYPE_IS_TRIVIAL 1
be2a1a68
AD
1351#endif
1352
74310291 1353b4_pure_if([],
be2a1a68
AD
1354[extern YYSTYPE b4_prefix[]lval;])
1355
58612f1d 1356b4_location_if(
050c471b
PE
1357[#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
1358typedef struct YYLTYPE
be2a1a68
AD
1359{
1360 int first_line;
1361 int first_column;
1362 int last_line;
1363 int last_column;
050c471b
PE
1364} YYLTYPE;
1365# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1366# define YYLTYPE_IS_DECLARED 1
1367# define YYLTYPE_IS_TRIVIAL 1
be2a1a68 1368#endif
ff48177d 1369
be2a1a68
AD
1370m4_if(b4_pure, [0],
1371[extern YYLTYPE b4_prefix[]lloc;])
1372])
be2a1a68 1373])