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