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


4f60505ae73c2d2fdb0d08d1cb8f83080f395918
[bison.git] / data / lalr1.cc
1 m4_divert(-1)
2 # C++ skeleton for Bison
3 # Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 2 of the License, or
8 # (at your option) any later version.
9
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18 # 02111-1307 USA
19
20 ## ---------------- ##
21 ## Default values. ##
22 ## ---------------- ##
23
24 # Default Parser class name.
25 m4_define_default([b4_parser_class_name], [Parser])
26
27
28
29 ## ----------------- ##
30 ## Semantic Values. ##
31 ## ----------------- ##
32
33
34 # b4_lhs_value([TYPE])
35 # --------------------
36 # Expansion of $<TYPE>$.
37 m4_define([b4_lhs_value],
38 [yyval[]m4_ifval([$1], [.$1])])
39
40
41 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
42 # --------------------------------------
43 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
44 # symbols on RHS.
45 m4_define([b4_rhs_value],
46 [semantic_stack_@{m4_eval([$1 - $2])@}m4_ifval([$3], [.$3])])
47
48 m4_define_default([b4_location_type], [Location])
49
50 # b4_lhs_location()
51 # -----------------
52 # Expansion of @$.
53 m4_define([b4_lhs_location],
54 [yyloc])
55
56
57 # b4_rhs_location(RULE-LENGTH, NUM)
58 # ---------------------------------
59 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
60 # on RHS.
61 m4_define([b4_rhs_location],
62 [location_stack_@{m4_eval([$1 - $2])@}])
63
64
65 # b4_parse_param_decl
66 # -------------------
67 # Extra formal arguments of the constructor.
68 # Change the parameter names from "foo" into "foo_yyarg", so that
69 # there is no collision bw the user chosen attribute name, and the
70 # argument name in the constructor.
71 m4_define([b4_parse_param_decl],
72 [m4_ifset([b4_parse_param],
73 [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
74
75 m4_define([b4_parse_param_decl_1],
76 [$1_yyarg])
77
78
79
80 # b4_parse_param_cons
81 # -------------------
82 # Extra initialisations of the constructor.
83 m4_define([b4_parse_param_cons],
84 [m4_ifset([b4_parse_param],
85 [,
86 b4_cc_constructor_calls(b4_parse_param)])])
87 m4_define([b4_cc_constructor_calls],
88 [m4_map_sep([b4_cc_constructor_call], [,
89 ], [$@])])
90 m4_define([b4_cc_constructor_call],
91 [$2 ($2_yyarg)])
92
93 # b4_parse_param_vars
94 # -------------------
95 # Extra instance variables.
96 m4_define([b4_parse_param_vars],
97 [m4_ifset([b4_parse_param],
98 [
99 /* User arguments. */
100 b4_cc_var_decls(b4_parse_param)])])
101 m4_define([b4_cc_var_decls],
102 [m4_map_sep([b4_cc_var_decl], [
103 ], [$@])])
104 m4_define([b4_cc_var_decl],
105 [ $1;])
106
107
108
109 # We do want M4 expansion after # for CPP macros.
110 m4_changecom()
111 m4_divert(0)dnl
112 m4_if(b4_defines_flag, 0, [],
113 [@output @output_header_name@
114 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
115 [2002, 2003, 2004])[
116 /* FIXME: This is wrong, we want computed header guards.
117 I don't know why the macros are missing now. :( */
118 #ifndef PARSER_HEADER_H
119 # define PARSER_HEADER_H
120
121 #include "stack.hh"
122 #include "location.hh"
123
124 #include <string>
125 #include <iostream>
126
127 /* Using locations. */
128 #define YYLSP_NEEDED ]b4_locations_flag[
129
130 ]b4_token_defines(b4_tokens)[
131
132 /* Copy the first part of user declarations. */
133 ]b4_pre_prologue[
134
135 ]/* Line __line__ of lalr1.cc. */
136 b4_syncline([@oline@], [@ofile@])[
137
138 /* Enabling traces. */
139 #ifndef YYDEBUG
140 # define YYDEBUG ]b4_debug[
141 #endif
142
143 /* Enabling verbose error message. */
144 #ifndef YYERROR_VERBOSE
145 # define YYERROR_VERBOSE ]b4_error_verbose[
146 #endif
147
148 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
149 ]m4_ifdef([b4_stype],
150 [b4_syncline([b4_stype_line], [b4_filename])
151 union YYSTYPE b4_stype;
152 /* Line __line__ of lalr1.cc. */
153 b4_syncline([@oline@], [@ofile@])],
154 [typedef int YYSTYPE;])[
155 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
156 # define YYSTYPE_IS_DECLARED 1
157 # define YYSTYPE_IS_TRIVIAL 1
158 #endif
159
160 /* Copy the second part of user declarations. */
161 ]b4_post_prologue[
162
163 ]/* Line __line__ of lalr1.cc. */
164 b4_syncline([@oline@], [@ofile@])[
165 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
166 If N is 0, then set CURRENT to the empty location which ends
167 the previous symbol: RHS[0] (always defined). */
168
169 #ifndef YYLLOC_DEFAULT
170 # define YYLLOC_DEFAULT(Current, Rhs, N) \
171 do { \
172 if (N) \
173 { \
174 (Current).begin = (Rhs)[1].begin; \
175 (Current).end = (Rhs)[N].end; \
176 } \
177 else \
178 { \
179 (Current).begin = (Current).end = (Rhs)[0].end; \
180 } \
181 } while (0)
182 #endif
183
184 namespace yy
185 {
186 class ]b4_parser_class_name[;
187
188 template <typename P>
189 struct Traits
190 {
191 };
192
193 template <>
194 struct Traits<]b4_parser_class_name[>
195 {
196 typedef ]b4_int_type_for([b4_translate])[ TokenNumberType;
197 typedef ]b4_int_type_for([b4_rhs])[ RhsNumberType;
198 typedef int StateType;
199 typedef YYSTYPE SemanticType;
200 typedef ]b4_location_type[ LocationType;
201 };
202 }
203
204 namespace yy
205 {
206 class ]b4_parser_class_name[
207 {
208 public:
209
210 typedef Traits<]b4_parser_class_name[>::TokenNumberType TokenNumberType;
211 typedef Traits<]b4_parser_class_name[>::RhsNumberType RhsNumberType;
212 typedef Traits<]b4_parser_class_name[>::StateType StateType;
213 typedef Traits<]b4_parser_class_name[>::SemanticType SemanticType;
214 typedef Traits<]b4_parser_class_name[>::LocationType LocationType;
215
216 typedef Stack<StateType> StateStack;
217 typedef Stack<SemanticType> SemanticStack;
218 typedef Stack<LocationType> LocationStack;
219
220 ]b4_parser_class_name[ (]b4_parse_param_decl[) :
221 yydebug_ (false),
222 yycdebug_ (&std::cerr)]b4_parse_param_cons[
223 {
224 }
225
226 virtual ~]b4_parser_class_name[ ()
227 {
228 }
229
230 /// Parse.
231 /// \returns 0 iff parsing succeeded.
232 virtual int parse ();
233
234 /// The current debugging stream.
235 std::ostream& debug_stream () const;
236 /// Set the current debugging stream.
237 void set_debug_stream (std::ostream &);
238
239 /// Type for debugging levels.
240 typedef int debug_level_type;
241 /// The current debugging level.
242 debug_level_type debug_level () const;
243 /// Set the current debugging level.
244 void set_debug_level (debug_level_type l);
245
246 private:
247
248 /// Call the scanner.
249 virtual void yylex_ ();
250 virtual void error_ ();
251 /// Generate an error message, and invoke error. */
252 virtual void yyreport_syntax_error_ ();
253 #if YYDEBUG
254 /// \brief Report a symbol on the debug stream.
255 /// \param yytype The token type.
256 /// \param yyvaluep Its semantic value.
257 /// \param yylocationp Its location.
258 virtual void yysymprint_ (int yytype,
259 const SemanticType* yyvaluep,
260 const LocationType* yylocationp);
261 #endif /* ! YYDEBUG */
262
263
264 /// The state stack.
265 StateStack state_stack_;
266 /// The semantic value stack.
267 SemanticStack semantic_stack_;
268 /// The location stack.
269 LocationStack location_stack_;
270
271 /* Tables. */
272 static const ]b4_int_type_for([b4_pact])[ pact_[];
273 static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ pact_ninf_;
274 static const ]b4_int_type_for([b4_defact])[ defact_[];
275 static const ]b4_int_type_for([b4_pgoto])[ pgoto_[];
276 static const ]b4_int_type_for([b4_defgoto])[ defgoto_[];
277 static const ]b4_int_type_for([b4_table])[ table_[];
278 static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ table_ninf_;
279 static const ]b4_int_type_for([b4_check])[ check_[];
280 static const ]b4_int_type_for([b4_stos])[ stos_[];
281 static const ]b4_int_type_for([b4_r1])[ r1_[];
282 static const ]b4_int_type_for([b4_r2])[ r2_[];
283
284 #if YYDEBUG || YYERROR_VERBOSE
285 static const char* const name_[];
286 #endif
287
288 /* More tables, for debugging. */
289 #if YYDEBUG
290 static const RhsNumberType rhs_[];
291 static const ]b4_int_type_for([b4_prhs])[ prhs_[];
292 static const ]b4_int_type_for([b4_rline])[ rline_[];
293 static const ]b4_int_type_for([b4_toknum])[ token_number_[];
294 virtual void yyreduce_print_ (int yyrule);
295 virtual void yystack_print_ ();
296 #endif
297
298 /// Convert a scanner token number to a symbol number.
299 inline TokenNumberType yytranslate_ (int token);
300
301 /// \brief Reclaim the memory associated to a symbol.
302 /// \param yymsg Why this token is reclaimed.
303 /// \param yytype The symbol type.
304 /// \param yyvaluep Its semantic value.
305 /// \param yylocationp Its location.
306 inline void yydestruct_ (const char* yymsg,
307 int yytype,
308 SemanticType* yyvaluep,
309 LocationType* yylocationp);
310
311 /// Pop \a n symbols the three stacks.
312 inline void yypop_ (unsigned int n = 1);
313
314 /* Constants. */
315 static const int eof_;
316 /* LAST_ -- Last index in TABLE_. */
317 static const int last_;
318 static const int nnts_;
319 static const int empty_;
320 static const int final_;
321 static const int terror_;
322 static const int errcode_;
323 static const int ntokens_;
324 static const unsigned int user_token_number_max_;
325 static const TokenNumberType undef_token_;
326
327 /* State. */
328 int n_;
329 int len_;
330 int state_;
331
332 /* Error handling. */
333 int nerrs_;
334 int errstatus_;
335
336 /* Debugging. */
337 int yydebug_;
338 std::ostream* yycdebug_;
339
340 /* Look-ahead and look-ahead in internal form. */
341 int looka_;
342 int ilooka_;
343
344 /* Message. */
345 std::string message;
346
347 /// Semantic value of the look-ahead.
348 SemanticType value;
349 /// Location of the look-ahead.
350 LocationType location;
351 /// The locations where the error started and ended.
352 Location error_range_[2];
353
354 /// $$.
355 SemanticType yyval;
356 /// @@$.
357 LocationType yyloc;
358 ]b4_parse_param_vars[
359 };
360 }
361
362 #endif /* ! defined PARSER_HEADER_H */]
363 ])dnl
364 @output @output_parser_name@
365 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
366 [2002, 2003, 2004])
367
368 m4_if(b4_defines_flag, 0, [], [#include @output_header_name@])[
369
370 /* A pseudo ostream that takes yydebug_ into account. */
371 # define YYCDEBUG \
372 for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false) \
373 (*yycdebug_)
374
375 /* Enable debugging if requested. */
376 #if YYDEBUG
377
378 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
379 do { \
380 if (yydebug_) \
381 { \
382 *yycdebug_ << (Title) << ' '; \
383 yysymprint_ ((Type), (Value), (Location)); \
384 *yycdebug_ << std::endl; \
385 } \
386 } while (0)
387
388 # define YY_REDUCE_PRINT(Rule) \
389 do { \
390 if (yydebug_) \
391 yyreduce_print_ (Rule); \
392 } while (0)
393
394 # define YY_STACK_PRINT() \
395 do { \
396 if (yydebug_) \
397 yystack_print_ (); \
398 } while (0)
399
400 #else /* !YYDEBUG */
401
402 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
403 # define YY_REDUCE_PRINT(Rule)
404 # define YY_STACK_PRINT()
405
406 #endif /* !YYDEBUG */
407
408 #define YYACCEPT goto yyacceptlab
409 #define YYABORT goto yyabortlab
410 #define YYERROR goto yyerrorlab
411
412 #if YYDEBUG
413 /*--------------------------------.
414 | Print this symbol on YYOUTPUT. |
415 `--------------------------------*/
416
417 void
418 yy::]b4_parser_class_name[::yysymprint_ (int yytype,
419 const SemanticType* yyvaluep, const LocationType* yylocationp)
420 {
421 /* Pacify ``unused variable'' warnings. */
422 (void) yyvaluep;
423 (void) yylocationp;
424 /* Backward compatibility, but should be removed eventually. */
425 std::ostream& cdebug_ = *yycdebug_;
426 (void) cdebug_;
427
428 *yycdebug_ << (yytype < ntokens_ ? "token" : "nterm")
429 << ' ' << name_[yytype] << " ("
430 << *yylocationp << ": ";
431 switch (yytype)
432 {
433 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
434 [ default:
435 break;
436 }
437 *yycdebug_ << ')';
438 }
439 #endif /* ! YYDEBUG */
440
441 void
442 yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg,
443 int yytype, SemanticType* yyvaluep, LocationType* yylocationp)
444 {
445 /* Pacify ``unused variable'' warnings. */
446 (void) yyvaluep;
447 (void) yylocationp;
448
449 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
450
451 switch (yytype)
452 {
453 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
454 default:
455 break;
456 }
457 }
458
459 void
460 yy::]b4_parser_class_name[::yypop_ (unsigned int n)
461 {
462 state_stack_.pop (n);
463 semantic_stack_.pop (n);
464 location_stack_.pop (n);
465 }
466
467 std::ostream&
468 yy::]b4_parser_class_name[::debug_stream () const
469 {
470 return *yycdebug_;
471 }
472
473 void
474 yy::]b4_parser_class_name[::set_debug_stream (std::ostream& o)
475 {
476 yycdebug_ = &o;
477 }
478
479
480 yy::]b4_parser_class_name[::debug_level_type
481 yy::]b4_parser_class_name[::debug_level () const
482 {
483 return yydebug_;
484 }
485
486 void
487 yy::]b4_parser_class_name[::set_debug_level (debug_level_type l)
488 {
489 yydebug_ = l;
490 }
491
492
493 int
494 yy::]b4_parser_class_name[::parse ()
495 {
496 YYCDEBUG << "Starting parse" << std::endl;
497
498 nerrs_ = 0;
499 errstatus_ = 0;
500
501 /* Start. */
502 state_ = 0;
503 looka_ = empty_;
504
505 ]m4_ifdef([b4_initial_action], [
506 m4_pushdef([b4_at_dollar], [location])dnl
507 m4_pushdef([b4_dollar_dollar], [value])dnl
508 /* User initialization code. */
509 b4_initial_action
510 m4_popdef([b4_dollar_dollar])dnl
511 m4_popdef([b4_at_dollar])dnl
512 /* Line __line__ of yacc.c. */
513 b4_syncline([@oline@], [@ofile@])])dnl
514
515 [ /* Initialize the stacks. The initial state will be pushed in
516 yynewstate, since the latter expects the semantical and the
517 location values to have been already stored, initialize these
518 stacks with a primary value. */
519 state_stack_ = StateStack (0);
520 semantic_stack_ = SemanticStack (0);
521 location_stack_ = LocationStack (0);
522 semantic_stack_.push (value);
523 location_stack_.push (location);
524
525 /* New state. */
526 yynewstate:
527 state_stack_.push (state_);
528 YYCDEBUG << "Entering state " << state_ << std::endl;
529 goto yybackup;
530
531 /* Backup. */
532 yybackup:
533
534 /* Try to take a decision without look-ahead. */
535 n_ = pact_[state_];
536 if (n_ == pact_ninf_)
537 goto yydefault;
538
539 /* Read a look-ahead token. */
540 if (looka_ == empty_)
541 yylex_ ();
542
543 /* Convert token to internal form. */
544 if (looka_ <= eof_)
545 {
546 looka_ = ilooka_ = eof_;
547 YYCDEBUG << "Now at end of input." << std::endl;
548 }
549 else
550 {
551 ilooka_ = yytranslate_ (looka_);
552 YY_SYMBOL_PRINT ("Next token is", ilooka_, &value, &location);
553 }
554
555 /* If the proper action on seeing token ILOOKA_ is to reduce or to
556 detect an error, take that action. */
557 n_ += ilooka_;
558 if (n_ < 0 || last_ < n_ || check_[n_] != ilooka_)
559 goto yydefault;
560
561 /* Reduce or error. */
562 n_ = table_[n_];
563 if (n_ < 0)
564 {
565 if (n_ == table_ninf_)
566 goto yyerrlab;
567 else
568 {
569 n_ = -n_;
570 goto yyreduce;
571 }
572 }
573 else if (n_ == 0)
574 goto yyerrlab;
575
576 /* Accept? */
577 if (n_ == final_)
578 goto yyacceptlab;
579
580 /* Shift the look-ahead token. */
581 YY_SYMBOL_PRINT ("Shifting", ilooka_, &value, &location);
582
583 /* Discard the token being shifted unless it is eof. */
584 if (looka_ != eof_)
585 looka_ = empty_;
586
587 semantic_stack_.push (value);
588 location_stack_.push (location);
589
590 /* Count tokens shifted since error; after three, turn off error
591 status. */
592 if (errstatus_)
593 --errstatus_;
594
595 state_ = n_;
596 goto yynewstate;
597
598 /*-----------------------------------------------------------.
599 | yydefault -- do the default action for the current state. |
600 `-----------------------------------------------------------*/
601 yydefault:
602 n_ = defact_[state_];
603 if (n_ == 0)
604 goto yyerrlab;
605 goto yyreduce;
606
607 /*-----------------------------.
608 | yyreduce -- Do a reduction. |
609 `-----------------------------*/
610 yyreduce:
611 len_ = r2_[n_];
612 /* If LEN_ is nonzero, implement the default value of the action:
613 `$$ = $1'. Otherwise, use the top of the stack.
614
615 Otherwise, the following line sets YYVAL to garbage.
616 This behavior is undocumented and Bison
617 users should not rely upon it. */
618 if (len_)
619 yyval = semantic_stack_[len_ - 1];
620 else
621 yyval = semantic_stack_[0];
622
623 {
624 Slice<LocationType, LocationStack> slice (location_stack_, len_);
625 YYLLOC_DEFAULT (yyloc, slice, len_);
626 }
627 YY_REDUCE_PRINT (n_);
628 switch (n_)
629 {
630 ]b4_actions[
631 }
632
633 ]/* Line __line__ of lalr1.cc. */
634 b4_syncline([@oline@], [@ofile@])[
635
636 yypop_ (len_);
637
638 YY_STACK_PRINT ();
639
640 semantic_stack_.push (yyval);
641 location_stack_.push (yyloc);
642
643 /* Shift the result of the reduction. */
644 n_ = r1_[n_];
645 state_ = pgoto_[n_ - ntokens_] + state_stack_[0];
646 if (0 <= state_ && state_ <= last_ && check_[state_] == state_stack_[0])
647 state_ = table_[state_];
648 else
649 state_ = defgoto_[n_ - ntokens_];
650 goto yynewstate;
651
652 /*------------------------------------.
653 | yyerrlab -- here on detecting error |
654 `------------------------------------*/
655 yyerrlab:
656 /* If not already recovering from an error, report this error. */
657 yyreport_syntax_error_ ();
658
659 error_range_[0] = location;
660 if (errstatus_ == 3)
661 {
662 /* If just tried and failed to reuse look-ahead token after an
663 error, discard it. */
664
665 /* Return failure if at end of input. */
666 if (looka_ <= eof_)
667 {
668 /* If at end of input, pop the error token,
669 then the rest of the stack, then return failure. */
670 if (looka_ == eof_)
671 for (;;)
672 {
673 error_range_[0] = location_stack_[0];
674 yypop_ ();
675 if (state_stack_.height () == 1)
676 YYABORT;
677 yydestruct_ ("Error: popping",
678 stos_[state_stack_[0]],
679 &semantic_stack_[0],
680 &location_stack_[0]);
681 }
682 }
683 else
684 {
685 yydestruct_ ("Error: discarding", ilooka_, &value, &location);
686 looka_ = empty_;
687 }
688 }
689
690 /* Else will try to reuse look-ahead token after shifting the error
691 token. */
692 goto yyerrlab1;
693
694
695 /*---------------------------------------------------.
696 | yyerrorlab -- error raised explicitly by YYERROR. |
697 `---------------------------------------------------*/
698 yyerrorlab:
699
700 #ifdef __GNUC__
701 /* Pacify GCC when the user code never invokes YYERROR and the label
702 yyerrorlab therefore never appears in user code. */
703 if (0)
704 goto yyerrorlab;
705 #endif
706
707 error_range_[0] = location_stack_[len_ - 1];
708 yypop_ (len_);
709 state_ = state_stack_[0];
710 goto yyerrlab1;
711
712 /*-------------------------------------------------------------.
713 | yyerrlab1 -- common code for both syntax error and YYERROR. |
714 `-------------------------------------------------------------*/
715 yyerrlab1:
716 errstatus_ = 3; /* Each real token shifted decrements this. */
717
718 for (;;)
719 {
720 n_ = pact_[state_];
721 if (n_ != pact_ninf_)
722 {
723 n_ += terror_;
724 if (0 <= n_ && n_ <= last_ && check_[n_] == terror_)
725 {
726 n_ = table_[n_];
727 if (0 < n_)
728 break;
729 }
730 }
731
732 /* Pop the current state because it cannot handle the error token. */
733 if (state_stack_.height () == 1)
734 YYABORT;
735
736 error_range_[0] = location_stack_[0];
737 yydestruct_ ("Error: popping",
738 stos_[state_], &semantic_stack_[0], &location_stack_[0]);
739 yypop_ ();
740 state_ = state_stack_[0];
741 YY_STACK_PRINT ();
742 }
743
744 if (n_ == final_)
745 goto yyacceptlab;
746
747 error_range_[1] = location;
748 // Using LOCATION is tempting, but would change the location of
749 // the look-ahead. YYLOC is available though.
750 YYLLOC_DEFAULT (yyloc, error_range_ - 1, 2);
751 semantic_stack_.push (value);
752 location_stack_.push (yyloc);
753
754 /* Shift the error token. */
755 YY_SYMBOL_PRINT ("Shifting", stos_[n_],
756 &semantic_stack_[0], &location_stack_[0]);
757
758 state_ = n_;
759 goto yynewstate;
760
761 /* Accept. */
762 yyacceptlab:
763 return 0;
764
765 /* Abort. */
766 yyabortlab:
767 /* Free the lookahead. */
768 yydestruct_ ("Error: discarding lookahead", ilooka_, &value, &location);
769 looka_ = empty_;
770 return 1;
771 }
772
773 void
774 yy::]b4_parser_class_name[::yylex_ ()
775 {
776 YYCDEBUG << "Reading a token: ";
777 #if YYLSP_NEEDED
778 looka_ = ]m4_default(b4_prefix, [yy])[lex (&value, &location);
779 #else
780 looka_ = ]m4_default(b4_prefix, [yy])[lex (&value);
781 #endif
782 }
783
784 // Generate an error message, and invoke error.
785 void
786 yy::]b4_parser_class_name[::yyreport_syntax_error_ ()
787 {
788 /* If not already recovering from an error, report this error. */
789 if (!errstatus_)
790 {
791 ++nerrs_;
792
793 #if YYERROR_VERBOSE
794 n_ = pact_[state_];
795 if (pact_ninf_ < n_ && n_ < last_)
796 {
797 message = "syntax error, unexpected ";
798 message += name_[ilooka_];
799 {
800 int count = 0;
801 for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
802 if (check_[x + n_] == x && x != terror_)
803 ++count;
804 if (count < 5)
805 {
806 count = 0;
807 for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
808 if (check_[x + n_] == x && x != terror_)
809 {
810 message += (!count++) ? ", expecting " : " or ";
811 message += name_[x];
812 }
813 }
814 }
815 }
816 else
817 #endif
818 message = "syntax error";
819 error_ ();
820 }
821 }
822
823
824 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
825 STATE-NUM. */
826 const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::pact_ninf_ = b4_pact_ninf[;
827 const ]b4_int_type_for([b4_pact])[
828 yy::]b4_parser_class_name[::pact_[] =
829 {
830 ]b4_pact[
831 };
832
833 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
834 doesn't specify something else to do. Zero means the default is an
835 error. */
836 const ]b4_int_type_for([b4_defact])[
837 yy::]b4_parser_class_name[::defact_[] =
838 {
839 ]b4_defact[
840 };
841
842 /* YYPGOTO[NTERM-NUM]. */
843 const ]b4_int_type_for([b4_pgoto])[
844 yy::]b4_parser_class_name[::pgoto_[] =
845 {
846 ]b4_pgoto[
847 };
848
849 /* YYDEFGOTO[NTERM-NUM]. */
850 const ]b4_int_type_for([b4_defgoto])[
851 yy::]b4_parser_class_name[::defgoto_[] =
852 {
853 ]b4_defgoto[
854 };
855
856 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
857 positive, shift that token. If negative, reduce the rule which
858 number is the opposite. If zero, do what YYDEFACT says. */
859 const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::table_ninf_ = b4_table_ninf[;
860 const ]b4_int_type_for([b4_table])[
861 yy::]b4_parser_class_name[::table_[] =
862 {
863 ]b4_table[
864 };
865
866 /* YYCHECK. */
867 const ]b4_int_type_for([b4_check])[
868 yy::]b4_parser_class_name[::check_[] =
869 {
870 ]b4_check[
871 };
872
873 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
874 symbol of state STATE-NUM. */
875 const ]b4_int_type_for([b4_stos])[
876 yy::]b4_parser_class_name[::stos_[] =
877 {
878 ]b4_stos[
879 };
880
881 #if YYDEBUG
882 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal token number corresponding
883 to YYLEX-NUM. */
884 const ]b4_int_type_for([b4_toknum])[
885 yy::]b4_parser_class_name[::token_number_[] =
886 {
887 ]b4_toknum[
888 };
889 #endif
890
891 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
892 const ]b4_int_type_for([b4_r1])[
893 yy::]b4_parser_class_name[::r1_[] =
894 {
895 ]b4_r1[
896 };
897
898 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
899 const ]b4_int_type_for([b4_r2])[
900 yy::]b4_parser_class_name[::r2_[] =
901 {
902 ]b4_r2[
903 };
904
905 #if YYDEBUG || YYERROR_VERBOSE
906 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
907 First, the terminals, then, starting at NTOKENS_, nonterminals. */
908 const char*
909 const yy::]b4_parser_class_name[::name_[] =
910 {
911 ]b4_tname[
912 };
913 #endif
914
915 #if YYDEBUG
916 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
917 const yy::]b4_parser_class_name[::RhsNumberType
918 yy::]b4_parser_class_name[::rhs_[] =
919 {
920 ]b4_rhs[
921 };
922
923 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
924 YYRHS. */
925 const ]b4_int_type_for([b4_prhs])[
926 yy::]b4_parser_class_name[::prhs_[] =
927 {
928 ]b4_prhs[
929 };
930
931 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
932 const ]b4_int_type_for([b4_rline])[
933 yy::]b4_parser_class_name[::rline_[] =
934 {
935 ]b4_rline[
936 };
937
938 /// Print the state stack on the debug stream.
939 void
940 yy::]b4_parser_class_name[::yystack_print_ ()
941 {
942 *yycdebug_ << "Stack now";
943 for (StateStack::const_iterator i = state_stack_.begin ();
944 i != state_stack_.end (); ++i)
945 *yycdebug_ << ' ' << *i;
946 *yycdebug_ << std::endl;
947 }
948
949 /// Report on the debug stream that the rule \a yyrule is going to be reduced.
950 void
951 yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
952 {
953 unsigned int yylno = rline_[yyrule];
954 /* Print the symbols being reduced, and their result. */
955 *yycdebug_ << "Reducing stack by rule " << n_ - 1
956 << " (line " << yylno << "), ";
957 for (]b4_int_type_for([b4_prhs])[ i = prhs_[n_];
958 0 <= rhs_[i]; ++i)
959 *yycdebug_ << name_[rhs_[i]] << ' ';
960 *yycdebug_ << "-> " << name_[r1_[n_]] << std::endl;
961 }
962 #endif // YYDEBUG
963
964 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
965 yy::]b4_parser_class_name[::TokenNumberType
966 yy::]b4_parser_class_name[::yytranslate_ (int token)
967 {
968 static
969 const TokenNumberType
970 translate_table[] =
971 {
972 ]b4_translate[
973 };
974 if ((unsigned int) token <= user_token_number_max_)
975 return translate_table[token];
976 else
977 return undef_token_;
978 }
979
980 const int yy::]b4_parser_class_name[::eof_ = 0;
981 const int yy::]b4_parser_class_name[::last_ = ]b4_last[;
982 const int yy::]b4_parser_class_name[::nnts_ = ]b4_nterms_number[;
983 const int yy::]b4_parser_class_name[::empty_ = -2;
984 const int yy::]b4_parser_class_name[::final_ = ]b4_final_state_number[;
985 const int yy::]b4_parser_class_name[::terror_ = 1;
986 const int yy::]b4_parser_class_name[::errcode_ = 256;
987 const int yy::]b4_parser_class_name[::ntokens_ = ]b4_tokens_number[;
988
989 const unsigned int yy::]b4_parser_class_name[::user_token_number_max_ = ]b4_user_token_number_max[;
990 const yy::]b4_parser_class_name[::TokenNumberType yy::]b4_parser_class_name[::undef_token_ = ]b4_undef_token_number[;
991
992 ]b4_epilogue
993 dnl
994 @output stack.hh
995 b4_copyright([Stack handling for Bison C++ parsers], [2002, 2003, 2004])[
996
997 #ifndef BISON_STACK_HH
998 # define BISON_STACK_HH
999
1000 #include <deque>
1001
1002 namespace yy
1003 {
1004 template <class T, class S = std::deque<T> >
1005 class Stack
1006 {
1007 public:
1008
1009 // Hide our reversed order.
1010 typedef typename S::reverse_iterator iterator;
1011 typedef typename S::const_reverse_iterator const_iterator;
1012
1013 Stack () : seq_ ()
1014 {
1015 }
1016
1017 Stack (unsigned int n) : seq_ (n)
1018 {
1019 }
1020
1021 inline
1022 T&
1023 operator [] (unsigned int i)
1024 {
1025 return seq_[i];
1026 }
1027
1028 inline
1029 const T&
1030 operator [] (unsigned int i) const
1031 {
1032 return seq_[i];
1033 }
1034
1035 inline
1036 void
1037 push (const T& t)
1038 {
1039 seq_.push_front (t);
1040 }
1041
1042 inline
1043 void
1044 pop (unsigned int n = 1)
1045 {
1046 for (; n; --n)
1047 seq_.pop_front ();
1048 }
1049
1050 inline
1051 unsigned int
1052 height () const
1053 {
1054 return seq_.size ();
1055 }
1056
1057 inline const_iterator begin () const { return seq_.rbegin (); }
1058 inline const_iterator end () const { return seq_.rend (); }
1059
1060 private:
1061
1062 S seq_;
1063 };
1064
1065 template <class T, class S = Stack<T> >
1066 class Slice
1067 {
1068 public:
1069
1070 Slice (const S& stack,
1071 unsigned int range) : stack_ (stack),
1072 range_ (range)
1073 {
1074 }
1075
1076 inline
1077 const T&
1078 operator [] (unsigned int i) const
1079 {
1080 return stack_[range_ - i];
1081 }
1082
1083 private:
1084
1085 const S& stack_;
1086 unsigned int range_;
1087 };
1088 }
1089
1090 #endif // not BISON_STACK_HH]
1091 dnl
1092 @output position.hh
1093 b4_copyright([Position class for Bison C++ parsers], [2002, 2003, 2004])[
1094
1095 /**
1096 ** \file position.hh
1097 ** Define the Location class.
1098 */
1099
1100 #ifndef BISON_POSITION_HH
1101 # define BISON_POSITION_HH
1102
1103 # include <iostream>
1104 # include <string>
1105
1106 namespace yy
1107 {
1108 /// Abstract a Position.
1109 class Position
1110 {
1111 public:
1112 /// Initial column number.
1113 static const unsigned int initial_column = 0;
1114 /// Initial line number.
1115 static const unsigned int initial_line = 1;
1116
1117 /** \name Ctor & dtor.
1118 ** \{ */
1119 public:
1120 /// Construct a Position.
1121 Position () :
1122 filename (),
1123 line (initial_line),
1124 column (initial_column)
1125 {
1126 }
1127 /** \} */
1128
1129
1130 /** \name Line and Column related manipulators
1131 ** \{ */
1132 public:
1133 /// (line related) Advance to the COUNT next lines.
1134 inline void lines (int count = 1)
1135 {
1136 column = initial_column;
1137 line += count;
1138 }
1139
1140 /// (column related) Advance to the COUNT next columns.
1141 inline void columns (int count = 1)
1142 {
1143 int leftmost = initial_column;
1144 int current = column;
1145 if (leftmost <= current + count)
1146 column += count;
1147 else
1148 column = initial_column;
1149 }
1150 /** \} */
1151
1152 public:
1153 /// File name to which this position refers.
1154 std::string filename;
1155 /// Current line number.
1156 unsigned int line;
1157 /// Current column number.
1158 unsigned int column;
1159 };
1160
1161 /// Add and assign a Position.
1162 inline const Position&
1163 operator+= (Position& res, const int width)
1164 {
1165 res.columns (width);
1166 return res;
1167 }
1168
1169 /// Add two Position objects.
1170 inline const Position
1171 operator+ (const Position& begin, const int width)
1172 {
1173 Position res = begin;
1174 return res += width;
1175 }
1176
1177 /// Add and assign a Position.
1178 inline const Position&
1179 operator-= (Position& res, const int width)
1180 {
1181 return res += -width;
1182 }
1183
1184 /// Add two Position objects.
1185 inline const Position
1186 operator- (const Position& begin, const int width)
1187 {
1188 return begin + -width;
1189 }
1190
1191 /** \brief Intercept output stream redirection.
1192 ** \param ostr the destination output stream
1193 ** \param pos a reference to the Position to redirect
1194 */
1195 inline std::ostream&
1196 operator<< (std::ostream& ostr, const Position& pos)
1197 {
1198 if (!pos.filename.empty ())
1199 ostr << pos.filename << ':';
1200 return ostr << pos.line << '.' << pos.column;
1201 }
1202
1203 }
1204 #endif // not BISON_POSITION_HH]
1205 @output location.hh
1206 b4_copyright([Location class for Bison C++ parsers], [2002, 2003, 2004])[
1207
1208 /**
1209 ** \file location.hh
1210 ** Define the Location class.
1211 */
1212
1213 #ifndef BISON_LOCATION_HH
1214 # define BISON_LOCATION_HH
1215
1216 # include <iostream>
1217 # include <string>
1218 # include "position.hh"
1219
1220 namespace yy
1221 {
1222
1223 /// Abstract a Location.
1224 class Location
1225 {
1226 /** \name Ctor & dtor.
1227 ** \{ */
1228 public:
1229 /// Construct a Location.
1230 Location (void) :
1231 begin (),
1232 end ()
1233 {
1234 }
1235 /** \} */
1236
1237
1238 /** \name Line and Column related manipulators
1239 ** \{ */
1240 public:
1241 /// Reset initial location to final location.
1242 inline void step (void)
1243 {
1244 begin = end;
1245 }
1246
1247 /// Extend the current location to the COUNT next columns.
1248 inline void columns (unsigned int count = 1)
1249 {
1250 end += count;
1251 }
1252
1253 /// Extend the current location to the COUNT next lines.
1254 inline void lines (unsigned int count = 1)
1255 {
1256 end.lines (count);
1257 }
1258 /** \} */
1259
1260
1261 public:
1262 /// Beginning of the located region.
1263 Position begin;
1264 /// End of the located region.
1265 Position end;
1266 };
1267
1268 /// Join two Location objects to create a Location.
1269 inline const Location operator+ (const Location& begin, const Location& end)
1270 {
1271 Location res = begin;
1272 res.end = end.end;
1273 return res;
1274 }
1275
1276 /// Add two Location objects.
1277 inline const Location operator+ (const Location& begin, unsigned int width)
1278 {
1279 Location res = begin;
1280 res.columns (width);
1281 return res;
1282 }
1283
1284 /// Add and assign a Location.
1285 inline Location& operator+= (Location& res, unsigned int width)
1286 {
1287 res.columns (width);
1288 return res;
1289 }
1290
1291 /** \brief Intercept output stream redirection.
1292 ** \param ostr the destination output stream
1293 ** \param loc a reference to the Location to redirect
1294 **
1295 ** Avoid duplicate information.
1296 */
1297 inline std::ostream& operator<< (std::ostream& ostr, const Location& loc)
1298 {
1299 Position last = loc.end - 1;
1300 ostr << loc.begin;
1301 if (loc.begin.filename != last.filename)
1302 ostr << '-' << last;
1303 else if (loc.begin.line != last.line)
1304 ostr << '-' << last.line << '.' << last.column;
1305 else if (loc.begin.column != last.column)
1306 ostr << '-' << last.column;
1307 return ostr;
1308 }
1309
1310 }
1311
1312 #endif // not BISON_LOCATION_HH]
bison