]> git.saurik.com Git - bison.git/blame - data/yacc.c
Bump version number.
[bison.git] / data / yacc.c
CommitLineData
007a50a4 1m4_divert(-1) -*- C -*-
fb8135fa 2m4_include([c.m4])
a8289c62 3
60491a94 4# Yacc compatible skeleton for Bison
12b0043a
AD
5# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002
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# ------------
21964f43 58# Accumule 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
62b4_location_if([, [[YYLTYPE *], [&yylloc]]])])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
80 b4_ints_in($@, [0], [65535]), [1], [unsigned short],
81 b4_ints_in($@, [-32768], [32767]), [1], [short],
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],
97[yyval[]m4_ifval([$1], [.$1])])
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],
947427ae 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],
117[yyloc])
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],
947427ae 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],
9c1e26bd 138 [1984, 1989, 1990, 2000, 2001, 2002])[
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
AD
156m4_if(b4_prefix[], [yy], [],
157[/* If NAME_PREFIX is specified substitute the variables and functions
17da6427 158 names. */
be2a1a68
AD
159#define yyparse b4_prefix[]parse
160#define yylex b4_prefix[]lex
161#define yyerror b4_prefix[]error
162#define yylval b4_prefix[]lval
163#define yychar b4_prefix[]char
164#define yydebug b4_prefix[]debug
165#define yynerrs b4_prefix[]nerrs
9c1e26bd 166b4_location_if([#define yylloc b4_prefix[]lloc])])[
17da6427 167
9c1e26bd 168]b4_token_defines(b4_tokens)[
17acead5 169
0dd1580a 170/* Copy the first part of user declarations. */
9c1e26bd 171]b4_pre_prologue[
cce71710 172
d99361e6
AD
173/* Enabling traces. */
174#ifndef YYDEBUG
9c1e26bd 175# define YYDEBUG ]b4_debug[
d99361e6
AD
176#endif
177
178/* Enabling verbose error messages. */
179#ifdef YYERROR_VERBOSE
180# undef YYERROR_VERBOSE
181# define YYERROR_VERBOSE 1
182#else
9c1e26bd 183# define YYERROR_VERBOSE ]b4_error_verbose[
d99361e6
AD
184#endif
185
050c471b 186#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
9c1e26bd 187]m4_ifdef([b4_stype],
437c2d80 188[b4_syncline([b4_stype_line], [b4_filename])
050c471b 189typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
996b1c7e 190/* Line __line__ of yacc.c. */
947427ae 191b4_syncline([@oline@], [@ofile@])],
050c471b
PE
192[typedef int YYSTYPE;])[
193# define yystype YYSTYPE /* obsolescent; will be withdrawn */
194# define YYSTYPE_IS_DECLARED 1
71cd15d4 195# define YYSTYPE_IS_TRIVIAL 1
fd51e5ff
AD
196#endif
197
050c471b
PE
198]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
199typedef struct YYLTYPE
fd51e5ff
AD
200{
201 int first_line;
202 int first_column;
203 int last_line;
204 int last_column;
050c471b
PE
205} YYLTYPE;
206# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
207# define YYLTYPE_IS_DECLARED 1
71cd15d4 208# define YYLTYPE_IS_TRIVIAL 1
fd51e5ff 209#endif
1915f133 210])[
fd51e5ff 211
0dd1580a 212/* Copy the second part of user declarations. */
ee41006f 213]b4_post_prologue
0dd1580a 214
996b1c7e 215/* Line __line__ of yacc.c. */
ee41006f 216b4_syncline([@oline@], [@ofile@])[
7093d0f5 217
cf44a9ae 218#if ! defined (yyoverflow) || YYERROR_VERBOSE
7093d0f5
AD
219
220/* The parser invokes alloca or malloc; define the necessary symbols. */
221
222# if YYSTACK_USE_ALLOCA
223# define YYSTACK_ALLOC alloca
7093d0f5
AD
224# else
225# ifndef YYSTACK_USE_ALLOCA
226# if defined (alloca) || defined (_ALLOCA_H)
227# define YYSTACK_ALLOC alloca
7093d0f5 228# else
0d8a7363 229# ifdef __GNUC__
7093d0f5
AD
230# define YYSTACK_ALLOC __builtin_alloca
231# endif
7093d0f5
AD
232# endif
233# endif
234# endif
235
236# ifdef YYSTACK_ALLOC
237 /* Pacify GCC's `empty if-body' warning. */
238# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
239# else
45119af1
PE
240# if defined (__STDC__) || defined (__cplusplus)
241# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
242# define YYSIZE_T size_t
7093d0f5 243# endif
45119af1
PE
244# define YYSTACK_ALLOC malloc
245# define YYSTACK_FREE free
7093d0f5 246# endif
cf44a9ae
PE
247#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
248
249
250#if (! defined (yyoverflow) \
251 && (! defined (__cplusplus) \
1915f133 252 || (]b4_location_if([YYLTYPE_IS_TRIVIAL && ])[YYSTYPE_IS_TRIVIAL)))
7093d0f5 253
600f9b0c
PE
254/* A type that is properly aligned for any stack member. */
255union yyalloc
256{
2729e106
PE
257 short yyss;
258 YYSTYPE yyvs;
9c1e26bd 259 ]b4_location_if([ YYLTYPE yyls;
58612f1d 260])dnl
9c1e26bd 261[};
600f9b0c
PE
262
263/* The size of the maximum gap between one aligned stack and the next. */
17836590 264# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
600f9b0c
PE
265
266/* The size of an array large to enough to hold all stacks, each with
267 N elements. */
9c1e26bd 268]b4_location_if(
58612f1d 269[# define YYSTACK_BYTES(N) \
cf44a9ae 270 ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
17836590 271 + 2 * YYSTACK_GAP_MAXIMUM)],
58612f1d 272[# define YYSTACK_BYTES(N) \
cf44a9ae 273 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
17836590 274 + YYSTACK_GAP_MAXIMUM)])[
600f9b0c 275
5b041382
PE
276/* Copy COUNT objects from FROM to TO. The source and destination do
277 not overlap. */
278# ifndef YYCOPY
279# if 1 < __GNUC__
280# define YYCOPY(To, From, Count) \
281 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
282# else
283# define YYCOPY(To, From, Count) \
284 do \
285 { \
286 register YYSIZE_T yyi; \
287 for (yyi = 0; yyi < (Count); yyi++) \
9c1e26bd 288 (To)[yyi] = (From)[yyi]; \
5b041382
PE
289 } \
290 while (0)
291# endif
292# endif
293
294/* Relocate STACK from its old location to the new one. The
7093d0f5 295 local variables YYSIZE and YYSTACKSIZE give the old and new number of
600f9b0c
PE
296 elements in the stack, and YYPTR gives the new location of the
297 stack. Advance YYPTR to a properly aligned location for the next
298 stack. */
5b041382 299# define YYSTACK_RELOCATE(Stack) \
7093d0f5
AD
300 do \
301 { \
302 YYSIZE_T yynewbytes; \
5b041382 303 YYCOPY (&yyptr->Stack, Stack, yysize); \
2729e106 304 Stack = &yyptr->Stack; \
17836590 305 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2729e106 306 yyptr += yynewbytes / sizeof (*yyptr); \
7093d0f5
AD
307 } \
308 while (0)
309
cf44a9ae 310#endif
8850be4b 311
768eb43f
PE
312#if defined (__STDC__) || defined (__cplusplus)
313 typedef signed char yysigned_char;
314#else
315 typedef short yysigned_char;
316#endif
317
7742ddeb 318/* YYFINAL -- State number of the termination state. */
9c1e26bd 319#define YYFINAL ]b4_final_state_number[
39912f52 320/* YYLAST -- Last index in YYTABLE. */
9c1e26bd 321#define YYLAST ]b4_last[
7742ddeb
AD
322
323/* YYNTOKENS -- Number of terminals. */
9c1e26bd 324#define YYNTOKENS ]b4_tokens_number[
7742ddeb 325/* YYNNTS -- Number of nonterminals. */
9c1e26bd 326#define YYNNTS ]b4_nterms_number[
7742ddeb 327/* YYNRULES -- Number of rules. */
9c1e26bd 328#define YYNRULES ]b4_rules_number[
7742ddeb 329/* YYNRULES -- Number of states. */
9c1e26bd 330#define YYNSTATES ]b4_states_number[
7742ddeb
AD
331
332/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
9c1e26bd
AD
333#define YYUNDEFTOK ]b4_undef_token_number[
334#define YYMAXUTOK ]b4_user_token_number_max[
007a50a4 335
b0400cc6 336#define YYTRANSLATE(YYX) \
a20713a4 337 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
a8289c62 338
b0400cc6
AD
339/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
340static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
a8289c62 341{
c5e3e510 342 ]b4_translate[
a8289c62
RA
343};
344
345#if YYDEBUG
c5e3e510 346/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
7742ddeb 347 YYRHS. */
c5e3e510 348static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
a8289c62 349{
c5e3e510 350 ]b4_prhs[
a8289c62
RA
351};
352
3db472b9 353/* YYRHS -- A `-1'-separated list of the rules' RHS. */
c5e3e510 354static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
a8289c62 355{
c5e3e510 356 ]b4_rhs[
a8289c62
RA
357};
358
c5e3e510
AD
359/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
360static const ]b4_int_type_for([b4_rline])[ yyrline[] =
a8289c62 361{
c5e3e510 362 ]b4_rline[
a8289c62
RA
363};
364#endif
365
5504898e 366#if YYDEBUG || YYERROR_VERBOSE
c5e3e510 367/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
7742ddeb 368 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
c5e3e510 369static const char *const yytname[] =
a8289c62 370{
c5e3e510 371 ]b4_tname[
a8289c62
RA
372};
373#endif
374
c0ad8bf3 375# ifdef YYPRINT
c5e3e510 376/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
769b430f 377 token YYLEX-NUM. */
c5e3e510 378static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
a8289c62 379{
c5e3e510 380 ]b4_toknum[
a8289c62 381};
c0ad8bf3 382# endif
a8289c62 383
c5e3e510
AD
384/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
385static const ]b4_int_type_for([b4_r1])[ yyr1[] =
a8289c62 386{
c5e3e510 387 ]b4_r1[
a8289c62
RA
388};
389
c5e3e510
AD
390/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
391static const ]b4_int_type_for([b4_r2])[ yyr2[] =
a8289c62 392{
c5e3e510 393 ]b4_r2[
a8289c62
RA
394};
395
c5e3e510 396/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
5504898e
AD
397 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
398 means the default is an error. */
c5e3e510 399static const ]b4_int_type_for([b4_defact])[ yydefact[] =
a8289c62 400{
c5e3e510 401 ]b4_defact[
a8289c62
RA
402};
403
c5e3e510
AD
404/* YYDEFGOTO[NTERM-NUM]. */
405static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
a8289c62 406{
c5e3e510 407 ]b4_defgoto[
a8289c62
RA
408};
409
c5e3e510 410/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
7742ddeb 411 STATE-NUM. */
c5e3e510
AD
412#define YYPACT_NINF ]b4_pact_ninf[
413static const ]b4_int_type_for([b4_pact])[ yypact[] =
a8289c62 414{
c5e3e510 415 ]b4_pact[
a8289c62
RA
416};
417
c5e3e510
AD
418/* YYPGOTO[NTERM-NUM]. */
419static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
a8289c62 420{
c5e3e510 421 ]b4_pgoto[
a8289c62
RA
422};
423
c5e3e510 424/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
7742ddeb 425 positive, shift that token. If negative, reduce the rule which
f50adbbd 426 number is the opposite. If zero, do what YYDEFACT says.
6e649e65 427 If YYTABLE_NINF, syntax error. */
c5e3e510
AD
428#define YYTABLE_NINF ]b4_table_ninf[
429static const ]b4_int_type_for([b4_table])[ yytable[] =
a8289c62 430{
c5e3e510 431 ]b4_table[
a8289c62
RA
432};
433
c5e3e510 434static const ]b4_int_type_for([b4_check])[ yycheck[] =
a8289c62 435{
c5e3e510 436 ]b4_check[
a8289c62
RA
437};
438
c5e3e510 439/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
5504898e 440 symbol of state STATE-NUM. */
c5e3e510 441static const ]b4_int_type_for([b4_stos])[ yystos[] =
5504898e 442{
c5e3e510 443 ]b4_stos[
5504898e 444};
7093d0f5
AD
445
446#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
447# define YYSIZE_T __SIZE_TYPE__
448#endif
449#if ! defined (YYSIZE_T) && defined (size_t)
450# define YYSIZE_T size_t
451#endif
b7575ffe 452#if ! defined (YYSIZE_T)
45119af1
PE
453# if defined (__STDC__) || defined (__cplusplus)
454# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
455# define YYSIZE_T size_t
b7575ffe 456# endif
7093d0f5
AD
457#endif
458#if ! defined (YYSIZE_T)
459# define YYSIZE_T unsigned int
460#endif
461
10fa2066 462#define yyerrok (yyerrstatus = 0)
a20713a4
PE
463#define yyclearin (yychar = YYEMPTY)
464#define YYEMPTY (-2)
10fa2066 465#define YYEOF 0
a8289c62 466
70ddf897 467#define YYACCEPT goto yyacceptlab
a8289c62 468#define YYABORT goto yyabortlab
10fa2066 469#define YYERROR goto yyerrlab1
a8289c62 470
71da9eea
AD
471/* Like YYERROR except do call yyerror. This remains here temporarily
472 to ease the transition to the new meaning of YYERROR, for GCC.
10fa2066 473 Once GCC version 2 has supplanted version 1, this can go. */
a8289c62 474
10fa2066 475#define YYFAIL goto yyerrlab
a8289c62 476
10fa2066 477#define YYRECOVERING() (!!yyerrstatus)
a8289c62 478
69b4e0c5 479#define YYBACKUP(Token, Value) \
10fa2066 480do \
a20713a4 481 if (yychar == YYEMPTY && yylen == 1) \
71da9eea 482 { \
17da6427 483 yychar = (Token); \
7742ddeb 484 yylval = (Value); \
b0400cc6 485 yytoken = YYTRANSLATE (yychar); \
10fa2066
RS
486 YYPOPSTACK; \
487 goto yybackup; \
488 } \
489 else \
71da9eea 490 { \
9c1e26bd 491 yyerror (]b4_yyerror_args["syntax error: cannot back up");\
71da9eea
AD
492 YYERROR; \
493 } \
10fa2066
RS
494while (0)
495
496#define YYTERROR 1
497#define YYERRCODE 256
498
3abcd459 499/* YYLLOC_DEFAULT -- Compute the default location (before the actions
b2d52318 500 are run). */
3abcd459
AD
501
502#ifndef YYLLOC_DEFAULT
9c1e26bd
AD
503# define YYLLOC_DEFAULT(Current, Rhs, N) \
504 Current.first_line = Rhs[1].first_line; \
505 Current.first_column = Rhs[1].first_column; \
506 Current.last_line = Rhs[N].last_line; \
507 Current.last_column = Rhs[N].last_column;
3abcd459
AD
508#endif
509
3abcd459 510/* YYLEX -- calling `yylex' with the right arguments. */
553e2b22 511
ae7453f2 512#ifdef YYLEX_PARAM
9c1e26bd 513# define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)
74310291 514#else
9c1e26bd 515# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
ae7453f2 516#endif
553e2b22 517
5a35a6cb 518/* Enable debugging if requested. */
0d533154 519#if YYDEBUG
b7575ffe
PE
520
521# ifndef YYFPRINTF
45119af1
PE
522# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
523# define YYFPRINTF fprintf
b7575ffe
PE
524# endif
525
5a35a6cb
AD
526# define YYDPRINTF(Args) \
527do { \
17da6427 528 if (yydebug) \
b7575ffe 529 YYFPRINTF Args; \
5a35a6cb 530} while (0)
c5e3e510 531
253862fd
AD
532# define YYDSYMPRINT(Args) \
533do { \
534 if (yydebug) \
535 yysymprint Args; \
536} while (0)
c5e3e510 537
9c1e26bd
AD
538# define YYDSYMPRINTF(Title, Token, Value, Location) \
539do { \
540 if (yydebug) \
541 { \
542 YYFPRINTF (stderr, "%s ", Title); \
543 yysymprint (stderr, \
544 Token, Value]b4_location_if([, Location])[); \
545 YYFPRINTF (stderr, "\n"); \
546 } \
547} while (0)
548
b0937b22
AD
549/*------------------------------------------------------------------.
550| yy_stack_print -- Print the state stack from its BOTTOM up to its |
551| TOP (cinluded). |
552`------------------------------------------------------------------*/
553
554]b4_c_function_def([yy_stack_print], [static void],
555 [[short *bottom], [bottom]],
556 [[short *top], [top]])[
557{
558 YYFPRINTF (stderr, "Stack now");
559 for (/* Nothing. */; bottom <= top; ++bottom)
560 YYFPRINTF (stderr, " %d", *bottom);
561 YYFPRINTF (stderr, "\n");
562}
563
564# define YY_STACK_PRINT(Bottom, Top) \
565do { \
566 if (yydebug) \
567 yy_stack_print ((Bottom), (Top)); \
568} while (0)
569
570
571/*------------------------------------------------.
572| Report that the YYRULE is going to be reduced. |
573`------------------------------------------------*/
574
575]b4_c_function_def([yy_reduce_print], [static void],
576 [[int yyrule], [yyrule]])[
577{
578 int yyi;
4f21fffe
PE
579 unsigned int yylineno = yyrline[yyrule];
580 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
581 yyrule - 1, yylineno);
b0937b22
AD
582 /* Print the symbols being reduced, and their result. */
583 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
584 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
585 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
586}
587
588# define YY_REDUCE_PRINT(Rule) \
589do { \
590 if (yydebug) \
591 yy_reduce_print (Rule); \
592} while (0)
593
cf44a9ae
PE
594/* Nonzero means print parse trace. It is left uninitialized so that
595 multiple parsers can coexist. */
17da6427 596int yydebug;
5a35a6cb
AD
597#else /* !YYDEBUG */
598# define YYDPRINTF(Args)
253862fd 599# define YYDSYMPRINT(Args)
9c1e26bd 600# define YYDSYMPRINTF(Title, Token, Value, Location)
b0937b22
AD
601# define YY_STACK_PRINT(Bottom, Top)
602# define YY_REDUCE_PRINT(Rule)
5a35a6cb
AD
603#endif /* !YYDEBUG */
604
b0937b22 605
5a35a6cb 606/* YYINITDEPTH -- initial size of the parser's stacks. */
10fa2066 607#ifndef YYINITDEPTH
9c1e26bd 608# define YYINITDEPTH ]b4_stack_depth_init[
10fa2066
RS
609#endif
610
5a35a6cb 611/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
600f9b0c
PE
612 if the built-in stack extension method is used).
613
614 Do not make this value too large; the results are undefined if
615 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
616 evaluated with infinite-precision integer arithmetic. */
617
10fa2066 618#if YYMAXDEPTH == 0
b07b484a 619# undef YYMAXDEPTH
10fa2066
RS
620#endif
621
622#ifndef YYMAXDEPTH
9c1e26bd 623# define YYMAXDEPTH ]b4_stack_depth_max[
10fa2066 624#endif
a8289c62 625
10fa2066 626\f
a8289c62 627
7093d0f5
AD
628#if YYERROR_VERBOSE
629
630# ifndef yystrlen
631# if defined (__GLIBC__) && defined (_STRING_H)
632# define yystrlen strlen
633# else
634/* Return the length of YYSTR. */
635static YYSIZE_T
636# if defined (__STDC__) || defined (__cplusplus)
637yystrlen (const char *yystr)
638# else
639yystrlen (yystr)
640 const char *yystr;
641# endif
642{
643 register const char *yys = yystr;
644
645 while (*yys++ != '\0')
646 continue;
647
648 return yys - yystr - 1;
649}
650# endif
651# endif
652
653# ifndef yystpcpy
654# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
655# define yystpcpy stpcpy
656# else
657/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
658 YYDEST. */
659static char *
f11966ff
PE
660# if defined (__STDC__) || defined (__cplusplus)
661yystpcpy (char *yydest, const char *yysrc)
662# else
7093d0f5
AD
663yystpcpy (yydest, yysrc)
664 char *yydest;
665 const char *yysrc;
7093d0f5
AD
666# endif
667{
668 register char *yyd = yydest;
669 register const char *yys = yysrc;
670
671 while ((*yyd++ = *yys++) != '\0')
672 continue;
673
674 return yyd - 1;
675}
676# endif
677# endif
678
679#endif /* !YYERROR_VERBOSE */
680
10fa2066 681\f
a8289c62 682
b8df3223 683#if YYDEBUG
9c1e26bd 684]b4_yysymprint_generate([b4_c_function_def])[
c5e3e510 685#endif /* ! YYDEBUG */
9c1e26bd 686]b4_yydestruct_generate([b4_c_function_def])
4a2a22f4
AD
687\f
688
0245f82d 689/* Prevent warnings from -Wmissing-prototypes. */
4a2a22f4
AD
690
691#ifdef YYPARSE_PARAM
692# if defined (__STDC__) || defined (__cplusplus)
0245f82d 693int yyparse (void *YYPARSE_PARAM);
4a2a22f4 694# else
0245f82d 695int yyparse ();
4a2a22f4 696# endif
0245f82d
AD
697#else /* ! YYPARSE_PARAM */
698b4_c_function_decl([yyparse], [int], b4_parse_param)
c5e3e510 699#endif /* ! YYPARSE_PARAM */
1b181651 700
0245f82d 701
74310291
AD
702m4_divert_push([KILL])# ======================== M4 code.
703# b4_declare_parser_variables
704# ---------------------------
705# Declare the variables that are global, or local to YYPARSE if
0245f82d 706# pure-parser.
74310291
AD
707m4_define([b4_declare_parser_variables],
708[/* The lookahead symbol. */
709int yychar;
710
711/* The semantic value of the lookahead symbol. */
712YYSTYPE yylval;
713
6e649e65 714/* Number of syntax errors so far. */
74310291
AD
715int yynerrs;b4_location_if([
716/* Location data for the lookahead symbol. */
58612f1d 717YYLTYPE yylloc;])
74310291
AD
718])
719m4_divert_pop([KILL])dnl# ====================== End of M4 code.
58612f1d 720
74310291
AD
721b4_pure_if([],
722 [b4_declare_parser_variables])
a35f64ea 723
0245f82d
AD
724
725/*----------.
726| yyparse. |
727`----------*/
728
729#ifdef YYPARSE_PARAM
730# if defined (__STDC__) || defined (__cplusplus)
731int yyparse (void *YYPARSE_PARAM)
732# else
733int yyparse (YYPARSE_PARAM)
734 void *YYPARSE_PARAM;
735# endif
736#else /* ! YYPARSE_PARAM */
737b4_c_function_def([yyparse], [int], b4_parse_param)
738#endif
be2a1a68 739{[
74310291 740 ]b4_pure_if([b4_declare_parser_variables])[
10fa2066
RS
741 register int yystate;
742 register int yyn;
600f9b0c 743 int yyresult;
b07b484a
AD
744 /* Number of tokens to shift before error messages enabled. */
745 int yyerrstatus;
746 /* Lookahead token as an internal (translated) token number. */
b0400cc6 747 int yytoken = 0;
10fa2066 748
bb10be54
AD
749 /* Three stacks and their tools:
750 `yyss': related to states,
e9e4c321 751 `yyvs': related to semantic values,
bb10be54
AD
752 `yyls': related to locations.
753
754 Refer to the stacks thru separate pointers, to allow yyoverflow
755 to reallocate them elsewhere. */
756
e8cb70b9 757 /* The state stack. */
b07b484a 758 short yyssa[YYINITDEPTH];
bb10be54
AD
759 short *yyss = yyssa;
760 register short *yyssp;
761
b07b484a
AD
762 /* The semantic value stack. */
763 YYSTYPE yyvsa[YYINITDEPTH];
b07b484a 764 YYSTYPE *yyvs = yyvsa;
bb10be54 765 register YYSTYPE *yyvsp;
10fa2066 766
58612f1d
AD
767]b4_location_if(
768[[ /* The location stack. */
b07b484a 769 YYLTYPE yylsa[YYINITDEPTH];
10fa2066 770 YYLTYPE *yyls = yylsa;
58612f1d 771 YYLTYPE *yylsp;]])[
10fa2066 772
58612f1d 773#define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
10fa2066 774
7093d0f5 775 YYSIZE_T yystacksize = YYINITDEPTH;
10fa2066 776
6666f98f
AD
777 /* The variables used to return semantic value and location from the
778 action routines. */
bb10be54 779 YYSTYPE yyval;
58612f1d 780]b4_location_if([ YYLTYPE yyloc;])[
10fa2066 781
6666f98f 782 /* When reducing, the number of symbols on the RHS of the reduced
e8cb70b9 783 rule. */
10fa2066
RS
784 int yylen;
785
7ea5e977 786 YYDPRINTF ((stderr, "Starting parse\n"));
10fa2066
RS
787
788 yystate = 0;
789 yyerrstatus = 0;
17da6427 790 yynerrs = 0;
a20713a4 791 yychar = YYEMPTY; /* Cause a token to be read. */
10fa2066
RS
792
793 /* Initialize stack pointers.
794 Waste one element of value and location stack
795 so that they stay on the same level as the state stack.
796 The wasted elements are never initialized. */
797
cbd89906 798 yyssp = yyss;
10fa2066 799 yyvsp = yyvs;
58612f1d 800]b4_location_if([ yylsp = yyls;])[
cbd89906 801 goto yysetstate;
10fa2066 802
71da9eea
AD
803/*------------------------------------------------------------.
804| yynewstate -- Push a new state, which is found in yystate. |
805`------------------------------------------------------------*/
342b8b6e 806 yynewstate:
71da9eea
AD
807 /* In all cases, when you get here, the value and location stacks
808 have just been pushed. so pushing a state here evens the stacks.
809 */
cbd89906
PE
810 yyssp++;
811
342b8b6e 812 yysetstate:
cbd89906 813 *yyssp = yystate;
10fa2066 814
39912f52 815 if (yyss + yystacksize - 1 <= yyssp)
10fa2066 816 {
10fa2066 817 /* Get the current used size of the three stacks, in elements. */
7093d0f5 818 YYSIZE_T yysize = yyssp - yyss + 1;
10fa2066
RS
819
820#ifdef yyoverflow
3d76b07d
AD
821 {
822 /* Give user a chance to reallocate the stack. Use copies of
823 these so that the &'s don't force the real ones into
824 memory. */
825 YYSTYPE *yyvs1 = yyvs;
826 short *yyss1 = yyss;
58612f1d 827]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
3d76b07d
AD
828
829 /* Each stack pointer address is followed by the size of the
58612f1d
AD
830 data in use in that stack, in bytes. This used to be a
831 conditional around just the two extra args, but that might
832 be undefined if yyoverflow is a macro. */
3d76b07d 833 yyoverflow ("parser stack overflow",
7093d0f5
AD
834 &yyss1, yysize * sizeof (*yyssp),
835 &yyvs1, yysize * sizeof (*yyvsp),
58612f1d 836]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
3d76b07d 837 &yystacksize);
58612f1d 838]b4_location_if([ yyls = yyls1;])[
3d76b07d
AD
839 yyss = yyss1;
840 yyvs = yyvs1;
841 }
10fa2066 842#else /* no yyoverflow */
cf44a9ae
PE
843# ifndef YYSTACK_RELOCATE
844 goto yyoverflowlab;
845# else
10fa2066 846 /* Extend the stack our own way. */
39912f52 847 if (YYMAXDEPTH <= yystacksize)
600f9b0c 848 goto yyoverflowlab;
10fa2066 849 yystacksize *= 2;
39912f52 850 if (YYMAXDEPTH < yystacksize)
10fa2066 851 yystacksize = YYMAXDEPTH;
e9e4c321 852
600f9b0c
PE
853 {
854 short *yyss1 = yyss;
2729e106
PE
855 union yyalloc *yyptr =
856 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
600f9b0c
PE
857 if (! yyptr)
858 goto yyoverflowlab;
5b041382
PE
859 YYSTACK_RELOCATE (yyss);
860 YYSTACK_RELOCATE (yyvs);
58612f1d 861]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
cf44a9ae 862# undef YYSTACK_RELOCATE
600f9b0c
PE
863 if (yyss1 != yyssa)
864 YYSTACK_FREE (yyss1);
865 }
cf44a9ae 866# endif
10fa2066
RS
867#endif /* no yyoverflow */
868
7093d0f5
AD
869 yyssp = yyss + yysize - 1;
870 yyvsp = yyvs + yysize - 1;
58612f1d 871]b4_location_if([ yylsp = yyls + yysize - 1;])[
10fa2066 872
7ea5e977 873 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
600f9b0c 874 (unsigned long int) yystacksize));
10fa2066 875
39912f52 876 if (yyss + yystacksize - 1 <= yyssp)
10fa2066
RS
877 YYABORT;
878 }
879
7ea5e977 880 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
10fa2066
RS
881
882 goto yybackup;
71da9eea 883
71da9eea
AD
884/*-----------.
885| yybackup. |
886`-----------*/
887yybackup:
10fa2066
RS
888
889/* Do appropriate processing given the current state. */
890/* Read a lookahead token if we need one and don't already have one. */
891/* yyresume: */
892
893 /* First try to decide what to do without reference to lookahead token. */
894
895 yyn = yypact[yystate];
12b0043a 896 if (yyn == YYPACT_NINF)
10fa2066
RS
897 goto yydefault;
898
899 /* Not known => get a lookahead token if don't already have one. */
900
a20713a4
PE
901 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
902 if (yychar == YYEMPTY)
10fa2066 903 {
7ea5e977 904 YYDPRINTF ((stderr, "Reading a token: "));
17da6427 905 yychar = YYLEX;
10fa2066
RS
906 }
907
a20713a4 908 if (yychar <= YYEOF)
10fa2066 909 {
a20713a4 910 yychar = yytoken = YYEOF;
7ea5e977 911 YYDPRINTF ((stderr, "Now at end of input.\n"));
10fa2066
RS
912 }
913 else
914 {
a20713a4 915 yytoken = YYTRANSLATE (yychar);
9c1e26bd 916 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
10fa2066
RS
917 }
918
b0400cc6 919 /* If the proper action on seeing token YYTOKEN is to reduce or to
e5cfd9d8 920 detect an error, take that action. */
b0400cc6
AD
921 yyn += yytoken;
922 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
e5cfd9d8
PE
923 goto yydefault;
924 yyn = yytable[yyn];
925 if (yyn <= 0)
10fa2066 926 {
e5cfd9d8
PE
927 if (yyn == 0 || yyn == YYTABLE_NINF)
928 goto yyerrlab;
10fa2066
RS
929 yyn = -yyn;
930 goto yyreduce;
931 }
10fa2066
RS
932
933 if (yyn == YYFINAL)
934 YYACCEPT;
935
936 /* Shift the lookahead token. */
9c1e26bd 937 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
10fa2066
RS
938
939 /* Discard the token being shifted unless it is eof. */
a20713a4
PE
940 if (yychar != YYEOF)
941 yychar = YYEMPTY;
10fa2066 942
17da6427 943 *++yyvsp = yylval;
58612f1d 944]b4_location_if([ *++yylsp = yylloc;])[
10fa2066 945
71da9eea
AD
946 /* Count tokens shifted since error; after three, turn off error
947 status. */
948 if (yyerrstatus)
949 yyerrstatus--;
10fa2066
RS
950
951 yystate = yyn;
952 goto yynewstate;
953
10fa2066 954
71da9eea
AD
955/*-----------------------------------------------------------.
956| yydefault -- do the default action for the current state. |
957`-----------------------------------------------------------*/
958yydefault:
10fa2066
RS
959 yyn = yydefact[yystate];
960 if (yyn == 0)
961 goto yyerrlab;
71da9eea 962 goto yyreduce;
10fa2066 963
71da9eea
AD
964
965/*-----------------------------.
966| yyreduce -- Do a reduction. |
967`-----------------------------*/
10fa2066 968yyreduce:
71da9eea 969 /* yyn is the number of a rule to reduce with. */
10fa2066 970 yylen = yyr2[yyn];
da9abf43
AD
971
972 /* If YYLEN is nonzero, implement the default value of the action:
573c1d9f 973 `$$ = $1'.
da9abf43 974
accea6db
PE
975 Otherwise, the following line sets YYVAL to garbage.
976 This behavior is undocumented and Bison
da9abf43
AD
977 users should not rely upon it. Assigning to YYVAL
978 unconditionally makes the parser a bit smaller, and it avoids a
979 GCC warning that YYVAL may be used uninitialized. */
980 yyval = yyvsp[1-yylen];
3abcd459 981
58612f1d
AD
982]b4_location_if(
983[ /* Default location. */
984 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
b0937b22 985 YY_REDUCE_PRINT (yyn);
a8289c62 986 switch (yyn)
be2a1a68
AD
987 ]{
988 b4_actions
a8289c62 989 }
897668ee 990
996b1c7e 991/* Line __line__ of yacc.c. */
947427ae 992b4_syncline([@oline@], [@ofile@])
10fa2066 993\f
be2a1a68 994[ yyvsp -= yylen;
10fa2066 995 yyssp -= yylen;
58612f1d 996]b4_location_if([ yylsp -= yylen;])[
10fa2066 997
b0937b22 998 YY_STACK_PRINT (yyss, yyssp);
10fa2066
RS
999
1000 *++yyvsp = yyval;
58612f1d 1001]b4_location_if([ *++yylsp = yyloc;])[
10fa2066 1002
41aca2e0
AD
1003 /* Now `shift' the result of the reduction. Determine what state
1004 that goes to, based on the state we popped back to and the rule
1005 number reduced by. */
10fa2066
RS
1006
1007 yyn = yyr1[yyn];
1008
7742ddeb 1009 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
12b0043a 1010 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10fa2066
RS
1011 yystate = yytable[yystate];
1012 else
7742ddeb 1013 yystate = yydefgoto[yyn - YYNTOKENS];
10fa2066
RS
1014
1015 goto yynewstate;
1016
10fa2066 1017
71da9eea
AD
1018/*------------------------------------.
1019| yyerrlab -- here on detecting error |
1020`------------------------------------*/
1021yyerrlab:
1022 /* If not already recovering from an error, report this error. */
1023 if (!yyerrstatus)
10fa2066 1024 {
17da6427 1025 ++yynerrs;
df5aed8c
PE
1026#if YYERROR_VERBOSE
1027 yyn = yypact[yystate];
1028
1029 if (YYPACT_NINF < yyn && yyn < YYLAST)
1030 {
1031 YYSIZE_T yysize = 0;
1032 int yytype = YYTRANSLATE (yychar);
1033 char *yymsg;
1034 int yyx, yycount;
1035
1036 yycount = 0;
1037 /* Start YYX at -YYN if negative to avoid negative indexes in
1038 YYCHECK. */
1039 for (yyx = yyn < 0 ? -yyn : 0;
1040 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1041 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1042 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
6e649e65 1043 yysize += yystrlen ("syntax error, unexpected ") + 1;
df5aed8c
PE
1044 yysize += yystrlen (yytname[yytype]);
1045 yymsg = (char *) YYSTACK_ALLOC (yysize);
1046 if (yymsg != 0)
1047 {
6e649e65 1048 char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
df5aed8c
PE
1049 yyp = yystpcpy (yyp, yytname[yytype]);
1050
1051 if (yycount < 5)
1052 {
1053 yycount = 0;
1054 for (yyx = yyn < 0 ? -yyn : 0;
1055 yyx < (int) (sizeof (yytname) / sizeof (char *));
1056 yyx++)
1057 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1058 {
1059 const char *yyq = ! yycount ? ", expecting " : " or ";
1060 yyp = yystpcpy (yyp, yyq);
1061 yyp = yystpcpy (yyp, yytname[yyx]);
1062 yycount++;
1063 }
1064 }
93724f13 1065 yyerror (]b4_yyerror_args[yymsg);
df5aed8c
PE
1066 YYSTACK_FREE (yymsg);
1067 }
1068 else
6e649e65 1069 yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted");
df5aed8c
PE
1070 }
1071 else
1072#endif /* YYERROR_VERBOSE */
6e649e65 1073 yyerror (]b4_yyerror_args["syntax error");
10fa2066 1074 }
71da9eea 1075
10fa2066
RS
1076 if (yyerrstatus == 3)
1077 {
71da9eea
AD
1078 /* If just tried and failed to reuse lookahead token after an
1079 error, discard it. */
10fa2066 1080
e8cb70b9 1081 /* Return failure if at end of input. */
a20713a4 1082 if (yychar == YYEOF)
5719c109
AD
1083 {
1084 /* Pop the error token. */
1085 YYPOPSTACK;
1086 /* Pop the rest of the stack. */
39912f52 1087 while (yyss < yyssp)
5719c109 1088 {
9c1e26bd 1089 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
7bd6c77e 1090 yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
5719c109
AD
1091 YYPOPSTACK;
1092 }
1093 YYABORT;
1094 }
1095
9c1e26bd 1096 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
7bd6c77e 1097 yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
a20713a4 1098 yychar = YYEMPTY;
10fa2066
RS
1099 }
1100
71da9eea
AD
1101 /* Else will try to reuse lookahead token after shifting the error
1102 token. */
300a7966
PE
1103 goto yyerrlab1;
1104
10fa2066 1105
300a7966
PE
1106/*----------------------------------------------------.
1107| yyerrlab1 -- error raised explicitly by an action. |
1108`----------------------------------------------------*/
1109yyerrlab1:
cf44a9ae 1110 yyerrstatus = 3; /* Each real token shifted decrements this. */
10fa2066 1111
660bc8dd
PE
1112 for (;;)
1113 {
1114 yyn = yypact[yystate];
12b0043a 1115 if (yyn != YYPACT_NINF)
660bc8dd
PE
1116 {
1117 yyn += YYTERROR;
1118 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1119 {
1120 yyn = yytable[yyn];
1121 if (0 < yyn)
1122 break;
1123 }
1124 }
10fa2066 1125
660bc8dd
PE
1126 /* Pop the current state because it cannot handle the error token. */
1127 if (yyssp == yyss)
1128 YYABORT;
5504898e 1129
9c1e26bd 1130 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
7bd6c77e 1131 yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
660bc8dd
PE
1132 yyvsp--;
1133 yystate = *--yyssp;
58612f1d 1134]b4_location_if([ yylsp--;])[
b0937b22 1135 YY_STACK_PRINT (yyss, yyssp);
10fa2066 1136 }
10fa2066
RS
1137
1138 if (yyn == YYFINAL)
1139 YYACCEPT;
1140
7ea5e977 1141 YYDPRINTF ((stderr, "Shifting error token, "));
10fa2066 1142
17da6427 1143 *++yyvsp = yylval;
58612f1d 1144]b4_location_if([ *++yylsp = yylloc;])[
10fa2066
RS
1145
1146 yystate = yyn;
1147 goto yynewstate;
70ddf897 1148
71da9eea
AD
1149
1150/*-------------------------------------.
1151| yyacceptlab -- YYACCEPT comes here. |
1152`-------------------------------------*/
1153yyacceptlab:
600f9b0c
PE
1154 yyresult = 0;
1155 goto yyreturn;
71da9eea
AD
1156
1157/*-----------------------------------.
1158| yyabortlab -- YYABORT comes here. |
1159`-----------------------------------*/
1160yyabortlab:
600f9b0c
PE
1161 yyresult = 1;
1162 goto yyreturn;
1163
0bfb02ff 1164#ifndef yyoverflow
ca98bf57
AD
1165/*----------------------------------------------.
1166| yyoverflowlab -- parser overflow comes here. |
1167`----------------------------------------------*/
600f9b0c 1168yyoverflowlab:
93724f13 1169 yyerror (]b4_yyerror_args["parser stack overflow");
600f9b0c
PE
1170 yyresult = 2;
1171 /* Fall through. */
0bfb02ff 1172#endif
600f9b0c
PE
1173
1174yyreturn:
1175#ifndef yyoverflow
1176 if (yyss != yyssa)
1177 YYSTACK_FREE (yyss);
70ddf897 1178#endif
600f9b0c 1179 return yyresult;
be2a1a68
AD
1180]}
1181
24c0aad7 1182
be2a1a68
AD
1183b4_epilogue
1184m4_if(b4_defines_flag, 0, [],
947427ae 1185[@output @output_header_name@
c76e14da 1186b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
0252b55c
PE
1187 [1984, 1989, 1990, 2000, 2001, 2002])
1188
1189/* As a special exception, when this file is copied by Bison into a
1190 Bison output file, you may use that output file without restriction.
1191 This special exception was added by the Free Software Foundation
1192 in version 1.24 of Bison. */
c76e14da 1193
0d8bed56 1194b4_token_defines(b4_tokens)
be2a1a68 1195
050c471b 1196#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
e9955c83 1197m4_ifdef([b4_stype],
437c2d80 1198[b4_syncline([b4_stype_line], [b4_filename])
050c471b 1199typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
996b1c7e 1200/* Line __line__ of yacc.c. */
947427ae 1201b4_syncline([@oline@], [@ofile@])],
050c471b
PE
1202[typedef int YYSTYPE;])
1203# define yystype YYSTYPE /* obsolescent; will be withdrawn */
1204# define YYSTYPE_IS_DECLARED 1
947427ae 1205# define YYSTYPE_IS_TRIVIAL 1
be2a1a68
AD
1206#endif
1207
74310291 1208b4_pure_if([],
be2a1a68
AD
1209[extern YYSTYPE b4_prefix[]lval;])
1210
58612f1d 1211b4_location_if(
050c471b
PE
1212[#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
1213typedef struct YYLTYPE
be2a1a68
AD
1214{
1215 int first_line;
1216 int first_column;
1217 int last_line;
1218 int last_column;
050c471b
PE
1219} YYLTYPE;
1220# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1221# define YYLTYPE_IS_DECLARED 1
1222# define YYLTYPE_IS_TRIVIAL 1
be2a1a68 1223#endif
ff48177d 1224
be2a1a68
AD
1225m4_if(b4_pure, [0],
1226[extern YYLTYPE b4_prefix[]lloc;])
1227])
be2a1a68 1228])