1 |
#output "b4_output_prefix[]b4_output_infix[]-class.hh" |
#output "b4_output_prefix[]b4_output_infix[]-class.hh" |
2 |
/* -*- C++ -*- */ |
/* -*- C++ -*- */ |
3 |
|
|
4 |
/* A Bison parser, made from %%filename, |
/* A Bison parser, made from b4_filename, |
5 |
by GNU bison %%version. */ |
by GNU bison b4_version. */ |
6 |
|
|
7 |
/* Skeleton output parser for bison, |
/* Skeleton output parser for bison, |
8 |
Copyright 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc. |
Copyright 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc. |
32 |
|
|
33 |
b4_prologue |
b4_prologue |
34 |
|
|
35 |
|
/* Enabling traces. */ |
36 |
|
#ifndef YYDEBUG |
37 |
|
# define YYDEBUG b4_debug |
38 |
|
#endif |
39 |
|
|
40 |
|
/* Enabling verbose error message. */ |
41 |
|
#ifndef YYERROR_VERBOSE |
42 |
|
# define YYERROR_VERBOSE b4_error_verbose |
43 |
|
#endif |
44 |
|
|
45 |
|
/* Using locations. */ |
46 |
|
#define YYLSP_NEEDED b4_locations_flag |
47 |
|
|
48 |
// FIXME: This should be defined in traits, not here. |
// FIXME: This should be defined in traits, not here. |
49 |
typedef b4_stype yystype; |
typedef b4_stype yystype; |
50 |
|
|
82 |
|
|
83 |
b4_name (bool debug) : debug_ (debug) |
b4_name (bool debug) : debug_ (debug) |
84 |
{ |
{ |
|
looka = empty_; |
|
85 |
} |
} |
86 |
|
|
87 |
virtual ~b4_name () |
virtual ~b4_name () |
92 |
|
|
93 |
private: |
private: |
94 |
|
|
95 |
|
virtual void lex_ (); |
96 |
virtual void error_ (); |
virtual void error_ (); |
97 |
virtual void print_ (); |
virtual void print_ (); |
98 |
|
|
|
/* Call to lexical analyser. */ |
|
|
virtual |
|
|
void |
|
|
lex () |
|
|
{ |
|
|
looka = yylex (&value, &location); |
|
|
} |
|
|
|
|
99 |
/* Stacks. */ |
/* Stacks. */ |
100 |
StateStack state_stack; |
StateStack state_stack_; |
101 |
SemanticStack semantic_stack; |
SemanticStack semantic_stack_; |
102 |
LocationStack location_stack; |
LocationStack location_stack_; |
103 |
|
|
104 |
/* Tables. */ |
/* Tables. */ |
105 |
static const short pact_[[]]; |
static const short pact_[[]]; |
110 |
static const short check_[[]]; |
static const short check_[[]]; |
111 |
static const short r1_[[]]; |
static const short r1_[[]]; |
112 |
static const short r2_[[]]; |
static const short r2_[[]]; |
113 |
|
|
114 |
|
#if YYDEBUG || YYERROR_VERBOSE |
115 |
static const char* const name_[[]]; |
static const char* const name_[[]]; |
116 |
|
#endif |
117 |
|
|
118 |
/* More tables, for debugging. */ |
/* More tables, for debugging. */ |
119 |
/* FIXME: These tables should not be printed when not in debug |
#if YYDEBUG |
|
mode. %%ifdef? */ |
|
120 |
static const short rhs_[[]]; |
static const short rhs_[[]]; |
121 |
static const short prhs_[[]]; |
static const short prhs_[[]]; |
122 |
static const short rline_[[]]; |
static const short rline_[[]]; |
123 |
|
#endif |
124 |
|
|
125 |
/* Even more tables. */ |
/* Even more tables. */ |
126 |
static inline char translate (int token); |
static inline char translate_ (int token); |
127 |
|
|
128 |
/* Constants. */ |
/* Constants. */ |
129 |
static const int eof_; |
static const int eof_; |
130 |
|
static const int last_; |
131 |
|
static const int flag_; |
132 |
|
static const int nnts_; |
133 |
|
static const int nsym_; |
134 |
static const int empty_; |
static const int empty_; |
135 |
|
static const int final_; |
136 |
static const int terror_; |
static const int terror_; |
137 |
static const int errcode_; |
static const int errcode_; |
138 |
static const int ntokens_; |
static const int ntokens_; |
139 |
|
static const int initdepth_; |
140 |
|
static const unsigned maxtok_; |
141 |
|
|
142 |
/* State. */ |
/* State. */ |
143 |
int n; |
int n_; |
144 |
int len; |
int len_; |
145 |
int debug_; |
int debug_; |
146 |
int state; |
int state_; |
147 |
|
|
148 |
/* Lookahead. */ |
/* Lookahead and lookahead in internal form. */ |
149 |
int looka; |
int looka_; |
150 |
int ilooka; |
int ilooka_; |
151 |
|
|
152 |
/* Message. */ |
/* Message. */ |
153 |
std::string message; |
std::string message; |
161 |
#output "b4_output_prefix[]b4_output_infix[].cc" |
#output "b4_output_prefix[]b4_output_infix[].cc" |
162 |
#include "b4_output_prefix[]b4_output_infix-class.hh" |
#include "b4_output_prefix[]b4_output_infix-class.hh" |
163 |
|
|
|
/* Enabling traces. */ |
|
|
#ifndef YYDEBUG |
|
|
# define YYDEBUG b4_debug |
|
|
#endif |
|
|
|
|
164 |
/* Enable debugging if requested. */ |
/* Enable debugging if requested. */ |
165 |
#if YYDEBUG |
#if YYDEBUG |
|
|
|
166 |
# include <cstdio> |
# include <cstdio> |
167 |
# define YYFPRINTF std::fprintf |
# define YYFPRINTF std::fprintf |
|
|
|
168 |
# define YYDPRINTF(Args) \ |
# define YYDPRINTF(Args) \ |
169 |
do { \ |
do { \ |
170 |
if (debug_) \ |
if (debug_) \ |
171 |
YYFPRINTF Args; \ |
YYFPRINTF Args; \ |
172 |
} while (0) |
} while (0) |
|
/* Nonzero means print parse trace. [The following comment makes no |
|
|
sense to me. Could someone clarify it? --akim] Since this is |
|
|
uninitialized, it does not stop multiple parsers from coexisting. |
|
|
*/ |
|
|
int yydebug; |
|
173 |
#else /* !YYDEBUG */ |
#else /* !YYDEBUG */ |
174 |
# define YYDPRINTF(Args) |
# define YYDPRINTF(Args) |
175 |
#endif /* !YYDEBUG */ |
#endif /* !YYDEBUG */ |
184 |
int errstatus = 0; |
int errstatus = 0; |
185 |
|
|
186 |
/* Initialize stack. */ |
/* Initialize stack. */ |
187 |
state_stack = StateStack (0); |
state_stack_ = StateStack (0); |
188 |
semantic_stack = SemanticStack (1); |
semantic_stack_ = SemanticStack (1); |
189 |
location_stack = LocationStack (1); |
location_stack_ = LocationStack (1); |
190 |
|
|
191 |
/* Reserve initial space. The C parser needed that, but is it really |
/* Reserve initial space. The C parser needed that, but is it really |
192 |
useful here? */ |
useful here? */ |
193 |
state_stack.reserve (b4_initdepth); |
state_stack_.reserve (initdepth_); |
194 |
semantic_stack.reserve (b4_initdepth); |
semantic_stack_.reserve (initdepth_); |
195 |
location_stack.reserve (b4_initdepth); |
location_stack_.reserve (initdepth_); |
196 |
|
|
197 |
/* Start. */ |
/* Start. */ |
198 |
state = 0; |
state_ = 0; |
199 |
|
looka_ = empty_; |
200 |
YYDPRINTF ((stderr, "Starting parse\n")); |
YYDPRINTF ((stderr, "Starting parse\n")); |
201 |
|
|
202 |
/* New state. */ |
/* New state. */ |
203 |
yynewstate: |
yynewstate: |
204 |
state_stack.push (state); |
state_stack_.push (state_); |
205 |
YYDPRINTF ((stderr, "Entering state %d\n", state)); |
YYDPRINTF ((stderr, "Entering state %d\n", state_)); |
206 |
goto yybackup; |
goto yybackup; |
207 |
|
|
208 |
/* Backup. */ |
/* Backup. */ |
209 |
yybackup: |
yybackup: |
210 |
|
|
211 |
/* Try to take a decision without lookahead. */ |
/* Try to take a decision without lookahead. */ |
212 |
n = pact_[[state]]; |
n_ = pact_[[state_]]; |
213 |
if (n == b4_flag) |
if (n_ == flag_) |
214 |
goto yydefault; |
goto yydefault; |
215 |
|
|
216 |
/* Read a lookahead token. */ |
/* Read a lookahead token. */ |
217 |
if (looka == empty_) |
if (looka_ == empty_) |
218 |
{ |
{ |
219 |
YYDPRINTF ((stderr, "Reading a token: ")); |
YYDPRINTF ((stderr, "Reading a token: ")); |
220 |
lex (); |
lex_ (); |
221 |
} |
} |
222 |
|
|
223 |
/* Convert token to internal form. */ |
/* Convert token to internal form. */ |
224 |
if (looka <= 0) |
if (looka_ <= 0) |
225 |
{ |
{ |
226 |
looka = eof_; |
looka_ = eof_; |
227 |
ilooka = 0; |
ilooka_ = 0; |
228 |
YYDPRINTF ((stderr, "Now at end of input.\n")); |
YYDPRINTF ((stderr, "Now at end of input.\n")); |
229 |
} |
} |
230 |
else |
else |
231 |
{ |
{ |
232 |
ilooka = translate (looka); |
ilooka_ = translate_ (looka_); |
233 |
#if YYDEBUG |
#if YYDEBUG |
234 |
if (debug_) |
if (debug_) |
235 |
{ |
{ |
236 |
YYFPRINTF (stderr, "Next token is %d (%s", looka, name_[[ilooka]]); |
YYFPRINTF (stderr, "Next token is %d (%s", looka_, name_[[ilooka_]]); |
237 |
print_ (); |
print_ (); |
238 |
YYFPRINTF (stderr, ")\n"); |
YYFPRINTF (stderr, ")\n"); |
239 |
} |
} |
240 |
#endif |
#endif |
241 |
} |
} |
242 |
|
|
243 |
n += ilooka; |
n_ += ilooka_; |
244 |
if (n < 0 || n > b4_last || check_[[n]] != ilooka) |
if (n_ < 0 || n_ > last_ || check_[[n_]] != ilooka_) |
245 |
goto yydefault; |
goto yydefault; |
246 |
|
|
247 |
/* Reduce or error. */ |
/* Reduce or error. */ |
248 |
n = table_[[n]]; |
n_ = table_[[n_]]; |
249 |
if (n < 0) |
if (n_ < 0) |
250 |
{ |
{ |
251 |
if (n == b4_flag) |
if (n_ == flag_) |
252 |
goto yyerrlab; |
goto yyerrlab; |
253 |
else |
else |
254 |
{ |
{ |
255 |
n = -n; |
n_ = -n_; |
256 |
goto yyreduce; |
goto yyreduce; |
257 |
} |
} |
258 |
} |
} |
259 |
else if (n == 0) |
else if (n_ == 0) |
260 |
goto yyerrlab; |
goto yyerrlab; |
261 |
|
|
262 |
/* Accept? */ |
/* Accept? */ |
263 |
if (n == b4_final) |
if (n_ == final_) |
264 |
goto yyacceptlab; |
goto yyacceptlab; |
265 |
|
|
266 |
/* Shift the lookahead token. */ |
/* Shift the lookahead token. */ |
267 |
YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka, name_[[ilooka]])); |
YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka_, name_[[ilooka_]])); |
268 |
|
|
269 |
/* Discard the token being shifted unless it is eof. */ |
/* Discard the token being shifted unless it is eof. */ |
270 |
if (looka != eof_) |
if (looka_ != eof_) |
271 |
looka = empty_; |
looka_ = empty_; |
272 |
|
|
273 |
semantic_stack.push (value); |
semantic_stack_.push (value); |
274 |
location_stack.push (location); |
location_stack_.push (location); |
275 |
state = n; |
state_ = n_; |
276 |
goto yynewstate; |
goto yynewstate; |
277 |
|
|
278 |
/* Default action. */ |
/* Default action. */ |
279 |
yydefault: |
yydefault: |
280 |
n = defact_[[state]]; |
n_ = defact_[[state_]]; |
281 |
if (n == 0) |
if (n_ == 0) |
282 |
goto yyerrlab; |
goto yyerrlab; |
283 |
goto yyreduce; |
goto yyreduce; |
284 |
|
|
285 |
/* Reduce. */ |
/* Reduce. */ |
286 |
yyreduce: |
yyreduce: |
287 |
len = r2_[[n]]; |
len_ = r2_[[n_]]; |
288 |
if (len) |
if (len_) |
289 |
{ |
{ |
290 |
value = semantic_stack[[1 - len]]; |
value = semantic_stack_[[1 - len_]]; |
291 |
location = location_stack[[1 - len]]; |
location = location_stack_[[1 - len_]]; |
292 |
} |
} |
293 |
else |
else |
294 |
{ |
{ |
295 |
// FIXME: This is truly ugly. |
value = semantic_stack_[[0]]; |
296 |
value = semantic_stack[[0]]; |
location = location_stack_[[0]]; |
|
location = location_stack[[0]]; |
|
297 |
} |
} |
298 |
|
|
299 |
#if YYDEBUG |
#if YYDEBUG |
300 |
if (debug_) |
if (debug_) |
301 |
{ |
{ |
302 |
YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n - 1, rline_[[n]]); |
YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n_ - 1, rline_[[n_]]); |
303 |
for (unsigned i = prhs_[[n]]; |
for (unsigned i = prhs_[[n_]]; |
304 |
rhs_[[i]] >= 0; ++i) |
rhs_[[i]] >= 0; ++i) |
305 |
YYFPRINTF (stderr, "%s ", name_[[rhs_[i]]]); |
YYFPRINTF (stderr, "%s ", name_[[rhs_[i]]]); |
306 |
YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n]]]); |
YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n_]]]); |
307 |
} |
} |
308 |
#endif |
#endif |
309 |
|
|
310 |
{ |
{ |
311 |
SemanticType& yyval (value); |
SemanticType& yyval (value); |
312 |
LocationType& yyloc (location); |
LocationType& yyloc (location); |
313 |
SemanticStack& yyvsp (semantic_stack); |
SemanticStack& yyvsp (semantic_stack_); |
314 |
LocationStack& yylsp (location_stack); |
LocationStack& yylsp (location_stack_); |
315 |
|
|
316 |
switch (n) |
switch (n_) |
317 |
{ |
{ |
318 |
b4_actions |
b4_actions |
319 |
} |
} |
320 |
} |
} |
321 |
|
|
322 |
state_stack.pop (len); |
state_stack_.pop (len_); |
323 |
semantic_stack.pop (len); |
semantic_stack_.pop (len_); |
324 |
location_stack.pop (len); |
location_stack_.pop (len_); |
325 |
|
|
326 |
#if YYDEBUG |
#if YYDEBUG |
327 |
if (debug_) |
if (debug_) |
328 |
{ |
{ |
329 |
YYFPRINTF (stderr, "state stack now"); |
YYFPRINTF (stderr, "state stack now"); |
330 |
for (StateStack::ConstIterator i = state_stack.begin (); |
for (StateStack::ConstIterator i = state_stack_.begin (); |
331 |
i != state_stack.end (); ++i) |
i != state_stack_.end (); ++i) |
332 |
YYFPRINTF (stderr, " %d", *i); |
YYFPRINTF (stderr, " %d", *i); |
333 |
YYFPRINTF (stderr, "\n"); |
YYFPRINTF (stderr, "\n"); |
334 |
} |
} |
335 |
#endif |
#endif |
336 |
|
|
337 |
semantic_stack.push (value); |
semantic_stack_.push (value); |
338 |
location_stack.push (location); |
location_stack_.push (location); |
339 |
|
|
340 |
/* Shift the result of the reduction. */ |
/* Shift the result of the reduction. */ |
341 |
n = r1_[[n]]; |
n_ = r1_[[n_]]; |
342 |
state = pgoto_[[n - ntokens_]] + state_stack[[0]]; |
state_ = pgoto_[[n_ - ntokens_]] + state_stack_[[0]]; |
343 |
if (state >= 0 && state <= b4_last && check_[[state]] == state_stack[[0]]) |
if (state_ >= 0 && state_ <= last_ && check_[[state_]] == state_stack_[[0]]) |
344 |
state = table_[[state]]; |
state_ = table_[[state_]]; |
345 |
else |
else |
346 |
state = defgoto_[[n - ntokens_]]; |
state_ = defgoto_[[n_ - ntokens_]]; |
347 |
goto yynewstate; |
goto yynewstate; |
348 |
|
|
349 |
/* Report and recover from errors. This is very incomplete. */ |
/* Report and recover from errors. This is very incomplete. */ |
353 |
{ |
{ |
354 |
++nerrs; |
++nerrs; |
355 |
|
|
356 |
// FIXME: Should be #if YYERROR_VERBOSE from here... |
#if YYERROR_VERBOSE |
357 |
n = pact_[[state]]; |
n_ = pact_[[state_]]; |
358 |
if (n > b4_flag && n < b4_last) |
if (n_ > flag_ && n_ < last_) |
359 |
{ |
{ |
360 |
message = "parse error, unexpected "; |
message = "parse error, unexpected "; |
361 |
message += name_[[ilooka]]; |
message += name_[[ilooka_]]; |
362 |
{ |
{ |
363 |
int count = 0; |
int count = 0; |
364 |
for (int x = (n < 0 ? -n : 0); x < b4_ntokens + b4_nnts; ++x) |
for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x) |
365 |
if (check_[[x + n]] == x) |
if (check_[[x + n_]] == x) |
366 |
++count; |
++count; |
367 |
if (count < 5) |
if (count < 5) |
368 |
{ |
{ |
369 |
count = 0; |
count = 0; |
370 |
for (int x = (n < 0 ? -n : 0); x < b4_ntokens + b4_nnts; ++x) |
for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x) |
371 |
if (check_[[x + n]] == x) |
if (check_[[x + n_]] == x) |
372 |
{ |
{ |
373 |
message += (!count++) ? ", expecting " : " or "; |
message += (!count++) ? ", expecting " : " or "; |
374 |
message += name_[[x]]; |
message += name_[[x]]; |
377 |
} |
} |
378 |
} |
} |
379 |
else |
else |
380 |
// FIXME: to there... |
#endif |
381 |
message = "parse error"; |
message = "parse error"; |
382 |
} |
} |
383 |
error_ (); |
error_ (); |
391 |
error, discard it. */ |
error, discard it. */ |
392 |
|
|
393 |
/* Return failure if at end of input. */ |
/* Return failure if at end of input. */ |
394 |
if (looka == eof_) |
if (looka_ == eof_) |
395 |
goto yyabortlab; |
goto yyabortlab; |
396 |
YYDPRINTF ((stderr, "Discarding token %d (%s).\n", looka, name_[[ilooka]])); |
YYDPRINTF ((stderr, "Discarding token %d (%s).\n", looka_, name_[[ilooka_]])); |
397 |
looka = empty_; |
looka_ = empty_; |
398 |
} |
} |
399 |
|
|
400 |
/* Else will try to reuse lookahead token after shifting the error |
/* Else will try to reuse lookahead token after shifting the error |
406 |
/* Pop the current state because it cannot handle the error token. */ |
/* Pop the current state because it cannot handle the error token. */ |
407 |
yyerrdefault: |
yyerrdefault: |
408 |
yyerrpop: |
yyerrpop: |
409 |
if (!state_stack.height ()) |
if (!state_stack_.height ()) |
410 |
goto yyabortlab; |
goto yyabortlab; |
411 |
state = (state_stack.pop (), state_stack[[0]]); |
state_ = (state_stack_.pop (), state_stack_[[0]]); |
412 |
semantic_stack.pop (); |
semantic_stack_.pop (); |
413 |
location_stack.pop ();; |
location_stack_.pop ();; |
414 |
|
|
415 |
#if YYDEBUG |
#if YYDEBUG |
416 |
if (debug_) |
if (debug_) |
417 |
{ |
{ |
418 |
YYFPRINTF (stderr, "Error: state stack now"); |
YYFPRINTF (stderr, "Error: state stack now"); |
419 |
for (StateStack::ConstIterator i = state_stack.begin (); |
for (StateStack::ConstIterator i = state_stack_.begin (); |
420 |
i != state_stack.end (); ++i) |
i != state_stack_.end (); ++i) |
421 |
YYFPRINTF (stderr, " %d", *i); |
YYFPRINTF (stderr, " %d", *i); |
422 |
YYFPRINTF (stderr, "\n"); |
YYFPRINTF (stderr, "\n"); |
423 |
} |
} |
424 |
#endif |
#endif |
425 |
|
|
426 |
yyerrhandle: |
yyerrhandle: |
427 |
n = pact_[[state]]; |
n_ = pact_[[state_]]; |
428 |
if (n == b4_flag) |
if (n_ == flag_) |
429 |
goto yyerrdefault; |
goto yyerrdefault; |
430 |
|
|
431 |
n += terror_; |
n_ += terror_; |
432 |
if (n < 0 || n > b4_last || check_[[n]] != terror_) |
if (n_ < 0 || n_ > last_ || check_[[n_]] != terror_) |
433 |
goto yyerrdefault; |
goto yyerrdefault; |
434 |
|
|
435 |
n = table_[[n]]; |
n_ = table_[[n_]]; |
436 |
if (n < 0) |
if (n_ < 0) |
437 |
{ |
{ |
438 |
if (n == b4_flag) |
if (n_ == flag_) |
439 |
goto yyerrpop; |
goto yyerrpop; |
440 |
n = -n; |
n_ = -n_; |
441 |
goto yyreduce; |
goto yyreduce; |
442 |
} |
} |
443 |
else if (!n) |
else if (!n_) |
444 |
goto yyerrpop; |
goto yyerrpop; |
445 |
|
|
446 |
if (n == b4_final) |
if (n_ == final_) |
447 |
goto yyacceptlab; |
goto yyacceptlab; |
448 |
|
|
449 |
YYDPRINTF ((stderr, "Shifting error token, ")); |
YYDPRINTF ((stderr, "Shifting error token, ")); |
450 |
|
|
451 |
semantic_stack.push (value); |
semantic_stack_.push (value); |
452 |
location_stack.push (location); |
location_stack_.push (location); |
453 |
|
|
454 |
state = n; |
state_ = n_; |
455 |
goto yynewstate; |
goto yynewstate; |
456 |
|
|
457 |
/* Accept. */ |
/* Accept. */ |
463 |
return 1; |
return 1; |
464 |
} |
} |
465 |
|
|
466 |
|
void |
467 |
|
yy::b4_name::lex_ () |
468 |
|
{ |
469 |
|
#if YYLSP_NEEDED |
470 |
|
looka_ = yylex (&value, &location); |
471 |
|
#else |
472 |
|
looka_ = yylex (&value); |
473 |
|
#endif |
474 |
|
} |
475 |
|
|
476 |
/* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing |
/* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing |
477 |
STATE-NUM. */ |
STATE-NUM. */ |
478 |
const short |
const short |
479 |
yy::b4_name::pact_[[]] = |
yy::b4_name::pact_[[]] = |
480 |
{ |
{ |
481 |
b4_pact |
b4_pact |
484 |
/* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE |
/* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE |
485 |
doesn't specify something else to do. Zero means the default is an |
doesn't specify something else to do. Zero means the default is an |
486 |
error. */ |
error. */ |
487 |
const short |
const short |
488 |
yy::b4_name::defact_[[]] = |
yy::b4_name::defact_[[]] = |
489 |
{ |
{ |
490 |
b4_defact |
b4_defact |
491 |
}; |
}; |
492 |
|
|
493 |
/* YYPGOTO[[NTERM-NUM]]. */ |
/* YYPGOTO[[NTERM-NUM]]. */ |
494 |
const short |
const short |
495 |
yy::b4_name::pgoto_[[]] = |
yy::b4_name::pgoto_[[]] = |
496 |
{ |
{ |
497 |
b4_pgoto |
b4_pgoto |
498 |
}; |
}; |
499 |
|
|
500 |
/* YYDEFGOTO[[NTERM-NUM]]. */ |
/* YYDEFGOTO[[NTERM-NUM]]. */ |
501 |
const short |
const short |
502 |
yy::b4_name::defgoto_[[]] = |
yy::b4_name::defgoto_[[]] = |
503 |
{ |
{ |
504 |
b4_defgoto |
b4_defgoto |
507 |
/* YYTABLE[[YYPACT[STATE-NUM]]]. What to do in state STATE-NUM. If |
/* YYTABLE[[YYPACT[STATE-NUM]]]. What to do in state STATE-NUM. If |
508 |
positive, shift that token. If negative, reduce the rule which |
positive, shift that token. If negative, reduce the rule which |
509 |
number is the opposite. If zero, do what YYDEFACT says. */ |
number is the opposite. If zero, do what YYDEFACT says. */ |
510 |
const short |
const short |
511 |
yy::b4_name::table_[[]] = |
yy::b4_name::table_[[]] = |
512 |
{ |
{ |
513 |
b4_table |
b4_table |
514 |
}; |
}; |
515 |
|
|
516 |
/* YYCHECK. */ |
/* YYCHECK. */ |
517 |
const short |
const short |
518 |
yy::b4_name::check_[[]] = |
yy::b4_name::check_[[]] = |
519 |
{ |
{ |
520 |
b4_check |
b4_check |
521 |
}; |
}; |
522 |
|
|
|
/* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */ |
|
|
const short |
|
|
yy::b4_name::rline_[[]] = |
|
|
{ |
|
|
b4_rline |
|
|
}; |
|
|
|
|
523 |
/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */ |
/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */ |
524 |
const short |
const short |
525 |
yy::b4_name::r1_[[]] = |
yy::b4_name::r1_[[]] = |
534 |
b4_r2 |
b4_r2 |
535 |
}; |
}; |
536 |
|
|
537 |
|
#if YYDEBUG || YYERROR_VERBOSE |
538 |
/* YYTNAME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM. |
/* YYTNAME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM. |
539 |
First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
540 |
const char* |
const char* |
542 |
{ |
{ |
543 |
b4_tname |
b4_tname |
544 |
}; |
}; |
545 |
|
#endif |
546 |
|
|
547 |
|
#if YYDEBUG |
548 |
/* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
/* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
549 |
const short |
const short |
550 |
yy::b4_name::rhs_[[]] = |
yy::b4_name::rhs_[[]] = |
554 |
|
|
555 |
/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in |
/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in |
556 |
YYRHS. */ |
YYRHS. */ |
557 |
const short |
const short |
558 |
yy::b4_name::prhs_[[]] = |
yy::b4_name::prhs_[[]] = |
559 |
{ |
{ |
560 |
b4_prhs |
b4_prhs |
561 |
}; |
}; |
562 |
|
|
563 |
|
/* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */ |
564 |
|
const short |
565 |
|
yy::b4_name::rline_[[]] = |
566 |
|
{ |
567 |
|
b4_rline |
568 |
|
}; |
569 |
|
#endif |
570 |
|
|
571 |
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
572 |
char |
char |
573 |
yy::b4_name::translate (int token) |
yy::b4_name::translate_ (int token) |
574 |
{ |
{ |
575 |
static |
static |
576 |
const char |
const char |
578 |
{ |
{ |
579 |
b4_translate |
b4_translate |
580 |
}; |
}; |
581 |
return ((unsigned)(token) <= b4_maxtok ? translate_[[token]] : b4_nsym); |
return ((unsigned)(token) <= maxtok_ ? translate_[[token]] : nsym_); |
582 |
} |
} |
583 |
|
|
584 |
const int yy::b4_name::eof_ = 0; |
const int yy::b4_name::eof_ = 0; |
585 |
|
const int yy::b4_name::last_ = b4_last; |
586 |
|
const int yy::b4_name::flag_ = b4_flag; |
587 |
|
const int yy::b4_name::nnts_ = b4_nnts; |
588 |
|
const int yy::b4_name::nsym_ = b4_nsym; |
589 |
const int yy::b4_name::empty_ = -2; |
const int yy::b4_name::empty_ = -2; |
590 |
|
const int yy::b4_name::final_ = b4_final; |
591 |
const int yy::b4_name::terror_ = 1; |
const int yy::b4_name::terror_ = 1; |
592 |
const int yy::b4_name::errcode_ = 256; |
const int yy::b4_name::errcode_ = 256; |
593 |
const int yy::b4_name::ntokens_ = b4_ntokens; |
const int yy::b4_name::ntokens_ = b4_ntokens; |
594 |
|
const int yy::b4_name::initdepth_ = b4_initdepth; |
595 |
|
|
596 |
|
const unsigned yy::b4_name::maxtok_ = b4_maxtok; |
597 |
|
|
598 |
b4_epilogue |
b4_epilogue |
599 |
|
|