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