]> git.saurik.com Git - bison.git/blob - data/lalr1.cc
projects / bison.git / blob
? search:


34bcc278df616404059c80c88bcbc5bc532d7116
[bison.git] / data / lalr1.cc
1 # C++ skeleton for Bison
2
3 # Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 # Free Software Foundation, 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 # b4_table_define(TABLE-NAME, CONTENT)
22 # ------------------------------------
23 # Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.
24 m4_define([b4_table_define],
25 [const b4_int_type_for([$2])
26 b4_parser_class_name::yy$1_[[]] =
27 {
28 $2
29 }dnl
30 ])
31
32 # How the semantic value is extracted when using variants.
33 b4_variant_if([
34 # b4_symbol_value(VAL, [TYPE])
35 # ----------------------------
36 m4_define([b4_symbol_value],
37 [m4_ifval([$2],
38 [$1.as<$2>()],
39 [$1])])
40 ]) # b4_variant_if
41
42
43 # b4_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT])
44 # ----------------------------------------------------
45 m4_define([b4_assert_if],
46 [b4_percent_define_ifdef([[assert]], [$1], [$2])])
47
48
49 # b4_lhs_value([TYPE])
50 # --------------------
51 # Expansion of $<TYPE>$.
52 m4_define([b4_lhs_value],
53 [b4_symbol_value([yylhs.value], [$1])])
54
55
56 # b4_lhs_location()
57 # -----------------
58 # Expansion of @$.
59 m4_define([b4_lhs_location],
60 [yylhs.location])
61
62
63 # b4_rhs_data(RULE-LENGTH, NUM)
64 # -----------------------------
65 # Return the data corresponding to the symbol #NUM, where the current
66 # rule has RULE-LENGTH symbols on RHS.
67 m4_define([b4_rhs_data],
68 [yystack_@{($1) - ($2)@}])
69
70
71 # b4_rhs_state(RULE-LENGTH, NUM)
72 # -----------------------------
73 # The state corresponding to the symbol #NUM, where the current
74 # rule has RULE-LENGTH symbols on RHS.
75 m4_define([b4_rhs_state],
76 [b4_rhs_data([$1], [$2]).state])
77
78
79 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
80 # --------------------------------------
81 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
82 # symbols on RHS.
83 m4_define([b4_rhs_value],
84 [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])])
85
86
87 # b4_rhs_location(RULE-LENGTH, NUM)
88 # ---------------------------------
89 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
90 # on RHS.
91 m4_define([b4_rhs_location],
92 [b4_rhs_data([$1], [$2]).location])
93
94
95 # b4_symbol_actions(FILENAME, LINENO,
96 # SYMBOL-TAG, SYMBOL-NUM,
97 # SYMBOL-ACTION, SYMBOL-TYPENAME)
98 # -------------------------------------------------
99 # Same as in C, but using references instead of pointers.
100 m4_define([b4_symbol_actions],
101 [m4_pushdef([b4_dollar_dollar],
102 [b4_symbol_value([yyvalue], [$6])])dnl
103 m4_pushdef([b4_at_dollar], [yylocation])dnl
104 case $4: // $3
105 b4_syncline([$2], [$1])
106 $5;
107 b4_syncline([@oline@], [@ofile@])
108 break;
109 m4_popdef([b4_at_dollar])dnl
110 m4_popdef([b4_dollar_dollar])dnl
111 ])
112
113
114 # b4_symbol_action_(SYMBOL-TAG, SYMBOL-NUM, SYMBOL-TYPENAME)
115 # ----------------------------------------------------------
116 # Invoke b4_dollar_dollar(SYMBOL_TYPENAME) for each symbol.
117 m4_define([b4_symbol_action_],
118 [m4_ifval($3,
119 [ case $2: // $1
120 b4_dollar_dollar($@);
121 break;
122 ])])
123
124
125 # b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
126 # ------------------------------------------------
127 # Run some ACTION ("build", or "destroy") on YYVAL of symbol type
128 # YYTYPE.
129 m4_define([b4_symbol_variant],
130 [m4_pushdef([b4_dollar_dollar],
131 [$2.$3<$][3>(m4_shift3($@))])dnl
132 switch ($1)
133 {
134 m4_map([b4_symbol_action_], m4_defn([b4_type_names]))
135 default:
136 break;
137 }
138 m4_popdef([b4_dollar_dollar])dnl
139 ])
140
141
142 # _b4_char_sizeof_counter
143 # -----------------------
144 # A counter used by _b4_char_sizeof_dummy to create fresh symbols.
145 m4_define([_b4_char_sizeof_counter],
146 [0])
147
148 # _b4_char_sizeof_dummy
149 # ---------------------
150 # At each call return a new C++ identifier.
151 m4_define([_b4_char_sizeof_dummy],
152 [m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl
153 dummy[]_b4_char_sizeof_counter])
154
155
156 # b4_char_sizeof(SYMBOL-TAG, SYMBOL-NUM, SYMBOL-TYPENAME)
157 # -------------------------------------------------------
158 # To be mapped on the list of type names to produce:
159 #
160 # char dummy1[sizeof(type_name_1)];
161 # char dummy2[sizeof(type_name_2)];
162 #
163 # for defined type names.
164 # $3 is doubly-quoted, do not quote it again.
165 m4_define([b4_char_sizeof],
166 [m4_ifval($3,
167 [
168 char _b4_char_sizeof_dummy@{sizeof($3)@}; // $1])dnl
169 ])
170
171
172 m4_pushdef([b4_copyright_years],
173 [2002, 2003, 2004, 2005, 2006, 2007, 2008])
174
175 m4_define([b4_parser_class_name],
176 [b4_percent_define_get([[parser_class_name]])])
177
178 # The header is mandatory.
179 b4_defines_if([],
180 [b4_fatal([b4_skeleton[: using %%defines is mandatory]])])
181
182 # Backward compatibility.
183 m4_define([b4_location_constructors])
184 m4_include(b4_pkgdatadir/[location.cc])
185
186 # We do want M4 expansion after # for CPP macros.
187 m4_changecom()
188 m4_divert_push(0)dnl
189 b4_defines_if(
190 [@output(b4_spec_defines_file@)@
191 b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])
192 dnl FIXME: This is wrong, we want computed header guards.
193 [
194 /* C++ LALR(1) parser skeleton written by Akim Demaille. */
195
196 #ifndef PARSER_HEADER_H
197 # define PARSER_HEADER_H
198
199 ]b4_percent_code_get([[requires]])[
200
201 ]b4_assert_if([#include <cassert>])[
202 #include <string>
203 #include <iostream>
204 #include "stack.hh"
205
206 ]b4_namespace_open[
207 class position;
208 class location;
209 ]b4_variant_if(
210 [[
211 /// A char[S] buffer to store and retrieve objects.
212 ///
213 /// Sort of a variant, but does not keep track of the nature
214 /// of the stored data, since that knowledge is available
215 /// via the current state.
216 template <size_t S>
217 struct variant
218 {]b4_assert_if([
219 /// Whether something is contained.
220 bool built;
221
222 /// Initially uninitialized.
223 variant ()
224 : built(false)
225 {}])[
226
227 /// Instantiate a \a T in here.
228 template <typename T>
229 inline T&
230 build()
231 {]b4_assert_if([
232 assert(!built);
233 built = true;])[
234 return *new (buffer) T;
235 }
236
237 /// Accessor to a built \a T.
238 template <typename T>
239 inline T&
240 as()
241 {]b4_assert_if([
242 assert(built);])[
243 return reinterpret_cast<T&>(buffer);
244 }
245
246 /// Const accessor to a built \a T (for %printer).
247 template <typename T>
248 inline const T&
249 as() const
250 {]b4_assert_if([
251 assert(built);])[
252 return reinterpret_cast<const T&>(buffer);
253 }
254
255 /// Swap the content with \a other.
256 template <typename T>
257 inline void
258 swap(variant<S>& other)
259 {
260 std::swap(as<T>(), other.as<T>());
261 }
262
263 /// Assign the content of \a other to this.
264 /// Destroys \a other.
265 template <typename T>
266 inline void
267 build(variant<S>& other)
268 {
269 build<T>();
270 swap<T>(other);
271 other.destroy<T>();
272 }
273
274 /// Destroy the stored \a T.
275 template <typename T>
276 inline void
277 destroy()
278 {
279 as<T>().~T();]b4_assert_if([
280 built = false;])[
281 }
282
283 /// A buffer large enough to store any of the semantic values.
284 char buffer[S];
285 };
286 ]])[
287 ]b4_namespace_close[
288
289 #include "location.hh"
290
291 /* Enabling traces. */
292 #ifndef YYDEBUG
293 # define YYDEBUG ]b4_debug_flag[
294 #endif
295
296 /* Enabling verbose error messages. */
297 #ifdef YYERROR_VERBOSE
298 # undef YYERROR_VERBOSE
299 # define YYERROR_VERBOSE 1
300 #else
301 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
302 #endif
303
304 /* Enabling the token table. */
305 #ifndef YYTOKEN_TABLE
306 # define YYTOKEN_TABLE ]b4_token_table[
307 #endif
308
309 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
310 If N is 0, then set CURRENT to the empty location which ends
311 the previous symbol: RHS[0] (always defined). */
312
313 #ifndef YYLLOC_DEFAULT
314 # define YYLLOC_DEFAULT(Current, Rhs, N) \
315 do { \
316 if (N) \
317 { \
318 (Current).begin = (Rhs)[1].location.begin; \
319 (Current).end = (Rhs)[N].location.end; \
320 } \
321 else \
322 { \
323 (Current).begin = (Current).end = (Rhs)[0].location.end; \
324 } \
325 } while (false)
326 #endif
327
328 ]b4_namespace_open[
329
330 /// A Bison parser.
331 class ]b4_parser_class_name[
332 {
333 public:
334 #ifndef YYSTYPE
335 ]b4_variant_if(
336 [ /// An auxiliary type to compute the largest semantic type.
337 union union_type
338 {]m4_map([b4_char_sizeof], m4_defn([b4_type_names]))[
339 };
340
341 /// Symbol semantic values.
342 typedef variant<sizeof(union_type)> semantic_type;],
343 [ /// Symbol semantic values.
344 m4_ifdef([b4_stype],
345 [ union semantic_type
346 {b4_user_stype
347 };],
348 [m4_if(b4_tag_seen_flag, 0,
349 [[ typedef int semantic_type;]],
350 [[ typedef YYSTYPE semantic_type;]])])])[
351 #else
352 typedef YYSTYPE semantic_type;
353 #endif
354 /// Symbol locations.
355 typedef ]b4_percent_define_get([[location_type]])[ location_type;
356 /// Tokens.
357 struct token
358 {
359 ]b4_token_enums(b4_tokens)[
360 };
361 /// Token type.
362 typedef token::yytokentype token_type;
363
364 /// Build a parser object.
365 ]b4_parser_class_name[ (]b4_parse_param_decl[);
366 virtual ~]b4_parser_class_name[ ();
367
368 /// Parse.
369 /// \returns 0 iff parsing succeeded.
370 virtual int parse ();
371
372 #if YYDEBUG
373 /// The current debugging stream.
374 std::ostream& debug_stream () const;
375 /// Set the current debugging stream.
376 void set_debug_stream (std::ostream &);
377
378 /// Type for debugging levels.
379 typedef int debug_level_type;
380 /// The current debugging level.
381 debug_level_type debug_level () const;
382 /// Set the current debugging level.
383 void set_debug_level (debug_level_type l);
384 #endif
385
386 private:
387 /// Report a syntax error.
388 /// \param loc where the syntax error is found.
389 /// \param msg a description of the syntax error.
390 virtual void error (const location_type& loc, const std::string& msg);
391
392 /// Generate an error message.
393 /// \param state the state where the error occurred.
394 /// \param tok the lookahead token.
395 virtual std::string yysyntax_error_ (int yystate, int tok);
396
397 #if YYDEBUG
398 /// \brief Report a symbol value on the debug stream.
399 /// \param yytype The token type.
400 /// \param yyvalue Its semantic value.
401 /// \param yylocation Its location.
402 virtual void yy_symbol_value_print_ (int yytype,
403 const semantic_type& yyvalue,
404 const location_type& yylocation);
405 /// \brief Report a symbol on the debug stream.
406 /// \param yytype The token type.
407 /// \param yyvalue Its semantic value.
408 /// \param yylocation Its location.
409 virtual void yy_symbol_print_ (int yytype,
410 const semantic_type& yyvalue,
411 const location_type& yylocation);
412 #endif
413
414 /// State numbers.
415 typedef int state_type;
416
417 /// Internal symbol numbers.
418 typedef ]b4_int_type_for([b4_translate])[ token_number_type;
419 /* Tables. */
420 /// For a state, the index in \a yytable_ of its portion.
421 static const ]b4_int_type_for([b4_pact])[ yypact_[];
422 static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
423
424 /// For a state, default rule to reduce.
425 /// Unless\a yytable_ specifies something else to do.
426 /// Zero means the default is an error.
427 static const ]b4_int_type_for([b4_defact])[ yydefact_[];
428
429 static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
430 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
431
432 /// What to do in a state.
433 /// \a yytable_[yypact_[s]]: what to do in state \a s.
434 /// - if positive, shift that token.
435 /// - if negative, reduce the rule which number is the opposite.
436 /// - if zero, do what YYDEFACT says.
437 static const ]b4_int_type_for([b4_table])[ yytable_[];
438 static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
439
440 static const ]b4_int_type_for([b4_check])[ yycheck_[];
441
442 /// For a state, its accessing symbol.
443 static const ]b4_int_type_for([b4_stos])[ yystos_[];
444
445 /// For a rule, its LHS.
446 static const ]b4_int_type_for([b4_r1])[ yyr1_[];
447 /// For a rule, its RHS length.
448 static const ]b4_int_type_for([b4_r2])[ yyr2_[];
449
450 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
451 /// For a symbol, its name in clear.
452 static const char* const yytname_[];
453 #endif
454
455 #if YYERROR_VERBOSE
456 /// Convert the symbol name \a n to a form suitable for a diagnostic.
457 virtual std::string yytnamerr_ (const char *n);
458 #endif
459
460 #if YYDEBUG
461 /// For each rule, its source line number.
462 static const ]b4_int_type_for([b4_rline])[ yyrline_[];
463 /// For each scanner token number, its symbol number.
464 static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[];
465 /// Report on the debug stream that the rule \a r is going to be reduced.
466 virtual void yy_reduce_print_ (int r);
467 /// Print the state stack on the debug stream.
468 virtual void yystack_print_ ();
469
470 /* Debugging. */
471 int yydebug_;
472 std::ostream* yycdebug_;
473 #endif
474
475 /// Convert a scanner token number \a t to a symbol number.
476 token_number_type yytranslate_ (int t);
477
478 /// \brief Reclaim the memory associated to a symbol.
479 /// \param yymsg Why this token is reclaimed.
480 /// If null, nothing is printed at all.
481 /// \param yytype The symbol type.
482 /// \param yyvalue Its semantic value.
483 /// \param yylocation Its location.
484 inline void yydestruct_ (const char* yymsg,
485 int yytype,
486 semantic_type& yyvalue,
487 location_type& yylocation);
488
489 /// Element of the stack: a state and its attributes.
490 struct data_type
491 {
492 /// Default constructor.
493 data_type ();
494
495 /// Constructor.
496 data_type (state_type s, const semantic_type& v, const location_type& l);
497
498 /// The state.
499 state_type state;
500
501 /// The semantic value.
502 semantic_type value;
503
504 /// The location.
505 location_type location;
506 };
507
508 /// Stack type.
509 typedef stack<data_type> stack_type;
510
511 /// The stack.
512 stack_type yystack_;
513
514 /// Push a new state on the stack.
515 /// \param m a debug message to display
516 /// if null, no trace is output.
517 /// \param s the state entered
518 /// \param v semantic value
519 /// \param l location
520 /// \warning the contents of \a v is stolen.
521 inline void yypush_ (const char* m, state_type s,
522 semantic_type& v, const location_type& l);
523
524 /// Pop \a n symbols the three stacks.
525 inline void yypop_ (unsigned int n = 1);
526
527 /* Constants. */
528 static const int yyeof_;
529 /* LAST_ -- Last index in TABLE_. */
530 static const int yylast_;
531 static const int yynnts_;
532 static const int yyempty_;
533 static const int yyfinal_;
534 static const int yyterror_;
535 static const int yyerrcode_;
536 static const int yyntokens_;
537 static const unsigned int yyuser_token_number_max_;
538 static const token_number_type yyundef_token_;
539 ]b4_parse_param_vars[
540 };
541 ]b4_namespace_close[
542
543 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
544 [b4_token_defines(b4_tokens)
545
546 #ifndef YYSTYPE
547 /* Redirection for backward compatibility. */
548 # define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type
549 #endif
550 ])
551 b4_percent_code_get([[provides]])[]dnl
552
553 [#endif /* ! defined PARSER_HEADER_H */]
554 ])dnl
555 @output(b4_parser_file_name@)@
556 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])
557 b4_percent_code_get([[top]])[]dnl
558 m4_if(b4_prefix, [yy], [],
559 [
560 // Take the name prefix into account.
561 #define yylex b4_prefix[]lex])[
562
563 /* First part of user declarations. */
564 ]b4_user_pre_prologue
565
566 b4_defines_if([[
567 #include "@basename(]b4_spec_defines_file[@)"]])[
568
569 /* User implementation prologue. */
570 ]b4_user_post_prologue
571 b4_percent_code_get[]dnl
572
573 [#ifndef YY_
574 # if YYENABLE_NLS
575 # if ENABLE_NLS
576 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
577 # define YY_(msgid) dgettext ("bison-runtime", msgid)
578 # endif
579 # endif
580 # ifndef YY_
581 # define YY_(msgid) msgid
582 # endif
583 #endif
584
585 /* Suppress unused-variable warnings by "using" E. */
586 #define YYUSE(e) ((void) (e))
587
588 /* Enable debugging if requested. */
589 #if YYDEBUG
590
591 /* A pseudo ostream that takes yydebug_ into account. */
592 # define YYCDEBUG if (yydebug_) (*yycdebug_)
593
594 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
595 do { \
596 if (yydebug_) \
597 { \
598 *yycdebug_ << Title << ' '; \
599 yy_symbol_print_ ((Type), (Value), (Location)); \
600 *yycdebug_ << std::endl; \
601 } \
602 } while (false)
603
604 # define YY_REDUCE_PRINT(Rule) \
605 do { \
606 if (yydebug_) \
607 yy_reduce_print_ (Rule); \
608 } while (false)
609
610 # define YY_STACK_PRINT() \
611 do { \
612 if (yydebug_) \
613 yystack_print_ (); \
614 } while (false)
615
616 #else /* !YYDEBUG */
617
618 # define YYCDEBUG if (false) std::cerr
619 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) static_cast<void>(0)
620 # define YY_REDUCE_PRINT(Rule) static_cast<void>(0)
621 # define YY_STACK_PRINT() static_cast<void>(0)
622
623 #endif /* !YYDEBUG */
624
625 #define yyerrok (yyerrstatus_ = 0)
626 #define yyclearin (yychar = yyempty_)
627
628 #define YYACCEPT goto yyacceptlab
629 #define YYABORT goto yyabortlab
630 #define YYERROR goto yyerrorlab
631 #define YYRECOVERING() (!!yyerrstatus_)
632
633 ]b4_namespace_open[
634 #if YYERROR_VERBOSE
635
636 /* Return YYSTR after stripping away unnecessary quotes and
637 backslashes, so that it's suitable for yyerror. The heuristic is
638 that double-quoting is unnecessary unless the string contains an
639 apostrophe, a comma, or backslash (other than backslash-backslash).
640 YYSTR is taken from yytname. */
641 std::string
642 ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
643 {
644 if (*yystr == '"')
645 {
646 std::string yyr = "";
647 char const *yyp = yystr;
648
649 for (;;)
650 switch (*++yyp)
651 {
652 case '\'':
653 case ',':
654 goto do_not_strip_quotes;
655
656 case '\\':
657 if (*++yyp != '\\')
658 goto do_not_strip_quotes;
659 /* Fall through. */
660 default:
661 yyr += *yyp;
662 break;
663
664 case '"':
665 return yyr;
666 }
667 do_not_strip_quotes: ;
668 }
669
670 return yystr;
671 }
672
673 #endif
674
675 /// Build a parser object.
676 ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
677 :])[
678 #if YYDEBUG
679 ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false),
680 yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
681 #endif]b4_parse_param_cons[
682 {
683 }
684
685 ]b4_parser_class_name::~b4_parser_class_name[ ()
686 {
687 }
688
689 #if YYDEBUG
690 /*--------------------------------.
691 | Print this symbol on YYOUTPUT. |
692 `--------------------------------*/
693
694 inline void
695 ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
696 const semantic_type& yyvalue, const location_type& yylocation)
697 {
698 YYUSE (yylocation);
699 YYUSE (yyvalue);
700 switch (yytype)
701 {
702 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
703 [ default:
704 break;
705 }
706 }
707
708
709 void
710 ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
711 const semantic_type& yyvalue, const location_type& yylocation)
712 {
713 *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
714 << ' ' << yytname_[yytype] << " ("
715 << yylocation << ": ";
716 yy_symbol_value_print_ (yytype, yyvalue, yylocation);
717 *yycdebug_ << ')';
718 }
719 #endif
720
721 void
722 ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
723 int yytype, semantic_type& yyvalue, location_type& yylocation)
724 {
725 YYUSE (yymsg);
726 YYUSE (yyvalue);
727 YYUSE (yylocation);
728
729 if (yymsg)
730 YY_SYMBOL_PRINT (yymsg, yytype, yyvalue, yylocation);
731
732 // User destructor.
733 switch (yytype)
734 {
735 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
736 default:
737 break;
738 }]b4_variant_if([
739
740 // Type destructor.
741 b4_symbol_variant([[yytype]], [[yyvalue]], [[destroy]])])[
742 }
743
744 ]b4_parser_class_name[::data_type::data_type ()
745 : state()
746 , value()
747 , location()
748 {
749 }
750
751 ]b4_parser_class_name[::data_type::data_type (state_type s,
752 const semantic_type& v, const location_type& l)
753 : state(s)
754 , value(v)
755 , location(l)
756 {
757 }
758
759 void
760 ]b4_parser_class_name[::yypush_ (const char* m, state_type s,
761 semantic_type& v, const location_type& l)
762 {
763 if (m)
764 YY_SYMBOL_PRINT (m, yystos_[s], v, l);
765 ]b4_variant_if(
766 [[ yystack_.push (data_type (s, semantic_type(), l));
767 ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]], [build], [v])],
768 [ yystack_.push (data_type (s, v, l));])[
769 }
770
771 void
772 ]b4_parser_class_name[::yypop_ (unsigned int n)
773 {
774 yystack_.pop (n);
775 }
776
777 #if YYDEBUG
778 std::ostream&
779 ]b4_parser_class_name[::debug_stream () const
780 {
781 return *yycdebug_;
782 }
783
784 void
785 ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
786 {
787 yycdebug_ = &o;
788 }
789
790
791 ]b4_parser_class_name[::debug_level_type
792 ]b4_parser_class_name[::debug_level () const
793 {
794 return yydebug_;
795 }
796
797 void
798 ]b4_parser_class_name[::set_debug_level (debug_level_type l)
799 {
800 yydebug_ = l;
801 }
802 #endif
803
804 int
805 ]b4_parser_class_name[::parse ()
806 {
807 /// Lookahead and lookahead in internal form.
808 int yychar = yyempty_;
809 int yytoken = 0;
810
811 /* State. */
812 int yyn;
813 int yylen = 0;
814 int yystate = 0;
815
816 /* Error handling. */
817 int yynerrs_ = 0;
818 int yyerrstatus_ = 0;
819
820 /// Semantic value of the lookahead.
821 semantic_type yylval;
822 /// Location of the lookahead.
823 location_type yylloc;
824 /// The locations where the error started and ended.
825 data_type yyerror_range[2];
826
827 /// $$ and @@$.
828 data_type yylhs;
829
830 /// The return value of parse().
831 int yyresult;
832
833 YYCDEBUG << "Starting parse" << std::endl;
834
835 ]m4_ifdef([b4_initial_action], [
836 m4_pushdef([b4_at_dollar], [yylloc])dnl
837 m4_pushdef([b4_dollar_dollar], [yylval])dnl
838 /* User initialization code. */
839 b4_user_initial_action
840 m4_popdef([b4_dollar_dollar])dnl
841 m4_popdef([b4_at_dollar])])dnl
842
843 [ /* Initialize the stack. The initial state will be set in
844 yynewstate, since the latter expects the semantical and the
845 location values to have been already stored, initialize these
846 stacks with a primary value. */
847 yystack_ = stack_type (0);
848 yypush_ (0, yystate, yylval, yylloc);
849
850 // A new state was pushed on the stack.
851 // Invariant: yystate == yystack_[0].state, i.e.,
852 // yystate was just pushed onto the state stack.
853 yynewstate:
854 YYCDEBUG << "Entering state " << yystate << std::endl;
855
856 /* Accept? */
857 if (yystate == yyfinal_)
858 goto yyacceptlab;
859
860 goto yybackup;
861
862 /* Backup. */
863 yybackup:
864
865 /* Try to take a decision without lookahead. */
866 yyn = yypact_[yystate];
867 if (yyn == yypact_ninf_)
868 goto yydefault;
869
870 /* Read a lookahead token. */
871 if (yychar == yyempty_)
872 {
873 YYCDEBUG << "Reading a token: ";
874 yychar = ]b4_c_function_call([yylex], [int],
875 [[YYSTYPE*], [&yylval]][]dnl
876 b4_locations_if([, [[location*], [&yylloc]]])dnl
877 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
878 }
879
880
881 /* Convert token to internal form. */
882 if (yychar <= yyeof_)
883 {
884 yychar = yytoken = yyeof_;
885 YYCDEBUG << "Now at end of input." << std::endl;
886 }
887 else
888 {
889 yytoken = yytranslate_ (yychar);
890 YY_SYMBOL_PRINT ("Next token is", yytoken, yylval, yylloc);
891 }
892
893 /* If the proper action on seeing token YYTOKEN is to reduce or to
894 detect an error, take that action. */
895 yyn += yytoken;
896 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
897 goto yydefault;
898
899 /* Reduce or error. */
900 yyn = yytable_[yyn];
901 if (yyn <= 0)
902 {
903 if (yyn == 0 || yyn == yytable_ninf_)
904 goto yyerrlab;
905 yyn = -yyn;
906 goto yyreduce;
907 }
908
909 /* Discard the token being shifted. */
910 yychar = yyempty_;
911
912 /* Count tokens shifted since error; after three, turn off error
913 status. */
914 if (yyerrstatus_)
915 --yyerrstatus_;
916
917 /* Shift the lookahead token. */
918 yystate = yyn;
919 yypush_ ("Shifting", yystate, yylval, yylloc);
920 goto yynewstate;
921
922 /*-----------------------------------------------------------.
923 | yydefault -- do the default action for the current state. |
924 `-----------------------------------------------------------*/
925 yydefault:
926 yyn = yydefact_[yystate];
927 if (yyn == 0)
928 goto yyerrlab;
929 goto yyreduce;
930
931 /*-----------------------------.
932 | yyreduce -- Do a reduction. |
933 `-----------------------------*/
934 yyreduce:
935 yylen = yyr2_[yyn];]b4_variant_if([
936 /* Variants are always initialized to an empty instance of the
937 correct type. The default $$=$1 rule is NOT applied when using
938 variants */
939 ]b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])[],[
940 /* If YYLEN is nonzero, implement the default value of the action:
941 `$$ = $1'. Otherwise, use the top of the stack.
942
943 Otherwise, the following line sets YYLHS.VALUE to garbage.
944 This behavior is undocumented and Bison
945 users should not rely upon it. */
946 if (yylen)
947 yylhs.value = yystack_@{yylen - 1@}.value;
948 else
949 yylhs.value = yystack_@{0@}.value;])[
950
951 // Compute the default @@$.
952 {
953 slice<data_type, stack_type> slice (yystack_, yylen);
954 YYLLOC_DEFAULT (yylhs.location, slice, yylen);
955 }
956
957 // Perform the reduction.
958 YY_REDUCE_PRINT (yyn);
959 switch (yyn)
960 {
961 ]b4_user_actions[
962 default:
963 break;
964 }
965 // Compute post-reduction state.
966 yyn = yyr1_[yyn];
967 yystate = yypgoto_[yyn - yyntokens_] + yystack_[yylen].state;
968 if (0 <= yystate && yystate <= yylast_
969 && yycheck_[yystate] == yystack_[yylen].state)
970 yystate = yytable_[yystate];
971 else
972 yystate = yydefgoto_[yyn - yyntokens_];
973 yylhs.state = yystate;
974 YY_SYMBOL_PRINT ("-> $$ =", yyn, yylhs.value, yylhs.location);
975 ]b4_variant_if([[
976 // Destroy the lhs symbols.
977 for (int i = 0; i < yylen; ++i)
978 // Destroy a variant which value may have be swapped with
979 // yylhs.value. The value of yylhs.value (hence maybe one of
980 // these lhs symbols) depends on what does the default
981 // contruction for this type. In the case of pointers for
982 // instance, nothing is done, so the value is junk. Therefore
983 // do not try to report the content in the debug trace, it's
984 // junk. Hence yymsg = 0. Besides, that keeps exactly the same
985 // traces as with the other Bison skeletons.
986 yydestruct_ (0,
987 yystos_[yystack_[i].state],
988 yystack_[i].value, yystack_[i].location);]])[
989
990 yypop_ (yylen);
991 yylen = 0;
992 YY_STACK_PRINT ();
993
994 /* Shift the result of the reduction. */
995 yypush_ (0, yylhs.state, yylhs.value, yylhs.location);
996 goto yynewstate;
997
998 /*------------------------------------.
999 | yyerrlab -- here on detecting error |
1000 `------------------------------------*/
1001 yyerrlab:
1002 /* If not already recovering from an error, report this error. */
1003 if (!yyerrstatus_)
1004 {
1005 ++yynerrs_;
1006 error (yylloc, yysyntax_error_ (yystate, yytoken));
1007 }
1008
1009 yyerror_range[0].location = yylloc;
1010 if (yyerrstatus_ == 3)
1011 {
1012 /* If just tried and failed to reuse lookahead token after an
1013 error, discard it. */
1014
1015 if (yychar <= yyeof_)
1016 {
1017 /* Return failure if at end of input. */
1018 if (yychar == yyeof_)
1019 YYABORT;
1020 }
1021 else
1022 {
1023 yydestruct_ ("Error: discarding", yytoken, yylval, yylloc);
1024 yychar = yyempty_;
1025 }
1026 }
1027
1028 /* Else will try to reuse lookahead token after shifting the error
1029 token. */
1030 goto yyerrlab1;
1031
1032
1033 /*---------------------------------------------------.
1034 | yyerrorlab -- error raised explicitly by YYERROR. |
1035 `---------------------------------------------------*/
1036 yyerrorlab:
1037
1038 /* Pacify compilers like GCC when the user code never invokes
1039 YYERROR and the label yyerrorlab therefore never appears in user
1040 code. */
1041 if (false)
1042 goto yyerrorlab;
1043
1044 yyerror_range[0].location = yystack_[yylen - 1].location;
1045 /* Do not reclaim the symbols of the rule which action triggered
1046 this YYERROR. */
1047 yypop_ (yylen);
1048 yylen = 0;
1049 yystate = yystack_[0].state;
1050 goto yyerrlab1;
1051
1052 /*-------------------------------------------------------------.
1053 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1054 `-------------------------------------------------------------*/
1055 yyerrlab1:
1056 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
1057 {
1058 data_type error_token;
1059 for (;;)
1060 {
1061 yyn = yypact_[yystate];
1062 if (yyn != yypact_ninf_)
1063 {
1064 yyn += yyterror_;
1065 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
1066 {
1067 yyn = yytable_[yyn];
1068 if (0 < yyn)
1069 break;
1070 }
1071 }
1072
1073 // Pop the current state because it cannot handle the error token.
1074 if (yystack_.size () == 1)
1075 YYABORT;
1076
1077 yyerror_range[0].location = yystack_[0].location;
1078 yydestruct_ ("Error: popping",
1079 yystos_[yystate],
1080 yystack_[0].value, yystack_[0].location);
1081 yypop_ ();
1082 yystate = yystack_[0].state;
1083 YY_STACK_PRINT ();
1084 }
1085
1086 yyerror_range[1].location = yylloc;
1087 YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2);
1088
1089 /* Shift the error token. */
1090 yystate = yyn;
1091 yypush_ ("Shifting", yystate, error_token.value, error_token.location);
1092 }
1093 goto yynewstate;
1094
1095 /* Accept. */
1096 yyacceptlab:
1097 yyresult = 0;
1098 goto yyreturn;
1099
1100 /* Abort. */
1101 yyabortlab:
1102 yyresult = 1;
1103 goto yyreturn;
1104
1105 yyreturn:
1106 if (yychar != yyempty_)
1107 yydestruct_ ("Cleanup: discarding lookahead", yytoken, yylval, yylloc);
1108
1109 /* Do not reclaim the symbols of the rule which action triggered
1110 this YYABORT or YYACCEPT. */
1111 yypop_ (yylen);
1112 while (yystack_.size () != 1)
1113 {
1114 yydestruct_ ("Cleanup: popping",
1115 yystos_[yystack_[0].state],
1116 yystack_[0].value, yystack_[0].location);
1117 yypop_ ();
1118 }
1119
1120 return yyresult;
1121 }
1122
1123 // Generate an error message.
1124 std::string
1125 ]b4_parser_class_name[::yysyntax_error_ (int yystate, int]dnl
1126 b4_error_verbose_if([ tok])[)
1127 {
1128 std::string res;
1129 YYUSE (yystate);
1130 #if YYERROR_VERBOSE
1131 int yyn = yypact_[yystate];
1132 if (yypact_ninf_ < yyn && yyn <= yylast_)
1133 {
1134 /* Start YYX at -YYN if negative to avoid negative indexes in
1135 YYCHECK. */
1136 int yyxbegin = yyn < 0 ? -yyn : 0;
1137
1138 /* Stay within bounds of both yycheck and yytname. */
1139 int yychecklim = yylast_ - yyn + 1;
1140 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1141 int count = 0;
1142 for (int x = yyxbegin; x < yyxend; ++x)
1143 if (yycheck_[x + yyn] == x && x != yyterror_)
1144 ++count;
1145
1146 // FIXME: This method of building the message is not compatible
1147 // with internationalization. It should work like yacc.c does it.
1148 // That is, first build a string that looks like this:
1149 // "syntax error, unexpected %s or %s or %s"
1150 // Then, invoke YY_ on this string.
1151 // Finally, use the string as a format to output
1152 // yytname_[tok], etc.
1153 // Until this gets fixed, this message appears in English only.
1154 res = "syntax error, unexpected ";
1155 res += yytnamerr_ (yytname_[tok]);
1156 if (count < 5)
1157 {
1158 count = 0;
1159 for (int x = yyxbegin; x < yyxend; ++x)
1160 if (yycheck_[x + yyn] == x && x != yyterror_)
1161 {
1162 res += (!count++) ? ", expecting " : " or ";
1163 res += yytnamerr_ (yytname_[x]);
1164 }
1165 }
1166 }
1167 else
1168 #endif
1169 res = YY_("syntax error");
1170 return res;
1171 }
1172
1173
1174 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1175 STATE-NUM. */
1176 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
1177 ]b4_table_define([pact], [b4_pact])[;
1178
1179 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
1180 doesn't specify something else to do. Zero means the default is an
1181 error. */
1182 ]b4_table_define([defact], [b4_defact])[;
1183
1184 /* YYPGOTO[NTERM-NUM]. */
1185 ]b4_table_define([pgoto], [b4_pgoto])[;
1186
1187 /* YYDEFGOTO[NTERM-NUM]. */
1188 ]b4_table_define([defgoto], [b4_defgoto])[;
1189
1190 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1191 positive, shift that token. If negative, reduce the rule which
1192 number is the opposite. If zero, do what YYDEFACT says. */
1193 const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
1194 ]b4_table_define([table], [b4_table])[;
1195
1196 /* YYCHECK. */
1197 ]b4_table_define([check], [b4_check])[;
1198
1199 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1200 symbol of state STATE-NUM. */
1201 ]b4_table_define([stos], [b4_stos])[;
1202
1203 #if YYDEBUG
1204 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
1205 to YYLEX-NUM. */
1206 ]b4_table_define([token_number], [b4_toknum])[;
1207 #endif
1208
1209 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1210 ]b4_table_define([r1], [b4_r1])[;
1211
1212 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1213 ]b4_table_define([r2], [b4_r2])[;
1214
1215 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1216 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1217 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
1218 const char*
1219 const ]b4_parser_class_name[::yytname_[] =
1220 {
1221 ]b4_tname[
1222 };
1223 #endif
1224
1225 #if YYDEBUG
1226 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1227 ]b4_table_define([rline], [b4_rline])[;
1228
1229 // Print the state stack on the debug stream.
1230 void
1231 ]b4_parser_class_name[::yystack_print_ ()
1232 {
1233 *yycdebug_ << "Stack now";
1234 for (stack_type::const_iterator
1235 i = yystack_.begin (),
1236 i_end = yystack_.end ();
1237 i != i_end; ++i)
1238 *yycdebug_ << ' ' << i->state;
1239 *yycdebug_ << std::endl;
1240 }
1241
1242 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1243 void
1244 ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
1245 {
1246 unsigned int yylno = yyrline_[yyrule];
1247 int yynrhs = yyr2_[yyrule];
1248 /* Print the symbols being reduced, and their result. */
1249 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1250 << " (line " << yylno << "):" << std::endl;
1251 /* The symbols being reduced. */
1252 for (int yyi = 0; yyi < yynrhs; yyi++)
1253 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1254 ]yystos_@{b4_rhs_state(yynrhs, yyi + 1)@}[,
1255 ]b4_rhs_value(yynrhs, yyi + 1)[,
1256 ]b4_rhs_location(yynrhs, yyi + 1)[);
1257 }
1258 #endif // YYDEBUG
1259
1260 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1261 ]b4_parser_class_name[::token_number_type
1262 ]b4_parser_class_name[::yytranslate_ (int t)
1263 {
1264 static
1265 const token_number_type
1266 translate_table[] =
1267 {
1268 ]b4_translate[
1269 };
1270 if ((unsigned int) t <= yyuser_token_number_max_)
1271 return translate_table[t];
1272 else
1273 return yyundef_token_;
1274 }
1275
1276 const int ]b4_parser_class_name[::yyeof_ = 0;
1277 const int ]b4_parser_class_name[::yylast_ = ]b4_last[;
1278 const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
1279 const int ]b4_parser_class_name[::yyempty_ = -2;
1280 const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
1281 const int ]b4_parser_class_name[::yyterror_ = 1;
1282 const int ]b4_parser_class_name[::yyerrcode_ = 256;
1283 const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
1284
1285 const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
1286 const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
1287
1288 ]b4_namespace_close[
1289
1290 ]b4_epilogue[]dnl
1291 @output(b4_dir_prefix[]stack.hh@)@
1292 b4_copyright([Stack handling for Bison parsers in C++])[
1293
1294 #ifndef BISON_STACK_HH
1295 # define BISON_STACK_HH
1296
1297 #include <deque>
1298
1299 ]b4_namespace_open[
1300 template <class T, class S = std::deque<T> >
1301 class stack
1302 {
1303 public:
1304
1305 // Hide our reversed order.
1306 typedef typename S::reverse_iterator iterator;
1307 typedef typename S::const_reverse_iterator const_iterator;
1308
1309 stack () : seq_ ()
1310 {
1311 }
1312
1313 stack (unsigned int n) : seq_ (n)
1314 {
1315 }
1316
1317 inline
1318 T&
1319 operator [] (unsigned int i)
1320 {
1321 return seq_[i];
1322 }
1323
1324 inline
1325 const T&
1326 operator [] (unsigned int i) const
1327 {
1328 return seq_[i];
1329 }
1330
1331 inline
1332 void
1333 push (const T& t)
1334 {
1335 seq_.push_front (t);
1336 }
1337
1338 inline
1339 void
1340 pop (unsigned int n = 1)
1341 {
1342 for (; n; --n)
1343 seq_.pop_front ();
1344 }
1345
1346 inline
1347 typename S::size_type
1348 size () const
1349 {
1350 return seq_.size ();
1351 }
1352
1353 inline const_iterator begin () const { return seq_.rbegin (); }
1354 inline const_iterator end () const { return seq_.rend (); }
1355
1356 private:
1357 /// The wrapped container.
1358 S seq_;
1359 };
1360
1361 /// Present a slice of the top of a stack.
1362 template <class T, class S = stack<T> >
1363 class slice
1364 {
1365 public:
1366
1367 slice (const S& stack,
1368 unsigned int range) : stack_ (stack),
1369 range_ (range)
1370 {
1371 }
1372
1373 inline
1374 const T&
1375 operator [] (unsigned int i) const
1376 {
1377 return stack_[range_ - i];
1378 }
1379
1380 private:
1381
1382 const S& stack_;
1383 unsigned int range_;
1384 };
1385 ]b4_namespace_close[
1386
1387 #endif // not BISON_STACK_HH[]dnl
1388 ]
1389 m4_divert_pop(0)
1390 m4_popdef([b4_copyright_years])dnl
bison