]>
Commit | Line | Data |
---|---|---|
007a50a4 | 1 | m4_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. | |
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 | # ------------ | |
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 |
60 | m4_define([b4_lex_param], |
61 | m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl | |
68cdf747 PE |
62 | b4_location_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])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 | ||
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>$. | |
96 | m4_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. | |
104 | m4_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 @$. | |
116 | m4_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. | |
124 | m4_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. |
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], |
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 | 156 | m4_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 | 165 | b4_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 | 188 | typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; |
996b1c7e | 189 | /* Line __line__ of yacc.c. */ |
947427ae | 190 | b4_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) |
198 | typedef 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 | 215 | b4_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. */ |
266 | union 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. */ |
351 | static 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 | 359 | static 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 | 365 | static 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. */ |
371 | static 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 | 380 | static 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 | 394 | static 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. */ |
401 | static 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. */ |
407 | static 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 | 415 | static const ]b4_int_type_for([b4_defact])[ yydefact[] = |
a8289c62 | 416 | { |
c5e3e510 | 417 | ]b4_defact[ |
a8289c62 RA |
418 | }; |
419 | ||
c5e3e510 AD |
420 | /* YYDEFGOTO[NTERM-NUM]. */ |
421 | static 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[ |
429 | static const ]b4_int_type_for([b4_pact])[ yypact[] = | |
a8289c62 | 430 | { |
c5e3e510 | 431 | ]b4_pact[ |
a8289c62 RA |
432 | }; |
433 | ||
c5e3e510 AD |
434 | /* YYPGOTO[NTERM-NUM]. */ |
435 | static 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[ |
445 | static const ]b4_int_type_for([b4_table])[ yytable[] = | |
a8289c62 | 446 | { |
c5e3e510 | 447 | ]b4_table[ |
a8289c62 RA |
448 | }; |
449 | ||
c5e3e510 | 450 | static 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 | 457 | static 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 | 497 | do \ |
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 |
511 | while (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) \ |
577 | do { \ | |
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 |
583 | do { \ |
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) \ | |
609 | do { \ | |
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) \ | |
633 | do { \ | |
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 | 640 | int 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. */ | |
674 | static YYSIZE_T | |
675 | # if defined (__STDC__) || defined (__cplusplus) | |
676 | yystrlen (const char *yystr) | |
677 | # else | |
678 | yystrlen (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. */ | |
698 | static char * | |
f11966ff PE |
699 | # if defined (__STDC__) || defined (__cplusplus) |
700 | yystpcpy (char *yydest, const char *yysrc) | |
701 | # else | |
7093d0f5 AD |
702 | yystpcpy (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 | 732 | int yyparse (void *YYPARSE_PARAM); |
4a2a22f4 | 733 | # else |
0245f82d | 734 | int yyparse (); |
4a2a22f4 | 735 | # endif |
0245f82d AD |
736 | #else /* ! YYPARSE_PARAM */ |
737 | b4_c_function_decl([yyparse], [int], b4_parse_param) | |
c5e3e510 | 738 | #endif /* ! YYPARSE_PARAM */ |
1b181651 | 739 | |
0245f82d | 740 | |
74310291 AD |
741 | m4_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 | 746 | m4_define([b4_declare_parser_variables], |
8dd162d3 | 747 | [/* The look-ahead symbol. */ |
74310291 AD |
748 | int yychar; |
749 | ||
8dd162d3 | 750 | /* The semantic value of the look-ahead symbol. */ |
74310291 AD |
751 | YYSTYPE yylval; |
752 | ||
6e649e65 | 753 | /* Number of syntax errors so far. */ |
74310291 | 754 | int yynerrs;b4_location_if([ |
8dd162d3 | 755 | /* Location data for the look-ahead symbol. */ |
58612f1d | 756 | YYLTYPE yylloc;]) |
74310291 AD |
757 | ]) |
758 | m4_divert_pop([KILL])dnl# ====================== End of M4 code. | |
58612f1d | 759 | |
74310291 AD |
760 | b4_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) | |
770 | int yyparse (void *YYPARSE_PARAM) | |
771 | # else | |
772 | int yyparse (YYPARSE_PARAM) | |
773 | void *YYPARSE_PARAM; | |
774 | # endif | |
775 | #else /* ! YYPARSE_PARAM */ | |
776 | b4_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 | ]]) | |
848 | m4_ifdef([b4_initial_action], [ | |
0092f063 AD |
849 | m4_pushdef([b4_at_dollar], [yylloc])dnl |
850 | m4_pushdef([b4_dollar_dollar], [yylval])dnl | |
cd3684cf | 851 | /* User initialization code. */ |
baf073c6 | 852 | b4_initial_action |
cd3684cf AD |
853 | m4_popdef([b4_dollar_dollar])dnl |
854 | m4_popdef([b4_at_dollar])dnl | |
855 | /* Line __line__ of yacc.c. */ | |
856 | b4_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 | `-----------*/ | |
947 | yybackup: | |
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 | `-----------------------------------------------------------*/ | |
1018 | yydefault: | |
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 | 1028 | yyreduce: |
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 | 1053 | b4_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 | `------------------------------------*/ | |
1082 | yyerrlab: | |
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 | `---------------------------------------------------*/ | |
1227 | yyerrorlab: | |
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 | 1246 | yyerrlab1: |
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 | `-------------------------------------*/ | |
1295 | yyacceptlab: | |
600f9b0c PE |
1296 | yyresult = 0; |
1297 | goto yyreturn; | |
71da9eea AD |
1298 | |
1299 | /*-----------------------------------. | |
1300 | | yyabortlab -- YYABORT comes here. | | |
1301 | `-----------------------------------*/ | |
1302 | yyabortlab: | |
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 | 1313 | yyoverflowlab: |
1ce59070 | 1314 | yyerror (]b4_yyerror_args[_("parser stack overflow")); |
600f9b0c PE |
1315 | yyresult = 2; |
1316 | /* Fall through. */ | |
0bfb02ff | 1317 | #endif |
600f9b0c PE |
1318 | |
1319 | yyreturn: | |
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 |
1328 | b4_epilogue |
1329 | m4_if(b4_defines_flag, 0, [], | |
947427ae | 1330 | [@output @output_header_name@ |
c76e14da | 1331 | b4_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 | 1339 | b4_token_defines(b4_tokens) |
be2a1a68 | 1340 | |
050c471b | 1341 | #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) |
e9955c83 | 1342 | m4_ifdef([b4_stype], |
437c2d80 | 1343 | [b4_syncline([b4_stype_line], [b4_filename]) |
050c471b | 1344 | typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; |
996b1c7e | 1345 | /* Line __line__ of yacc.c. */ |
947427ae | 1346 | b4_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 | 1353 | b4_pure_if([], |
be2a1a68 AD |
1354 | [extern YYSTYPE b4_prefix[]lval;]) |
1355 | ||
58612f1d | 1356 | b4_location_if( |
050c471b PE |
1357 | [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) |
1358 | typedef 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 |
1370 | m4_if(b4_pure, [0], |
1371 | [extern YYLTYPE b4_prefix[]lloc;]) | |
1372 | ]) | |
be2a1a68 | 1373 | ]) |