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