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