]> git.saurik.com Git - bison.git/blob - data/lalr1.cc
* bootstrap (gnulib_modules): Add strverscmp.
[bison.git] / data / lalr1.cc
1 m4_divert(-1)
2
3 # C++ skeleton for Bison
4
5 # Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
6
7 # This program is free software; you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation; either version 2 of the License, or
10 # (at your option) any later version.
11
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
16
17 # You should have received a copy of the GNU General Public License
18 # along with this program; if not, write to the Free Software
19 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 # 02110-1301 USA
21
22 m4_include(b4_pkgdatadir/[c++.m4])
23 m4_include(b4_pkgdatadir/[location.cc])
24
25 # We do want M4 expansion after # for CPP macros.
26 m4_changecom()
27 m4_divert(0)dnl
28 m4_if(b4_defines_flag, 0, [],
29 [@output @output_header_name@
30 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
31 [2002, 2003, 2004, 2005])
32 dnl FIXME: This is wrong, we want computed header guards.
33 dnl FIXME: I don\'t know why the macros are missing now. :(
34 [
35 #ifndef PARSER_HEADER_H
36 # define PARSER_HEADER_H
37
38 #include <string>
39 #include <iostream>
40 #include "stack.hh"
41
42 namespace yy
43 {
44 class position;
45 class location;
46 }
47
48 /* First part of user declarations. */
49 ]b4_pre_prologue[
50
51 ]/* Line __line__ of lalr1.cc. */
52 b4_syncline([@oline@], [@ofile@])[
53
54 ]dnl Include location.hh here: it might depend on headers included above.
55 [#include "location.hh"
56
57 /* Enabling traces. */
58 #ifndef YYDEBUG
59 # define YYDEBUG ]b4_debug[
60 #endif
61
62 /* Enabling verbose error messages. */
63 #ifdef YYERROR_VERBOSE
64 # undef YYERROR_VERBOSE
65 # define YYERROR_VERBOSE 1
66 #else
67 # define YYERROR_VERBOSE ]b4_error_verbose[
68 #endif
69
70 /* Enabling the token table. */
71 #ifndef YYTOKEN_TABLE
72 # define YYTOKEN_TABLE ]b4_token_table[
73 #endif
74
75 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
76 If N is 0, then set CURRENT to the empty location which ends
77 the previous symbol: RHS[0] (always defined). */
78
79 #ifndef YYLLOC_DEFAULT
80 # define YYLLOC_DEFAULT(Current, Rhs, N) \
81 do { \
82 if (N) \
83 { \
84 (Current).begin = (Rhs)[1].begin; \
85 (Current).end = (Rhs)[N].end; \
86 } \
87 else \
88 { \
89 (Current).begin = (Current).end = (Rhs)[0].end; \
90 } \
91 } while (0)
92 #endif
93
94 namespace yy
95 {
96
97 /// A Bison parser.
98 class ]b4_parser_class_name[
99 {
100 public:
101 /// Symbol semantic values.
102 #if ! defined (YYSTYPE)
103 ]m4_ifdef([b4_stype],
104 [b4_syncline([b4_stype_line], [b4_file_name])
105 union semantic_type b4_stype;
106 /* Line __line__ of lalr1.cc. */
107 b4_syncline([@oline@], [@ofile@])],
108 [ typedef int semantic_type;])[
109 #else
110 typedef YYSTYPE semantic_type;
111 #endif
112 /// Symbol locations.
113 typedef ]b4_location_type[ location_type;
114 /// Tokens.
115 struct token
116 {
117 ]b4_token_enums(b4_tokens)[
118 };
119
120 /// Build a parser object.
121 ]b4_parser_class_name[ (]b4_parse_param_decl[) :
122 yydebug_ (false),
123 yycdebug_ (&std::cerr)]b4_parse_param_cons[
124 {
125 }
126
127 virtual ~]b4_parser_class_name[ ()
128 {
129 }
130
131 /// Parse.
132 /// \returns 0 iff parsing succeeded.
133 virtual int parse ();
134
135 /// The current debugging stream.
136 std::ostream& debug_stream () const;
137 /// Set the current debugging stream.
138 void set_debug_stream (std::ostream &);
139
140 /// Type for debugging levels.
141 typedef int debug_level_type;
142 /// The current debugging level.
143 debug_level_type debug_level () const;
144 /// Set the current debugging level.
145 void set_debug_level (debug_level_type l);
146
147 private:
148 /// Report a syntax error.
149 /// \param loc where the syntax error is found.
150 /// \param msg a description of the syntax error.
151 virtual void error (const location_type& loc, const std::string& msg);
152
153 /// Generate an error message.
154 /// \param state the state where the error occurred.
155 /// \param tok the look-ahead token.
156 virtual std::string yysyntax_error_ (int yystate]dnl
157 b4_error_verbose_if([, int tok])[);
158
159 #if YYDEBUG
160 /// \brief Report a symbol on the debug stream.
161 /// \param yytype The token type.
162 /// \param yyvaluep Its semantic value.
163 /// \param yylocationp Its location.
164 virtual void yysymprint_ (int yytype,
165 const semantic_type* yyvaluep,
166 const location_type* yylocationp);
167 #endif /* ! YYDEBUG */
168
169
170 /// State numbers.
171 typedef int state_type;
172 /// State stack type.
173 typedef stack<state_type> state_stack_type;
174 /// Semantic value stack type.
175 typedef stack<semantic_type> semantic_stack_type;
176 /// location stack type.
177 typedef stack<location_type> location_stack_type;
178
179 /// The state stack.
180 state_stack_type yystate_stack_;
181 /// The semantic value stack.
182 semantic_stack_type yysemantic_stack_;
183 /// The location stack.
184 location_stack_type yylocation_stack_;
185
186 /// Internal symbol numbers.
187 typedef ]b4_int_type_for([b4_translate])[ token_number_type;
188 /* Tables. */
189 /// For a state, the index in \a yytable_ of its portion.
190 static const ]b4_int_type_for([b4_pact])[ yypact_[];
191 static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
192
193 /// For a state, default rule to reduce.
194 /// Unless\a yytable_ specifies something else to do.
195 /// Zero means the default is an error.
196 static const ]b4_int_type_for([b4_defact])[ yydefact_[];
197
198 static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
199 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
200
201 /// What to do in a state.
202 /// \a yytable_[yypact_[s]]: what to do in state \a s.
203 /// - if positive, shift that token.
204 /// - if negative, reduce the rule which number is the opposite.
205 /// - if zero, do what YYDEFACT says.
206 static const ]b4_int_type_for([b4_table])[ yytable_[];
207 static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
208
209 static const ]b4_int_type_for([b4_check])[ yycheck_[];
210
211 /// For a state, its accessing symbol.
212 static const ]b4_int_type_for([b4_stos])[ yystos_[];
213
214 /// For a rule, its LHS.
215 static const ]b4_int_type_for([b4_r1])[ yyr1_[];
216 /// For a rule, its RHS length.
217 static const ]b4_int_type_for([b4_r2])[ yyr2_[];
218
219 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
220 /// For a symbol, its name in clear.
221 static const char* const yytname_[];
222 #endif
223
224 #if YYERROR_VERBOSE
225 /// Convert the symbol name \a n to a form suitable for a diagnostic.
226 virtual std::string yytnamerr_ (const char *n);
227 #endif
228
229 #if YYDEBUG
230 /// A type to store symbol numbers and -1.
231 typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type;
232 /// A `-1'-separated list of the rules' RHS.
233 static const rhs_number_type yyrhs_[];
234 /// For each rule, the index of the first RHS symbol in \a yyrhs_.
235 static const ]b4_int_type_for([b4_prhs])[ yyprhs_[];
236 /// For each rule, its source line number.
237 static const ]b4_int_type_for([b4_rline])[ yyrline_[];
238 /// For each scanner token number, its symbol number.
239 static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[];
240 /// Report on the debug stream that the rule \a r is going to be reduced.
241 virtual void yyreduce_print_ (int r);
242 /// Print the state stack on the debug stream.
243 virtual void yystack_print_ ();
244 #endif
245
246 /// Convert a scanner token number to a symbol number.
247 inline token_number_type yytranslate_ (int token);
248
249 /// \brief Reclaim the memory associated to a symbol.
250 /// \param yymsg Why this token is reclaimed.
251 /// \param yytype The symbol type.
252 /// \param yyvaluep Its semantic value.
253 /// \param yylocationp Its location.
254 inline void yydestruct_ (const char* yymsg,
255 int yytype,
256 semantic_type* yyvaluep,
257 location_type* yylocationp);
258
259 /// Pop \a n symbols the three stacks.
260 inline void yypop_ (unsigned int n = 1);
261
262 /* Constants. */
263 static const int yyeof_;
264 /* LAST_ -- Last index in TABLE_. */
265 static const int yylast_;
266 static const int yynnts_;
267 static const int yyempty_;
268 static const int yyfinal_;
269 static const int yyterror_;
270 static const int yyerrcode_;
271 static const int yyntokens_;
272 static const unsigned int yyuser_token_number_max_;
273 static const token_number_type yyundef_token_;
274
275 /* Debugging. */
276 int yydebug_;
277 std::ostream* yycdebug_;
278
279 ]b4_parse_param_vars[
280 };
281 }
282
283 ]m4_ifset([b4_global_tokens_and_yystype],
284 [b4_token_defines(b4_tokens)
285
286 #ifndef YYSTYPE
287 /* Redirection for backward compatibility. */
288 # define YYSTYPE yy::b4_parser_class_name::semantic_type
289 #endif
290 ])[
291 #endif /* ! defined PARSER_HEADER_H */]
292 ])dnl
293 @output @output_parser_name@
294 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
295 [2002, 2003, 2004, 2005])
296 m4_if(b4_prefix[], [yy], [],
297 [
298 // Take the name prefix into account.
299 #define yylex b4_prefix[]lex])
300 m4_if(b4_defines_flag, 0, [],
301 [
302 #include @output_header_name@])[
303
304 /* User implementation prologue. */
305 ]b4_post_prologue[
306
307 ]/* Line __line__ of lalr1.cc. */
308 b4_syncline([@oline@], [@ofile@])[
309
310 #ifndef YY_
311 # if YYENABLE_NLS
312 # if ENABLE_NLS
313 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
314 # define YY_(msgid) dgettext ("bison-runtime", msgid)
315 # endif
316 # endif
317 # ifndef YY_
318 # define YY_(msgid) msgid
319 # endif
320 #endif
321
322 /* A pseudo ostream that takes yydebug_ into account. */
323 # define YYCDEBUG \
324 for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false) \
325 (*yycdebug_)
326
327 /* Enable debugging if requested. */
328 #if YYDEBUG
329
330 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
331 do { \
332 if (yydebug_) \
333 { \
334 *yycdebug_ << (Title) << ' '; \
335 yysymprint_ ((Type), (Value), (Location)); \
336 *yycdebug_ << std::endl; \
337 } \
338 } while (0)
339
340 # define YY_REDUCE_PRINT(Rule) \
341 do { \
342 if (yydebug_) \
343 yyreduce_print_ (Rule); \
344 } while (0)
345
346 # define YY_STACK_PRINT() \
347 do { \
348 if (yydebug_) \
349 yystack_print_ (); \
350 } while (0)
351
352 #else /* !YYDEBUG */
353
354 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
355 # define YY_REDUCE_PRINT(Rule)
356 # define YY_STACK_PRINT()
357
358 #endif /* !YYDEBUG */
359
360 #define YYACCEPT goto yyacceptlab
361 #define YYABORT goto yyabortlab
362 #define YYERROR goto yyerrorlab
363
364 #if YYERROR_VERBOSE
365
366 /* Return YYSTR after stripping away unnecessary quotes and
367 backslashes, so that it's suitable for yyerror. The heuristic is
368 that double-quoting is unnecessary unless the string contains an
369 apostrophe, a comma, or backslash (other than backslash-backslash).
370 YYSTR is taken from yytname. */
371 std::string
372 yy::]b4_parser_class_name[::yytnamerr_ (const char *yystr)
373 {
374 if (*yystr == '"')
375 {
376 std::string yyr = "";
377 char const *yyp = yystr;
378
379 for (;;)
380 switch (*++yyp)
381 {
382 case '\'':
383 case ',':
384 goto do_not_strip_quotes;
385
386 case '\\':
387 if (*++yyp != '\\')
388 goto do_not_strip_quotes;
389 /* Fall through. */
390 default:
391 yyr += *yyp;
392 break;
393
394 case '"':
395 return yyr;
396 }
397 do_not_strip_quotes: ;
398 }
399
400 return yystr;
401 }
402
403 #endif
404
405 #if YYDEBUG
406 /*--------------------------------.
407 | Print this symbol on YYOUTPUT. |
408 `--------------------------------*/
409
410 void
411 yy::]b4_parser_class_name[::yysymprint_ (int yytype,
412 const semantic_type* yyvaluep, const location_type* yylocationp)
413 {
414 /* Pacify ``unused variable'' warnings. */
415 (void) yyvaluep;
416 (void) yylocationp;
417 /* Backward compatibility, but should be removed eventually. */
418 std::ostream& cdebug_ = *yycdebug_;
419 (void) cdebug_;
420
421 *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
422 << ' ' << yytname_[yytype] << " ("
423 << *yylocationp << ": ";
424 switch (yytype)
425 {
426 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
427 [ default:
428 break;
429 }
430 *yycdebug_ << ')';
431 }
432 #endif /* ! YYDEBUG */
433
434 void
435 yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg,
436 int yytype, semantic_type* yyvaluep, location_type* yylocationp)
437 {
438 /* Pacify ``unused variable'' warnings. */
439 (void) yymsg;
440 (void) yyvaluep;
441 (void) yylocationp;
442
443 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
444
445 switch (yytype)
446 {
447 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
448 default:
449 break;
450 }
451 }
452
453 void
454 yy::]b4_parser_class_name[::yypop_ (unsigned int n)
455 {
456 yystate_stack_.pop (n);
457 yysemantic_stack_.pop (n);
458 yylocation_stack_.pop (n);
459 }
460
461 std::ostream&
462 yy::]b4_parser_class_name[::debug_stream () const
463 {
464 return *yycdebug_;
465 }
466
467 void
468 yy::]b4_parser_class_name[::set_debug_stream (std::ostream& o)
469 {
470 yycdebug_ = &o;
471 }
472
473
474 yy::]b4_parser_class_name[::debug_level_type
475 yy::]b4_parser_class_name[::debug_level () const
476 {
477 return yydebug_;
478 }
479
480 void
481 yy::]b4_parser_class_name[::set_debug_level (debug_level_type l)
482 {
483 yydebug_ = l;
484 }
485
486
487 int
488 yy::]b4_parser_class_name[::parse ()
489 {
490 /// Look-ahead and look-ahead in internal form.
491 int yychar = yyempty_;
492 int yytoken = 0;
493
494 /* State. */
495 int yyn;
496 int yylen;
497 int yystate = 0;
498
499 /* Error handling. */
500 int yynerrs_ = 0;
501 int yyerrstatus_ = 0;
502
503 /// Semantic value of the look-ahead.
504 semantic_type yylval;
505 /// Location of the look-ahead.
506 location_type yylloc;
507 /// The locations where the error started and ended.
508 location yyerror_range[2];
509
510 /// $$.
511 semantic_type yyval;
512 /// @@$.
513 location_type yyloc;
514
515 int yyresult;
516
517 YYCDEBUG << "Starting parse" << std::endl;
518
519 ]m4_ifdef([b4_initial_action], [
520 m4_pushdef([b4_at_dollar], [yylloc])dnl
521 m4_pushdef([b4_dollar_dollar], [yylval])dnl
522 /* User initialization code. */
523 b4_initial_action
524 m4_popdef([b4_dollar_dollar])dnl
525 m4_popdef([b4_at_dollar])dnl
526 /* Line __line__ of yacc.c. */
527 b4_syncline([@oline@], [@ofile@])])dnl
528
529 [ /* Initialize the stacks. The initial state will be pushed in
530 yynewstate, since the latter expects the semantical and the
531 location values to have been already stored, initialize these
532 stacks with a primary value. */
533 yystate_stack_ = state_stack_type (0);
534 yysemantic_stack_ = semantic_stack_type (0);
535 yylocation_stack_ = location_stack_type (0);
536 yysemantic_stack_.push (yylval);
537 yylocation_stack_.push (yylloc);
538
539 /* New state. */
540 yynewstate:
541 yystate_stack_.push (yystate);
542 YYCDEBUG << "Entering state " << yystate << std::endl;
543 goto yybackup;
544
545 /* Backup. */
546 yybackup:
547
548 /* Try to take a decision without look-ahead. */
549 yyn = yypact_[yystate];
550 if (yyn == yypact_ninf_)
551 goto yydefault;
552
553 /* Read a look-ahead token. */
554 if (yychar == yyempty_)
555 {
556 YYCDEBUG << "Reading a token: ";
557 yychar = ]b4_c_function_call([yylex], [int],
558 [[YYSTYPE*], [&yylval]][]dnl
559 b4_location_if([, [[location*], [&yylloc]]])dnl
560 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
561 }
562
563
564 /* Convert token to internal form. */
565 if (yychar <= yyeof_)
566 {
567 yychar = yytoken = yyeof_;
568 YYCDEBUG << "Now at end of input." << std::endl;
569 }
570 else
571 {
572 yytoken = yytranslate_ (yychar);
573 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
574 }
575
576 /* If the proper action on seeing token YYTOKEN is to reduce or to
577 detect an error, take that action. */
578 yyn += yytoken;
579 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
580 goto yydefault;
581
582 /* Reduce or error. */
583 yyn = yytable_[yyn];
584 if (yyn <= 0)
585 {
586 if (yyn == 0 || yyn == yytable_ninf_)
587 goto yyerrlab;
588 yyn = -yyn;
589 goto yyreduce;
590 }
591
592 /* Accept? */
593 if (yyn == yyfinal_)
594 goto yyacceptlab;
595
596 /* Shift the look-ahead token. */
597 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
598
599 /* Discard the token being shifted unless it is eof. */
600 if (yychar != yyeof_)
601 yychar = yyempty_;
602
603 yysemantic_stack_.push (yylval);
604 yylocation_stack_.push (yylloc);
605
606 /* Count tokens shifted since error; after three, turn off error
607 status. */
608 if (yyerrstatus_)
609 --yyerrstatus_;
610
611 yystate = yyn;
612 goto yynewstate;
613
614 /*-----------------------------------------------------------.
615 | yydefault -- do the default action for the current state. |
616 `-----------------------------------------------------------*/
617 yydefault:
618 yyn = yydefact_[yystate];
619 if (yyn == 0)
620 goto yyerrlab;
621 goto yyreduce;
622
623 /*-----------------------------.
624 | yyreduce -- Do a reduction. |
625 `-----------------------------*/
626 yyreduce:
627 yylen = yyr2_[yyn];
628 /* If LEN_ is nonzero, implement the default value of the action:
629 `$$ = $1'. Otherwise, use the top of the stack.
630
631 Otherwise, the following line sets YYVAL to garbage.
632 This behavior is undocumented and Bison
633 users should not rely upon it. */
634 if (yylen)
635 yyval = yysemantic_stack_[yylen - 1];
636 else
637 yyval = yysemantic_stack_[0];
638
639 {
640 slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
641 YYLLOC_DEFAULT (yyloc, slice, yylen);
642 }
643 YY_REDUCE_PRINT (yyn);
644 switch (yyn)
645 {
646 ]b4_actions[
647 default: break;
648 }
649
650 ]/* Line __line__ of lalr1.cc. */
651 b4_syncline([@oline@], [@ofile@])[
652
653 yypop_ (yylen);
654
655 YY_STACK_PRINT ();
656
657 yysemantic_stack_.push (yyval);
658 yylocation_stack_.push (yyloc);
659
660 /* Shift the result of the reduction. */
661 yyn = yyr1_[yyn];
662 yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
663 if (0 <= yystate && yystate <= yylast_
664 && yycheck_[yystate] == yystate_stack_[0])
665 yystate = yytable_[yystate];
666 else
667 yystate = yydefgoto_[yyn - yyntokens_];
668 goto yynewstate;
669
670 /*------------------------------------.
671 | yyerrlab -- here on detecting error |
672 `------------------------------------*/
673 yyerrlab:
674 /* If not already recovering from an error, report this error. */
675 if (!yyerrstatus_)
676 {
677 ++yynerrs_;
678 error (yylloc, yysyntax_error_ (yystate]dnl
679 b4_error_verbose_if([, yytoken])[));
680 }
681
682 yyerror_range[0] = yylloc;
683 if (yyerrstatus_ == 3)
684 {
685 /* If just tried and failed to reuse look-ahead token after an
686 error, discard it. */
687
688 if (yychar <= yyeof_)
689 {
690 /* Return failure if at end of input. */
691 if (yychar == yyeof_)
692 YYABORT;
693 }
694 else
695 {
696 yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
697 yychar = yyempty_;
698 }
699 }
700
701 /* Else will try to reuse look-ahead token after shifting the error
702 token. */
703 goto yyerrlab1;
704
705
706 /*---------------------------------------------------.
707 | yyerrorlab -- error raised explicitly by YYERROR. |
708 `---------------------------------------------------*/
709 yyerrorlab:
710
711 /* Pacify compilers like GCC when the user code never invokes
712 YYERROR and the label yyerrorlab therefore never appears in user
713 code. */
714 if (false)
715 goto yyerrorlab;
716
717 yyerror_range[0] = yylocation_stack_[yylen - 1];
718 yypop_ (yylen);
719 yystate = yystate_stack_[0];
720 goto yyerrlab1;
721
722 /*-------------------------------------------------------------.
723 | yyerrlab1 -- common code for both syntax error and YYERROR. |
724 `-------------------------------------------------------------*/
725 yyerrlab1:
726 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
727
728 for (;;)
729 {
730 yyn = yypact_[yystate];
731 if (yyn != yypact_ninf_)
732 {
733 yyn += yyterror_;
734 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
735 {
736 yyn = yytable_[yyn];
737 if (0 < yyn)
738 break;
739 }
740 }
741
742 /* Pop the current state because it cannot handle the error token. */
743 if (yystate_stack_.height () == 1)
744 YYABORT;
745
746 yyerror_range[0] = yylocation_stack_[0];
747 yydestruct_ ("Error: popping",
748 yystos_[yystate],
749 &yysemantic_stack_[0], &yylocation_stack_[0]);
750 yypop_ ();
751 yystate = yystate_stack_[0];
752 YY_STACK_PRINT ();
753 }
754
755 if (yyn == yyfinal_)
756 goto yyacceptlab;
757
758 yyerror_range[1] = yylloc;
759 // Using YYLLOC is tempting, but would change the location of
760 // the look-ahead. YYLOC is available though.
761 YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
762 yysemantic_stack_.push (yylval);
763 yylocation_stack_.push (yyloc);
764
765 /* Shift the error token. */
766 YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
767 &yysemantic_stack_[0], &yylocation_stack_[0]);
768
769 yystate = yyn;
770 goto yynewstate;
771
772 /* Accept. */
773 yyacceptlab:
774 yyresult = 0;
775 goto yyreturn;
776
777 /* Abort. */
778 yyabortlab:
779 yyresult = 1;
780 goto yyreturn;
781
782 yyreturn:
783 if (yychar != yyeof_ && yychar != yyempty_)
784 yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
785
786 while (yystate_stack_.height () != 1)
787 {
788 yydestruct_ ("Cleanup: popping",
789 yystos_[yystate_stack_[0]],
790 &yysemantic_stack_[0],
791 &yylocation_stack_[0]);
792 yypop_ ();
793 }
794
795 return yyresult;
796 }
797
798 // Generate an error message.
799 std::string
800 yy::]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl
801 b4_error_verbose_if([, int tok])[)
802 {
803 std::string res;
804 #if YYERROR_VERBOSE
805 int yyn = yypact_[yystate];
806 if (yypact_ninf_ < yyn && yyn < yylast_)
807 {
808 /* Start YYX at -YYN if negative to avoid negative indexes in
809 YYCHECK. */
810 int yyxbegin = yyn < 0 ? -yyn : 0;
811
812 /* Stay within bounds of both yycheck and yytname. */
813 int yychecklim = yylast_ - yyn;
814 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
815 int count = 0;
816 for (int x = yyxbegin; x < yyxend; ++x)
817 if (yycheck_[x + yyn] == x && x != yyterror_)
818 ++count;
819
820 // FIXME: This method of building the message is not compatible
821 // with internationalization. It should work like yacc.c does it.
822 // That is, first build a string that looks like this:
823 // "syntax error, unexpected %s or %s or %s"
824 // Then, invoke YY_ on this string.
825 // Finally, use the string as a format to output
826 // yytname_[tok], etc.
827 // Until this gets fixed, this message appears in English only.
828 res = "syntax error, unexpected ";
829 res += yytnamerr_ (yytname_[tok]);
830 if (count < 5)
831 {
832 count = 0;
833 for (int x = yyxbegin; x < yyxend; ++x)
834 if (yycheck_[x + yyn] == x && x != yyterror_)
835 {
836 res += (!count++) ? ", expecting " : " or ";
837 res += yytnamerr_ (yytname_[x]);
838 }
839 }
840 }
841 else
842 #endif
843 res = YY_("syntax error");
844 return res;
845 }
846
847
848 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
849 STATE-NUM. */
850 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
851 const ]b4_int_type_for([b4_pact])[
852 yy::]b4_parser_class_name[::yypact_[] =
853 {
854 ]b4_pact[
855 };
856
857 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
858 doesn't specify something else to do. Zero means the default is an
859 error. */
860 const ]b4_int_type_for([b4_defact])[
861 yy::]b4_parser_class_name[::yydefact_[] =
862 {
863 ]b4_defact[
864 };
865
866 /* YYPGOTO[NTERM-NUM]. */
867 const ]b4_int_type_for([b4_pgoto])[
868 yy::]b4_parser_class_name[::yypgoto_[] =
869 {
870 ]b4_pgoto[
871 };
872
873 /* YYDEFGOTO[NTERM-NUM]. */
874 const ]b4_int_type_for([b4_defgoto])[
875 yy::]b4_parser_class_name[::yydefgoto_[] =
876 {
877 ]b4_defgoto[
878 };
879
880 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
881 positive, shift that token. If negative, reduce the rule which
882 number is the opposite. If zero, do what YYDEFACT says. */
883 const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
884 const ]b4_int_type_for([b4_table])[
885 yy::]b4_parser_class_name[::yytable_[] =
886 {
887 ]b4_table[
888 };
889
890 /* YYCHECK. */
891 const ]b4_int_type_for([b4_check])[
892 yy::]b4_parser_class_name[::yycheck_[] =
893 {
894 ]b4_check[
895 };
896
897 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
898 symbol of state STATE-NUM. */
899 const ]b4_int_type_for([b4_stos])[
900 yy::]b4_parser_class_name[::yystos_[] =
901 {
902 ]b4_stos[
903 };
904
905 #if YYDEBUG
906 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
907 to YYLEX-NUM. */
908 const ]b4_int_type_for([b4_toknum])[
909 yy::]b4_parser_class_name[::yytoken_number_[] =
910 {
911 ]b4_toknum[
912 };
913 #endif
914
915 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
916 const ]b4_int_type_for([b4_r1])[
917 yy::]b4_parser_class_name[::yyr1_[] =
918 {
919 ]b4_r1[
920 };
921
922 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
923 const ]b4_int_type_for([b4_r2])[
924 yy::]b4_parser_class_name[::yyr2_[] =
925 {
926 ]b4_r2[
927 };
928
929 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
930 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
931 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
932 const char*
933 const yy::]b4_parser_class_name[::yytname_[] =
934 {
935 ]b4_tname[
936 };
937 #endif
938
939 #if YYDEBUG
940 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
941 const yy::]b4_parser_class_name[::rhs_number_type
942 yy::]b4_parser_class_name[::yyrhs_[] =
943 {
944 ]b4_rhs[
945 };
946
947 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
948 YYRHS. */
949 const ]b4_int_type_for([b4_prhs])[
950 yy::]b4_parser_class_name[::yyprhs_[] =
951 {
952 ]b4_prhs[
953 };
954
955 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
956 const ]b4_int_type_for([b4_rline])[
957 yy::]b4_parser_class_name[::yyrline_[] =
958 {
959 ]b4_rline[
960 };
961
962 // Print the state stack on the debug stream.
963 void
964 yy::]b4_parser_class_name[::yystack_print_ ()
965 {
966 *yycdebug_ << "Stack now";
967 for (state_stack_type::const_iterator i = yystate_stack_.begin ();
968 i != yystate_stack_.end (); ++i)
969 *yycdebug_ << ' ' << *i;
970 *yycdebug_ << std::endl;
971 }
972
973 // Report on the debug stream that the rule \a yyrule is going to be reduced.
974 void
975 yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
976 {
977 unsigned int yylno = yyrline_[yyrule];
978 /* Print the symbols being reduced, and their result. */
979 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
980 << " (line " << yylno << "), ";
981 for (]b4_int_type_for([b4_prhs])[ i = yyprhs_[yyrule];
982 0 <= yyrhs_[i]; ++i)
983 *yycdebug_ << yytname_[yyrhs_[i]] << ' ';
984 *yycdebug_ << "-> " << yytname_[yyr1_[yyrule]] << std::endl;
985 }
986 #endif // YYDEBUG
987
988 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
989 yy::]b4_parser_class_name[::token_number_type
990 yy::]b4_parser_class_name[::yytranslate_ (int token)
991 {
992 static
993 const token_number_type
994 translate_table[] =
995 {
996 ]b4_translate[
997 };
998 if ((unsigned int) token <= yyuser_token_number_max_)
999 return translate_table[token];
1000 else
1001 return yyundef_token_;
1002 }
1003
1004 const int yy::]b4_parser_class_name[::yyeof_ = 0;
1005 const int yy::]b4_parser_class_name[::yylast_ = ]b4_last[;
1006 const int yy::]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
1007 const int yy::]b4_parser_class_name[::yyempty_ = -2;
1008 const int yy::]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
1009 const int yy::]b4_parser_class_name[::yyterror_ = 1;
1010 const int yy::]b4_parser_class_name[::yyerrcode_ = 256;
1011 const int yy::]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
1012
1013 const unsigned int yy::]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
1014 const yy::]b4_parser_class_name[::token_number_type yy::]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
1015
1016 ]b4_epilogue
1017 dnl
1018 @output b4_dir_prefix[]stack.hh
1019 b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004, 2005])[
1020
1021 #ifndef BISON_STACK_HH
1022 # define BISON_STACK_HH
1023
1024 #include <deque>
1025
1026 namespace yy
1027 {
1028 template <class T, class S = std::deque<T> >
1029 class stack
1030 {
1031 public:
1032
1033 // Hide our reversed order.
1034 typedef typename S::reverse_iterator iterator;
1035 typedef typename S::const_reverse_iterator const_iterator;
1036
1037 stack () : seq_ ()
1038 {
1039 }
1040
1041 stack (unsigned int n) : seq_ (n)
1042 {
1043 }
1044
1045 inline
1046 T&
1047 operator [] (unsigned int i)
1048 {
1049 return seq_[i];
1050 }
1051
1052 inline
1053 const T&
1054 operator [] (unsigned int i) const
1055 {
1056 return seq_[i];
1057 }
1058
1059 inline
1060 void
1061 push (const T& t)
1062 {
1063 seq_.push_front (t);
1064 }
1065
1066 inline
1067 void
1068 pop (unsigned int n = 1)
1069 {
1070 for (; n; --n)
1071 seq_.pop_front ();
1072 }
1073
1074 inline
1075 unsigned int
1076 height () const
1077 {
1078 return seq_.size ();
1079 }
1080
1081 inline const_iterator begin () const { return seq_.rbegin (); }
1082 inline const_iterator end () const { return seq_.rend (); }
1083
1084 private:
1085
1086 S seq_;
1087 };
1088
1089 /// Present a slice of the top of a stack.
1090 template <class T, class S = stack<T> >
1091 class slice
1092 {
1093 public:
1094
1095 slice (const S& stack,
1096 unsigned int range) : stack_ (stack),
1097 range_ (range)
1098 {
1099 }
1100
1101 inline
1102 const T&
1103 operator [] (unsigned int i) const
1104 {
1105 return stack_[range_ - i];
1106 }
1107
1108 private:
1109
1110 const S& stack_;
1111 unsigned int range_;
1112 };
1113 }
1114
1115 #endif // not BISON_STACK_HH]
1116 m4_divert(-1)