]>
Commit | Line | Data |
---|---|---|
007a50a4 | 1 | m4_divert(-1) -*- C -*- |
fb8135fa | 2 | m4_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. | |
30 | m4_define_default([b4_stack_depth_max], [10000]) | |
31 | m4_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. | |
42 | m4_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 |
51 | m4_define([b4_yyerror_args], |
52 | [b4_Pure_if([b4_location_if([&yylloc, ])])dnl | |
53 | m4_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 |
60 | m4_define([b4_lex_param], |
61 | m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl | |
62 | b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl | |
63 | m4_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 |
76 | m4_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>$. | |
96 | m4_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. | |
104 | m4_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 @$. | |
116 | m4_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. | |
124 | m4_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. |
134 | m4_changecom() | |
be2a1a68 | 135 | m4_divert(0)dnl |
947427ae | 136 | @output @output_parser_name@ |
fb8135fa | 137 | b4_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 |
156 | m4_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 | 166 | b4_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 | 189 | typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; |
996b1c7e | 190 | /* Line __line__ of yacc.c. */ |
947427ae | 191 | b4_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) |
199 | typedef 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 | 216 | b4_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. */ |
255 | union 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. */ |
340 | static 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 | 348 | static 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 | 354 | static 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. */ |
360 | static 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 | 369 | static 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 | 378 | static 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. */ |
385 | static 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. */ |
391 | static 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 | 399 | static const ]b4_int_type_for([b4_defact])[ yydefact[] = |
a8289c62 | 400 | { |
c5e3e510 | 401 | ]b4_defact[ |
a8289c62 RA |
402 | }; |
403 | ||
c5e3e510 AD |
404 | /* YYDEFGOTO[NTERM-NUM]. */ |
405 | static 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[ |
413 | static const ]b4_int_type_for([b4_pact])[ yypact[] = | |
a8289c62 | 414 | { |
c5e3e510 | 415 | ]b4_pact[ |
a8289c62 RA |
416 | }; |
417 | ||
c5e3e510 AD |
418 | /* YYPGOTO[NTERM-NUM]. */ |
419 | static 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[ |
429 | static const ]b4_int_type_for([b4_table])[ yytable[] = | |
a8289c62 | 430 | { |
c5e3e510 | 431 | ]b4_table[ |
a8289c62 RA |
432 | }; |
433 | ||
c5e3e510 | 434 | static 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 | 441 | static 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 | 480 | do \ |
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 |
494 | while (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) \ |
527 | do { \ | |
17da6427 | 528 | if (yydebug) \ |
b7575ffe | 529 | YYFPRINTF Args; \ |
5a35a6cb | 530 | } while (0) |
c5e3e510 | 531 | |
253862fd AD |
532 | # define YYDSYMPRINT(Args) \ |
533 | do { \ | |
534 | if (yydebug) \ | |
535 | yysymprint Args; \ | |
536 | } while (0) | |
c5e3e510 | 537 | |
9c1e26bd AD |
538 | # define YYDSYMPRINTF(Title, Token, Value, Location) \ |
539 | do { \ | |
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) \ | |
565 | do { \ | |
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) \ | |
589 | do { \ | |
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 | 596 | int 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. */ | |
635 | static YYSIZE_T | |
636 | # if defined (__STDC__) || defined (__cplusplus) | |
637 | yystrlen (const char *yystr) | |
638 | # else | |
639 | yystrlen (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. */ | |
659 | static char * | |
f11966ff PE |
660 | # if defined (__STDC__) || defined (__cplusplus) |
661 | yystpcpy (char *yydest, const char *yysrc) | |
662 | # else | |
7093d0f5 AD |
663 | yystpcpy (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 | 693 | int yyparse (void *YYPARSE_PARAM); |
4a2a22f4 | 694 | # else |
0245f82d | 695 | int yyparse (); |
4a2a22f4 | 696 | # endif |
0245f82d AD |
697 | #else /* ! YYPARSE_PARAM */ |
698 | b4_c_function_decl([yyparse], [int], b4_parse_param) | |
c5e3e510 | 699 | #endif /* ! YYPARSE_PARAM */ |
1b181651 | 700 | |
0245f82d | 701 | |
74310291 AD |
702 | m4_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 |
707 | m4_define([b4_declare_parser_variables], |
708 | [/* The lookahead symbol. */ | |
709 | int yychar; | |
710 | ||
711 | /* The semantic value of the lookahead symbol. */ | |
712 | YYSTYPE yylval; | |
713 | ||
6e649e65 | 714 | /* Number of syntax errors so far. */ |
74310291 AD |
715 | int yynerrs;b4_location_if([ |
716 | /* Location data for the lookahead symbol. */ | |
58612f1d | 717 | YYLTYPE yylloc;]) |
74310291 AD |
718 | ]) |
719 | m4_divert_pop([KILL])dnl# ====================== End of M4 code. | |
58612f1d | 720 | |
74310291 AD |
721 | b4_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) | |
731 | int yyparse (void *YYPARSE_PARAM) | |
732 | # else | |
733 | int yyparse (YYPARSE_PARAM) | |
734 | void *YYPARSE_PARAM; | |
735 | # endif | |
736 | #else /* ! YYPARSE_PARAM */ | |
737 | b4_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 | `-----------*/ | |
887 | yybackup: | |
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 | `-----------------------------------------------------------*/ | |
958 | yydefault: | |
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 | 968 | yyreduce: |
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 | 992 | b4_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 | `------------------------------------*/ | |
1021 | yyerrlab: | |
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 | `----------------------------------------------------*/ | |
1109 | yyerrlab1: | |
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 | `-------------------------------------*/ | |
1153 | yyacceptlab: | |
600f9b0c PE |
1154 | yyresult = 0; |
1155 | goto yyreturn; | |
71da9eea AD |
1156 | |
1157 | /*-----------------------------------. | |
1158 | | yyabortlab -- YYABORT comes here. | | |
1159 | `-----------------------------------*/ | |
1160 | yyabortlab: | |
600f9b0c PE |
1161 | yyresult = 1; |
1162 | goto yyreturn; | |
1163 | ||
0bfb02ff | 1164 | #ifndef yyoverflow |
ca98bf57 AD |
1165 | /*----------------------------------------------. |
1166 | | yyoverflowlab -- parser overflow comes here. | | |
1167 | `----------------------------------------------*/ | |
600f9b0c | 1168 | yyoverflowlab: |
93724f13 | 1169 | yyerror (]b4_yyerror_args["parser stack overflow"); |
600f9b0c PE |
1170 | yyresult = 2; |
1171 | /* Fall through. */ | |
0bfb02ff | 1172 | #endif |
600f9b0c PE |
1173 | |
1174 | yyreturn: | |
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 |
1183 | b4_epilogue |
1184 | m4_if(b4_defines_flag, 0, [], | |
947427ae | 1185 | [@output @output_header_name@ |
c76e14da | 1186 | b4_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 | 1194 | b4_token_defines(b4_tokens) |
be2a1a68 | 1195 | |
050c471b | 1196 | #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) |
e9955c83 | 1197 | m4_ifdef([b4_stype], |
437c2d80 | 1198 | [b4_syncline([b4_stype_line], [b4_filename]) |
050c471b | 1199 | typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; |
996b1c7e | 1200 | /* Line __line__ of yacc.c. */ |
947427ae | 1201 | b4_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 | 1208 | b4_pure_if([], |
be2a1a68 AD |
1209 | [extern YYSTYPE b4_prefix[]lval;]) |
1210 | ||
58612f1d | 1211 | b4_location_if( |
050c471b PE |
1212 | [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) |
1213 | typedef 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 |
1225 | m4_if(b4_pure, [0], |
1226 | [extern YYLTYPE b4_prefix[]lloc;]) | |
1227 | ]) | |
be2a1a68 | 1228 | ]) |