]>
Commit | Line | Data |
---|---|---|
1 | -*- Autoconf -*- | |
2 | ||
3 | # C++ skeleton for Bison | |
4 | ||
5 | # Copyright (C) 2002-2013 Free Software Foundation, Inc. | |
6 | ||
7 | # This program is free software: you can redistribute it and/or modify | |
8 | # it under the terms of the GNU General Public License as published by | |
9 | # the Free Software Foundation, either version 3 of the License, or | |
10 | # (at your option) any later version. | |
11 | # | |
12 | # This program is distributed in the hope that it will be useful, | |
13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | # GNU General Public License for more details. | |
16 | # | |
17 | # You should have received a copy of the GNU General Public License | |
18 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
19 | ||
20 | m4_include(b4_pkgdatadir/[c.m4]) | |
21 | ||
22 | # b4_comment(TEXT, [PREFIX]) | |
23 | # -------------------------- | |
24 | # Put TEXT in comment. Prefix all the output lines with PREFIX. | |
25 | m4_define([b4_comment], | |
26 | [b4_comment_([$1], [$2// ], [$2// ])]) | |
27 | ||
28 | ## -------- ## | |
29 | ## Checks. ## | |
30 | ## -------- ## | |
31 | ||
32 | b4_percent_define_check_kind([api.namespace], [code], [deprecated]) | |
33 | b4_percent_define_check_kind([parser_class_name], [code], [deprecated]) | |
34 | ||
35 | ## ---------------- ## | |
36 | ## Default values. ## | |
37 | ## ---------------- ## | |
38 | ||
39 | b4_percent_define_default([[parser_class_name]], [[parser]]) | |
40 | ||
41 | # Don't do that so that we remember whether we're using a user | |
42 | # request, or the default value. | |
43 | # | |
44 | # b4_percent_define_default([[api.location.type]], [[location]]) | |
45 | ||
46 | b4_percent_define_default([[filename_type]], [[std::string]]) | |
47 | # Make it a warning for those who used betas of Bison 3.0. | |
48 | b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix])) | |
49 | ||
50 | b4_percent_define_default([[global_tokens_and_yystype]], [[false]]) | |
51 | b4_percent_define_default([[define_location_comparison]], | |
52 | [m4_if(b4_percent_define_get([[filename_type]]), | |
53 | [std::string], [[true]], [[false]])]) | |
54 | ||
55 | ||
56 | ||
57 | ## ----------- ## | |
58 | ## Namespace. ## | |
59 | ## ----------- ## | |
60 | ||
61 | m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])]) | |
62 | ||
63 | ||
64 | # Don't permit an empty b4_namespace_ref. Any '::parser::foo' appended to it | |
65 | # would compile as an absolute reference with 'parser' in the global namespace. | |
66 | # b4_namespace_open would open an anonymous namespace and thus establish | |
67 | # internal linkage. This would compile. However, it's cryptic, and internal | |
68 | # linkage for the parser would be specified in all translation units that | |
69 | # include the header, which is always generated. If we ever need to permit | |
70 | # internal linkage somehow, surely we can find a cleaner approach. | |
71 | m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [], | |
72 | [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), | |
73 | [[namespace reference is empty]])]) | |
74 | ||
75 | # Instead of assuming the C++ compiler will do it, Bison should reject any | |
76 | # invalid b4_namepsace_ref that would be converted to a valid | |
77 | # b4_namespace_open. The problem is that Bison doesn't always output | |
78 | # b4_namespace_ref to uncommented code but should reserve the ability to do so | |
79 | # in future releases without risking breaking any existing user grammars. | |
80 | # Specifically, don't allow empty names as b4_namespace_open would just convert | |
81 | # those into anonymous namespaces, and that might tempt some users. | |
82 | m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [], | |
83 | [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), | |
84 | [[namespace reference has consecutive "::"]])]) | |
85 | m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [], | |
86 | [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), | |
87 | [[namespace reference has a trailing "::"]])]) | |
88 | ||
89 | m4_define([b4_namespace_open], | |
90 | [b4_user_code([b4_percent_define_get_syncline([[api.namespace]]) | |
91 | [namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref), | |
92 | [^\(.\)[ ]*::], [\1])), | |
93 | [::], [ { namespace ])[ {]])]) | |
94 | ||
95 | m4_define([b4_namespace_close], | |
96 | [b4_user_code([b4_percent_define_get_syncline([[api.namespace]]) | |
97 | m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]), | |
98 | [^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*], | |
99 | [\1])), | |
100 | [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])]) | |
101 | ||
102 | ||
103 | # b4_token_enums | |
104 | # -------------- | |
105 | # Output the definition of the tokens as enums. | |
106 | m4_define([b4_token_enums], | |
107 | [[enum yytokentype | |
108 | { | |
109 | ]m4_join([, | |
110 | ], | |
111 | b4_symbol_map([b4_token_enum]))[ | |
112 | };]dnl | |
113 | ]) | |
114 | ||
115 | ||
116 | ||
117 | ||
118 | ## ----------------- ## | |
119 | ## Semantic Values. ## | |
120 | ## ----------------- ## | |
121 | ||
122 | ||
123 | ||
124 | # b4_value_type_declare | |
125 | # --------------------- | |
126 | # Declare semantic_type. | |
127 | m4_define([b4_value_type_declare], | |
128 | [b4_value_type_setup[]dnl | |
129 | [ /// Symbol semantic values. | |
130 | ]m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), | |
131 | [code], | |
132 | [[ typedef ]b4_percent_define_get([[api.value.type]])[ semantic_type;]], | |
133 | [m4_bmatch(b4_percent_define_get([[api.value.type]]), | |
134 | [union\|union-directive], | |
135 | [[ union semantic_type | |
136 | { | |
137 | ]b4_user_union_members[ | |
138 | };]])])dnl | |
139 | ]) | |
140 | ||
141 | ||
142 | # b4_public_types_declare | |
143 | # ----------------------- | |
144 | # Define the public types: token, semantic value, location, and so forth. | |
145 | # Depending on %define token_lex, may be output in the header or source file. | |
146 | m4_define([b4_public_types_declare], | |
147 | [[#ifndef ]b4_api_PREFIX[STYPE | |
148 | ]b4_value_type_declare[ | |
149 | #else | |
150 | typedef ]b4_api_PREFIX[STYPE semantic_type; | |
151 | #endif]b4_locations_if([ | |
152 | /// Symbol locations. | |
153 | typedef b4_percent_define_get([[api.location.type]], | |
154 | [[location]]) location_type;])[ | |
155 | ||
156 | /// Syntax errors thrown from user actions. | |
157 | struct syntax_error : std::runtime_error | |
158 | { | |
159 | syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([ | |
160 | location_type location;])[ | |
161 | }; | |
162 | ||
163 | /// Tokens. | |
164 | struct token | |
165 | { | |
166 | ]b4_token_enums[ | |
167 | }; | |
168 | ||
169 | /// (External) token type, as returned by yylex. | |
170 | typedef token::yytokentype token_type; | |
171 | ||
172 | /// Internal symbol number. | |
173 | typedef int symbol_number_type; | |
174 | ||
175 | /// Internal symbol number for tokens (subsumed by symbol_number_type). | |
176 | typedef ]b4_int_type_for([b4_translate])[ token_number_type; | |
177 | ||
178 | /// A complete symbol. | |
179 | /// | |
180 | /// Expects its Base type to provide access to the symbol type | |
181 | /// via type_get(). | |
182 | /// | |
183 | /// Provide access to semantic value]b4_locations_if([ and location])[. | |
184 | template <typename Base> | |
185 | struct basic_symbol : Base | |
186 | { | |
187 | /// Alias to Base. | |
188 | typedef Base super_type; | |
189 | ||
190 | /// Default constructor. | |
191 | basic_symbol (); | |
192 | ||
193 | /// Copy constructor. | |
194 | basic_symbol (const basic_symbol& other); | |
195 | ]b4_variant_if([[ | |
196 | /// Constructor for valueless symbols, and symbols from each type. | |
197 | ]b4_type_foreach([b4_basic_symbol_constructor_declare])], [[ | |
198 | /// Constructor for valueless symbols. | |
199 | basic_symbol (typename Base::kind_type t]b4_locations_if([, | |
200 | const location_type& l])[);]])[ | |
201 | ||
202 | /// Constructor for symbols with semantic value. | |
203 | basic_symbol (typename Base::kind_type t, | |
204 | const semantic_type& v]b4_locations_if([, | |
205 | const location_type& l])[); | |
206 | ||
207 | ~basic_symbol (); | |
208 | ||
209 | /// Destructive move, \a s is emptied into this. | |
210 | void move (basic_symbol& s); | |
211 | ||
212 | /// The semantic value. | |
213 | semantic_type value;]b4_locations_if([ | |
214 | ||
215 | /// The location. | |
216 | location_type location;])[ | |
217 | ||
218 | private: | |
219 | /// Assignment operator. | |
220 | basic_symbol& operator= (const basic_symbol& other); | |
221 | }; | |
222 | ||
223 | /// Type access provider for token (enum) based symbols. | |
224 | struct by_type | |
225 | { | |
226 | /// Default constructor. | |
227 | by_type (); | |
228 | ||
229 | /// Copy constructor. | |
230 | by_type (const by_type& other); | |
231 | ||
232 | /// The symbol type as needed by the constructor. | |
233 | typedef token_type kind_type; | |
234 | ||
235 | /// Constructor from (external) token numbers. | |
236 | by_type (kind_type t); | |
237 | ||
238 | /// Steal the symbol type from \a that. | |
239 | void move (by_type& that); | |
240 | ||
241 | /// The (internal) type number (corresponding to \a type). | |
242 | /// -1 when this symbol is empty. | |
243 | symbol_number_type type_get () const; | |
244 | ||
245 | /// The token. | |
246 | token_type token () const; | |
247 | ||
248 | enum { empty = 0 }; | |
249 | ||
250 | /// The symbol type. | |
251 | /// -1 when this symbol is empty. | |
252 | token_number_type type; | |
253 | }; | |
254 | ||
255 | /// "External" symbols: returned by the scanner. | |
256 | typedef basic_symbol<by_type> symbol_type; | |
257 | ||
258 | ]b4_symbol_constructor_declare]) | |
259 | ||
260 | ||
261 | # b4_public_types_define | |
262 | # ---------------------- | |
263 | # Provide the implementation needed by the public types. | |
264 | m4_define([b4_public_types_define], | |
265 | [[ inline | |
266 | ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m) | |
267 | : std::runtime_error (m)]b4_locations_if([ | |
268 | , location (l)])[ | |
269 | {} | |
270 | ||
271 | // basic_symbol. | |
272 | template <typename Base> | |
273 | inline | |
274 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol () | |
275 | : value () | |
276 | {} | |
277 | ||
278 | template <typename Base> | |
279 | inline | |
280 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const basic_symbol& other) | |
281 | : Base (other) | |
282 | , value ()]b4_locations_if([ | |
283 | , location (other.location)])[ | |
284 | { | |
285 | ]b4_variant_if([b4_symbol_variant([other.type_get ()], [value], [copy], | |
286 | [other.value])], | |
287 | [value = other.value;])[ | |
288 | } | |
289 | ||
290 | ||
291 | template <typename Base> | |
292 | inline | |
293 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join( | |
294 | [typename Base::kind_type t], | |
295 | [const semantic_type& v], | |
296 | b4_locations_if([const location_type& l]))[) | |
297 | : Base (t) | |
298 | , value (]b4_variant_if([], [v])[)]b4_locations_if([ | |
299 | , location (l)])[ | |
300 | {]b4_variant_if([[ | |
301 | (void) v; | |
302 | ]b4_symbol_variant([this->type_get ()], [value], [copy], [v])])[} | |
303 | ||
304 | ]b4_variant_if([[ | |
305 | // Implementation of basic_symbol constructor for each type. | |
306 | ]b4_type_foreach([b4_basic_symbol_constructor_define])], [[ | |
307 | /// Constructor for valueless symbols. | |
308 | template <typename Base> | |
309 | inline | |
310 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join( | |
311 | [typename Base::kind_type t], | |
312 | b4_locations_if([const location_type& l]))[) | |
313 | : Base (t) | |
314 | , value ()]b4_locations_if([ | |
315 | , location (l)])[ | |
316 | {}]])[ | |
317 | ||
318 | template <typename Base> | |
319 | inline | |
320 | ]b4_parser_class_name[::basic_symbol<Base>::~basic_symbol () | |
321 | {]b4_variant_if([[ | |
322 | // User destructor. | |
323 | symbol_number_type yytype = this->type_get (); | |
324 | switch (yytype) | |
325 | { | |
326 | ]b4_symbol_foreach([b4_symbol_destructor])dnl | |
327 | [ default: | |
328 | break; | |
329 | } | |
330 | ||
331 | // Type destructor. | |
332 | ]b4_symbol_variant([[yytype]], [[value]], [[template destroy]])])[ | |
333 | } | |
334 | ||
335 | template <typename Base> | |
336 | inline | |
337 | void | |
338 | ]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s) | |
339 | { | |
340 | super_type::move(s); | |
341 | ]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [move], | |
342 | [s.value])], | |
343 | [value = s.value;])[]b4_locations_if([ | |
344 | location = s.location;])[ | |
345 | } | |
346 | ||
347 | // by_type. | |
348 | inline | |
349 | ]b4_parser_class_name[::by_type::by_type () | |
350 | : type (empty) | |
351 | {} | |
352 | ||
353 | inline | |
354 | ]b4_parser_class_name[::by_type::by_type (const by_type& other) | |
355 | : type (other.type) | |
356 | {} | |
357 | ||
358 | inline | |
359 | ]b4_parser_class_name[::by_type::by_type (token_type t) | |
360 | : type (yytranslate_ (t)) | |
361 | {} | |
362 | ||
363 | inline | |
364 | void | |
365 | ]b4_parser_class_name[::by_type::move (by_type& that) | |
366 | { | |
367 | type = that.type; | |
368 | that.type = empty; | |
369 | } | |
370 | ||
371 | inline | |
372 | int | |
373 | ]b4_parser_class_name[::by_type::type_get () const | |
374 | { | |
375 | return type; | |
376 | } | |
377 | ]b4_token_ctor_if([[ | |
378 | inline | |
379 | ]b4_parser_class_name[::token_type | |
380 | ]b4_parser_class_name[::by_type::token () const | |
381 | { | |
382 | // YYTOKNUM[NUM] -- (External) token number corresponding to the | |
383 | // (internal) symbol number NUM (which must be that of a token). */ | |
384 | static | |
385 | const ]b4_int_type_for([b4_toknum])[ | |
386 | yytoken_number_[] = | |
387 | { | |
388 | ]b4_toknum[ | |
389 | }; | |
390 | return static_cast<token_type> (yytoken_number_[type]); | |
391 | } | |
392 | ]])[]dnl | |
393 | b4_symbol_constructor_define]) | |
394 | ||
395 | ||
396 | # b4_symbol_constructor_declare | |
397 | # b4_symbol_constructor_define | |
398 | # ----------------------------- | |
399 | # Declare/define symbol constructors for all the value types. | |
400 | # Use at class-level. Redefined in variant.hh. | |
401 | m4_define([b4_symbol_constructor_declare], []) | |
402 | m4_define([b4_symbol_constructor_define], []) | |
403 | ||
404 | ||
405 | # b4_yytranslate_define | |
406 | # --------------------- | |
407 | # Define yytranslate_. Sometimes used in the header file, | |
408 | # sometimes in the cc file. | |
409 | m4_define([b4_yytranslate_define], | |
410 | [[ // Symbol number corresponding to token number t. | |
411 | inline | |
412 | ]b4_parser_class_name[::token_number_type | |
413 | ]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type], | |
414 | [int])[ t) | |
415 | { | |
416 | static | |
417 | const token_number_type | |
418 | translate_table[] = | |
419 | { | |
420 | ]b4_translate[ | |
421 | }; | |
422 | const unsigned int user_token_number_max_ = ]b4_user_token_number_max[; | |
423 | const token_number_type undef_token_ = ]b4_undef_token_number[; | |
424 | ||
425 | if (static_cast<int>(t) <= yyeof_) | |
426 | return yyeof_; | |
427 | else if (static_cast<unsigned int> (t) <= user_token_number_max_) | |
428 | return translate_table[t]; | |
429 | else | |
430 | return undef_token_; | |
431 | } | |
432 | ]]) | |
433 | ||
434 | ||
435 | # b4_lhs_value([TYPE]) | |
436 | # -------------------- | |
437 | # Expansion of $<TYPE>$. | |
438 | m4_define([b4_lhs_value], | |
439 | [b4_symbol_value([yyval], [$1])]) | |
440 | ||
441 | ||
442 | # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) | |
443 | # -------------------------------------- | |
444 | # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH | |
445 | # symbols on RHS. | |
446 | m4_define([b4_rhs_value], | |
447 | [b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])]) | |
448 | ||
449 | ||
450 | # b4_lhs_location() | |
451 | # ----------------- | |
452 | # Expansion of @$. | |
453 | m4_define([b4_lhs_location], | |
454 | [(yyloc)]) | |
455 | ||
456 | ||
457 | # b4_rhs_location(RULE-LENGTH, NUM) | |
458 | # --------------------------------- | |
459 | # Expansion of @NUM, where the current rule has RULE-LENGTH symbols | |
460 | # on RHS. | |
461 | m4_define([b4_rhs_location], | |
462 | [(yylocation_stack_@{($1) - ($2)@})]) | |
463 | ||
464 | ||
465 | # b4_parse_param_decl | |
466 | # ------------------- | |
467 | # Extra formal arguments of the constructor. | |
468 | # Change the parameter names from "foo" into "foo_yyarg", so that | |
469 | # there is no collision bw the user chosen attribute name, and the | |
470 | # argument name in the constructor. | |
471 | m4_define([b4_parse_param_decl], | |
472 | [m4_ifset([b4_parse_param], | |
473 | [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])]) | |
474 | ||
475 | m4_define([b4_parse_param_decl_1], | |
476 | [$1_yyarg]) | |
477 | ||
478 | ||
479 | ||
480 | # b4_parse_param_cons | |
481 | # ------------------- | |
482 | # Extra initialisations of the constructor. | |
483 | m4_define([b4_parse_param_cons], | |
484 | [m4_ifset([b4_parse_param], | |
485 | [ | |
486 | b4_cc_constructor_calls(b4_parse_param)])]) | |
487 | m4_define([b4_cc_constructor_calls], | |
488 | [m4_map_sep([b4_cc_constructor_call], [, | |
489 | ], [$@])]) | |
490 | m4_define([b4_cc_constructor_call], | |
491 | [$2 ($2_yyarg)]) | |
492 | ||
493 | # b4_parse_param_vars | |
494 | # ------------------- | |
495 | # Extra instance variables. | |
496 | m4_define([b4_parse_param_vars], | |
497 | [m4_ifset([b4_parse_param], | |
498 | [ | |
499 | // User arguments. | |
500 | b4_cc_var_decls(b4_parse_param)])]) | |
501 | m4_define([b4_cc_var_decls], | |
502 | [m4_map_sep([b4_cc_var_decl], [ | |
503 | ], [$@])]) | |
504 | m4_define([b4_cc_var_decl], | |
505 | [ $1;]) | |
506 | ||
507 | ||
508 | ## ---------## | |
509 | ## Values. ## | |
510 | ## ---------## | |
511 | ||
512 | # b4_yylloc_default_define | |
513 | # ------------------------ | |
514 | # Define YYLLOC_DEFAULT. | |
515 | m4_define([b4_yylloc_default_define], | |
516 | [[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. | |
517 | If N is 0, then set CURRENT to the empty location which ends | |
518 | the previous symbol: RHS[0] (always defined). */ | |
519 | ||
520 | # ifndef YYLLOC_DEFAULT | |
521 | # define YYLLOC_DEFAULT(Current, Rhs, N) \ | |
522 | do \ | |
523 | if (N) \ | |
524 | { \ | |
525 | (Current).begin = YYRHSLOC (Rhs, 1).begin; \ | |
526 | (Current).end = YYRHSLOC (Rhs, N).end; \ | |
527 | } \ | |
528 | else \ | |
529 | { \ | |
530 | (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ | |
531 | } \ | |
532 | while (/*CONSTCOND*/ false) | |
533 | # endif | |
534 | ]]) | |
535 | ||
536 | ## -------- ## | |
537 | ## Checks. ## | |
538 | ## -------- ## | |
539 | ||
540 | b4_token_ctor_if([b4_variant_if([], | |
541 | [b4_fatal_at(b4_percent_define_get_loc(api.token.constructor), | |
542 | [cannot use '%s' without '%s'], | |
543 | [%define api.token.constructor], | |
544 | [%define api.value.type variant]))])]) |