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


96bd3a78810c9575f0cdbcb986a9dd60450a3616
[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 /// The lookahead symbol.
821 data_type yyla;
822
823 /// The locations where the error started and ended.
824 data_type yyerror_range[2];
825
826 /// $$ and @@$.
827 data_type yylhs;
828
829 /// The return value of parse().
830 int yyresult;
831
832 YYCDEBUG << "Starting parse" << std::endl;
833
834 ]m4_ifdef([b4_initial_action], [
835 m4_pushdef([b4_at_dollar], [yyla.location])dnl
836 m4_pushdef([b4_dollar_dollar], [yyla.value])dnl
837 /* User initialization code. */
838 b4_user_initial_action
839 m4_popdef([b4_dollar_dollar])dnl
840 m4_popdef([b4_at_dollar])])dnl
841
842 [ /* Initialize the stack. The initial state will be set in
843 yynewstate, since the latter expects the semantical and the
844 location values to have been already stored, initialize these
845 stacks with a primary value. */
846 yystack_ = stack_type (0);
847 yypush_ (0, yyla.state, yyla.value, yyla.location);
848
849 // A new state was pushed on the stack.
850 // Invariant: yystate == yystack_[0].state, i.e.,
851 // yystate was just pushed onto the state stack.
852 yynewstate:
853 YYCDEBUG << "Entering state " << yystate << std::endl;
854
855 /* Accept? */
856 if (yystate == yyfinal_)
857 goto yyacceptlab;
858
859 goto yybackup;
860
861 /* Backup. */
862 yybackup:
863
864 /* Try to take a decision without lookahead. */
865 yyn = yypact_[yystate];
866 if (yyn == yypact_ninf_)
867 goto yydefault;
868
869 /* Read a lookahead token. */
870 if (yychar == yyempty_)
871 {
872 YYCDEBUG << "Reading a token: ";
873 yychar = ]b4_c_function_call([yylex], [int],
874 [[YYSTYPE*], [&yyla.value]][]dnl
875 b4_locations_if([, [[location*], [&yyla.location]]])dnl
876 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
877 }
878
879
880 /* Convert token to internal form. */
881 if (yychar <= yyeof_)
882 {
883 yychar = yytoken = yyeof_;
884 YYCDEBUG << "Now at end of input." << std::endl;
885 }
886 else
887 {
888 yytoken = yytranslate_ (yychar);
889 YY_SYMBOL_PRINT ("Next token is", yytoken, yyla.value, yyla.location);
890 }
891
892 /* If the proper action on seeing token YYTOKEN is to reduce or to
893 detect an error, take that action. */
894 yyn += yytoken;
895 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
896 goto yydefault;
897
898 /* Reduce or error. */
899 yyn = yytable_[yyn];
900 if (yyn <= 0)
901 {
902 if (yyn == 0 || yyn == yytable_ninf_)
903 goto yyerrlab;
904 yyn = -yyn;
905 goto yyreduce;
906 }
907
908 /* Discard the token being shifted. */
909 yychar = yyempty_;
910
911 /* Count tokens shifted since error; after three, turn off error
912 status. */
913 if (yyerrstatus_)
914 --yyerrstatus_;
915
916 /* Shift the lookahead token. */
917 yyla.state = yystate = yyn;
918 yypush_ ("Shifting", yyla.state, yyla.value, yyla.location);
919 goto yynewstate;
920
921 /*-----------------------------------------------------------.
922 | yydefault -- do the default action for the current state. |
923 `-----------------------------------------------------------*/
924 yydefault:
925 yyn = yydefact_[yystate];
926 if (yyn == 0)
927 goto yyerrlab;
928 goto yyreduce;
929
930 /*-----------------------------.
931 | yyreduce -- Do a reduction. |
932 `-----------------------------*/
933 yyreduce:
934 yylen = yyr2_[yyn];]b4_variant_if([
935 /* Variants are always initialized to an empty instance of the
936 correct type. The default $$=$1 rule is NOT applied when using
937 variants */
938 ]b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])[],[
939 /* If YYLEN is nonzero, implement the default value of the action:
940 `$$ = $1'. Otherwise, use the top of the stack.
941
942 Otherwise, the following line sets YYLHS.VALUE to garbage.
943 This behavior is undocumented and Bison
944 users should not rely upon it. */
945 if (yylen)
946 yylhs.value = yystack_@{yylen - 1@}.value;
947 else
948 yylhs.value = yystack_@{0@}.value;])[
949
950 // Compute the default @@$.
951 {
952 slice<data_type, stack_type> slice (yystack_, yylen);
953 YYLLOC_DEFAULT (yylhs.location, slice, yylen);
954 }
955
956 // Perform the reduction.
957 YY_REDUCE_PRINT (yyn);
958 switch (yyn)
959 {
960 ]b4_user_actions[
961 default:
962 break;
963 }
964 // Compute post-reduction state.
965 yyn = yyr1_[yyn];
966 yystate = yypgoto_[yyn - yyntokens_] + yystack_[yylen].state;
967 if (0 <= yystate && yystate <= yylast_
968 && yycheck_[yystate] == yystack_[yylen].state)
969 yystate = yytable_[yystate];
970 else
971 yystate = yydefgoto_[yyn - yyntokens_];
972 yylhs.state = yystate;
973 YY_SYMBOL_PRINT ("-> $$ =", yyn, yylhs.value, yylhs.location);
974 ]b4_variant_if([[
975 // Destroy the lhs symbols.
976 for (int i = 0; i < yylen; ++i)
977 // Destroy a variant which value may have be swapped with
978 // yylhs.value. The value of yylhs.value (hence maybe one of
979 // these lhs symbols) depends on what does the default
980 // contruction for this type. In the case of pointers for
981 // instance, nothing is done, so the value is junk. Therefore
982 // do not try to report the content in the debug trace, it's
983 // junk. Hence yymsg = 0. Besides, that keeps exactly the same
984 // traces as with the other Bison skeletons.
985 yydestruct_ (0,
986 yystos_[yystack_[i].state],
987 yystack_[i].value, yystack_[i].location);]])[
988
989 yypop_ (yylen);
990 yylen = 0;
991 YY_STACK_PRINT ();
992
993 /* Shift the result of the reduction. */
994 yypush_ (0, yylhs.state, yylhs.value, yylhs.location);
995 goto yynewstate;
996
997 /*------------------------------------.
998 | yyerrlab -- here on detecting error |
999 `------------------------------------*/
1000 yyerrlab:
1001 /* If not already recovering from an error, report this error. */
1002 if (!yyerrstatus_)
1003 {
1004 ++yynerrs_;
1005 error (yyla.location, yysyntax_error_ (yystate, yytoken));
1006 }
1007
1008 yyerror_range[0].location = yyla.location;
1009 if (yyerrstatus_ == 3)
1010 {
1011 /* If just tried and failed to reuse lookahead token after an
1012 error, discard it. */
1013
1014 if (yychar <= yyeof_)
1015 {
1016 /* Return failure if at end of input. */
1017 if (yychar == yyeof_)
1018 YYABORT;
1019 }
1020 else
1021 {
1022 yydestruct_ ("Error: discarding",
1023 yytoken, yyla.value, yyla.location);
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 = yyla.location;
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",
1108 yytoken, yyla.value, yyla.location);
1109
1110 /* Do not reclaim the symbols of the rule which action triggered
1111 this YYABORT or YYACCEPT. */
1112 yypop_ (yylen);
1113 while (yystack_.size () != 1)
1114 {
1115 yydestruct_ ("Cleanup: popping",
1116 yystos_[yystack_[0].state],
1117 yystack_[0].value, yystack_[0].location);
1118 yypop_ ();
1119 }
1120
1121 return yyresult;
1122 }
1123
1124 // Generate an error message.
1125 std::string
1126 ]b4_parser_class_name[::yysyntax_error_ (int yystate, int]dnl
1127 b4_error_verbose_if([ tok])[)
1128 {
1129 std::string res;
1130 YYUSE (yystate);
1131 #if YYERROR_VERBOSE
1132 int yyn = yypact_[yystate];
1133 if (yypact_ninf_ < yyn && yyn <= yylast_)
1134 {
1135 /* Start YYX at -YYN if negative to avoid negative indexes in
1136 YYCHECK. */
1137 int yyxbegin = yyn < 0 ? -yyn : 0;
1138
1139 /* Stay within bounds of both yycheck and yytname. */
1140 int yychecklim = yylast_ - yyn + 1;
1141 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
1142 int count = 0;
1143 for (int x = yyxbegin; x < yyxend; ++x)
1144 if (yycheck_[x + yyn] == x && x != yyterror_)
1145 ++count;
1146
1147 // FIXME: This method of building the message is not compatible
1148 // with internationalization. It should work like yacc.c does it.
1149 // That is, first build a string that looks like this:
1150 // "syntax error, unexpected %s or %s or %s"
1151 // Then, invoke YY_ on this string.
1152 // Finally, use the string as a format to output
1153 // yytname_[tok], etc.
1154 // Until this gets fixed, this message appears in English only.
1155 res = "syntax error, unexpected ";
1156 res += yytnamerr_ (yytname_[tok]);
1157 if (count < 5)
1158 {
1159 count = 0;
1160 for (int x = yyxbegin; x < yyxend; ++x)
1161 if (yycheck_[x + yyn] == x && x != yyterror_)
1162 {
1163 res += (!count++) ? ", expecting " : " or ";
1164 res += yytnamerr_ (yytname_[x]);
1165 }
1166 }
1167 }
1168 else
1169 #endif
1170 res = YY_("syntax error");
1171 return res;
1172 }
1173
1174
1175 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1176 STATE-NUM. */
1177 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
1178 ]b4_table_define([pact], [b4_pact])[;
1179
1180 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
1181 doesn't specify something else to do. Zero means the default is an
1182 error. */
1183 ]b4_table_define([defact], [b4_defact])[;
1184
1185 /* YYPGOTO[NTERM-NUM]. */
1186 ]b4_table_define([pgoto], [b4_pgoto])[;
1187
1188 /* YYDEFGOTO[NTERM-NUM]. */
1189 ]b4_table_define([defgoto], [b4_defgoto])[;
1190
1191 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1192 positive, shift that token. If negative, reduce the rule which
1193 number is the opposite. If zero, do what YYDEFACT says. */
1194 const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
1195 ]b4_table_define([table], [b4_table])[;
1196
1197 /* YYCHECK. */
1198 ]b4_table_define([check], [b4_check])[;
1199
1200 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
1201 symbol of state STATE-NUM. */
1202 ]b4_table_define([stos], [b4_stos])[;
1203
1204 #if YYDEBUG
1205 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
1206 to YYLEX-NUM. */
1207 ]b4_table_define([token_number], [b4_toknum])[;
1208 #endif
1209
1210 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1211 ]b4_table_define([r1], [b4_r1])[;
1212
1213 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1214 ]b4_table_define([r2], [b4_r2])[;
1215
1216 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1217 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1218 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
1219 const char*
1220 const ]b4_parser_class_name[::yytname_[] =
1221 {
1222 ]b4_tname[
1223 };
1224 #endif
1225
1226 #if YYDEBUG
1227 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1228 ]b4_table_define([rline], [b4_rline])[;
1229
1230 // Print the state stack on the debug stream.
1231 void
1232 ]b4_parser_class_name[::yystack_print_ ()
1233 {
1234 *yycdebug_ << "Stack now";
1235 for (stack_type::const_iterator
1236 i = yystack_.begin (),
1237 i_end = yystack_.end ();
1238 i != i_end; ++i)
1239 *yycdebug_ << ' ' << i->state;
1240 *yycdebug_ << std::endl;
1241 }
1242
1243 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1244 void
1245 ]b4_parser_class_name[::yy_reduce_print_ (int yyrule)
1246 {
1247 unsigned int yylno = yyrline_[yyrule];
1248 int yynrhs = yyr2_[yyrule];
1249 /* Print the symbols being reduced, and their result. */
1250 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1251 << " (line " << yylno << "):" << std::endl;
1252 /* The symbols being reduced. */
1253 for (int yyi = 0; yyi < yynrhs; yyi++)
1254 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1255 ]yystos_@{b4_rhs_state(yynrhs, yyi + 1)@}[,
1256 ]b4_rhs_value(yynrhs, yyi + 1)[,
1257 ]b4_rhs_location(yynrhs, yyi + 1)[);
1258 }
1259 #endif // YYDEBUG
1260
1261 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1262 ]b4_parser_class_name[::token_number_type
1263 ]b4_parser_class_name[::yytranslate_ (int t)
1264 {
1265 static
1266 const token_number_type
1267 translate_table[] =
1268 {
1269 ]b4_translate[
1270 };
1271 if ((unsigned int) t <= yyuser_token_number_max_)
1272 return translate_table[t];
1273 else
1274 return yyundef_token_;
1275 }
1276
1277 const int ]b4_parser_class_name[::yyeof_ = 0;
1278 const int ]b4_parser_class_name[::yylast_ = ]b4_last[;
1279 const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
1280 const int ]b4_parser_class_name[::yyempty_ = -2;
1281 const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
1282 const int ]b4_parser_class_name[::yyterror_ = 1;
1283 const int ]b4_parser_class_name[::yyerrcode_ = 256;
1284 const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
1285
1286 const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
1287 const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
1288
1289 ]b4_namespace_close[
1290
1291 ]b4_epilogue[]dnl
1292 @output(b4_dir_prefix[]stack.hh@)@
1293 b4_copyright([Stack handling for Bison parsers in C++])[
1294
1295 #ifndef BISON_STACK_HH
1296 # define BISON_STACK_HH
1297
1298 #include <deque>
1299
1300 ]b4_namespace_open[
1301 template <class T, class S = std::deque<T> >
1302 class stack
1303 {
1304 public:
1305
1306 // Hide our reversed order.
1307 typedef typename S::reverse_iterator iterator;
1308 typedef typename S::const_reverse_iterator const_iterator;
1309
1310 stack () : seq_ ()
1311 {
1312 }
1313
1314 stack (unsigned int n) : seq_ (n)
1315 {
1316 }
1317
1318 inline
1319 T&
1320 operator [] (unsigned int i)
1321 {
1322 return seq_[i];
1323 }
1324
1325 inline
1326 const T&
1327 operator [] (unsigned int i) const
1328 {
1329 return seq_[i];
1330 }
1331
1332 inline
1333 void
1334 push (const T& t)
1335 {
1336 seq_.push_front (t);
1337 }
1338
1339 inline
1340 void
1341 pop (unsigned int n = 1)
1342 {
1343 for (; n; --n)
1344 seq_.pop_front ();
1345 }
1346
1347 inline
1348 typename S::size_type
1349 size () const
1350 {
1351 return seq_.size ();
1352 }
1353
1354 inline const_iterator begin () const { return seq_.rbegin (); }
1355 inline const_iterator end () const { return seq_.rend (); }
1356
1357 private:
1358 /// The wrapped container.
1359 S seq_;
1360 };
1361
1362 /// Present a slice of the top of a stack.
1363 template <class T, class S = stack<T> >
1364 class slice
1365 {
1366 public:
1367
1368 slice (const S& stack,
1369 unsigned int range) : stack_ (stack),
1370 range_ (range)
1371 {
1372 }
1373
1374 inline
1375 const T&
1376 operator [] (unsigned int i) const
1377 {
1378 return stack_[range_ - i];
1379 }
1380
1381 private:
1382
1383 const S& stack_;
1384 unsigned int range_;
1385 };
1386 ]b4_namespace_close[
1387
1388 #endif // not BISON_STACK_HH[]dnl
1389 ]
1390 m4_divert_pop(0)
1391 m4_popdef([b4_copyright_years])dnl
bison