]>
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. | |
5f87211c AD |
179 | inline basic_symbol (typename Base::value_type t]b4_locations_if([, |
180 | const location_type& l])[); | |
1d6b689b | 181 | |
1dbaf37f | 182 | /// Constructor for symbols with semantic value. |
5f87211c AD |
183 | inline basic_symbol (typename Base::value_type t, |
184 | const semantic_type& v]b4_locations_if([, | |
185 | const location_type& l])[); | |
1d6b689b | 186 | |
04816a6f TR |
187 | /// Assignment operator. |
188 | inline basic_symbol& operator= (const basic_symbol& other); | |
189 | ||
5f87211c | 190 | /// Destructive move, \a s is emptied into this. |
1dbaf37f | 191 | inline void move (basic_symbol& s); |
1d6b689b AD |
192 | |
193 | /// The semantic value. | |
194 | semantic_type value;]b4_locations_if([ | |
195 | ||
196 | /// The location. | |
197 | location_type location;])[ | |
198 | }; | |
199 | ||
1dbaf37f TR |
200 | /// Type access provider for token (enum) based symbols. |
201 | struct by_type | |
1d6b689b | 202 | { |
1d6b689b | 203 | /// Default constructor. |
1dbaf37f | 204 | inline by_type (); |
1d6b689b | 205 | |
1dbaf37f TR |
206 | /// Copy constructor. |
207 | inline by_type (const by_type& other); | |
1d6b689b | 208 | |
1dbaf37f TR |
209 | /// Constructor. |
210 | inline by_type (token_type t); | |
1d6b689b AD |
211 | |
212 | /// The symbol type. | |
213 | int type; | |
214 | ||
1dbaf37f TR |
215 | /// The type (corresponding to \a type). |
216 | inline int type_get () const; | |
1d6b689b | 217 | |
2b08bceb | 218 | /// The token. |
1d6b689b | 219 | inline token_type token () const; |
1dbaf37f | 220 | |
5f87211c | 221 | /// The type used to store the symbol type. |
1dbaf37f | 222 | typedef token_type value_type; |
1d6b689b | 223 | }; |
1dbaf37f TR |
224 | |
225 | /// "External" symbols: returned by the scanner. | |
226 | typedef basic_symbol<by_type> symbol_type; | |
227 | ||
0623bacc | 228 | ]b4_symbol_constructor_declare]) |
4f84717d AD |
229 | |
230 | ||
1d6b689b AD |
231 | # b4_public_types_define |
232 | # ---------------------- | |
233 | # Provide the implementation needed by the public types. | |
234 | m4_define([b4_public_types_define], | |
403febca | 235 | [[ inline |
ff601366 AD |
236 | ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m) |
237 | : std::runtime_error (m)]b4_locations_if([ | |
238 | , location (l)])[ | |
239 | {} | |
240 | ||
1dbaf37f TR |
241 | // basic_symbol. |
242 | template <typename Base> | |
1dbaf37f TR |
243 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol () |
244 | : value () | |
245 | {} | |
246 | ]b4_locations_if([ | |
247 | template <typename Base> | |
1dbaf37f TR |
248 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const location_type& l) |
249 | : value () | |
250 | , location (l) | |
251 | {}])[ | |
1d6b689b | 252 | |
04816a6f | 253 | template <typename Base> |
04816a6f | 254 | ]b4_parser_class_name[::basic_symbol<Base>& |
60607adb | 255 | ]b4_parser_class_name[::basic_symbol<Base>::operator= (const basic_symbol&) |
04816a6f TR |
256 | { |
257 | abort (); | |
258 | } | |
259 | ||
1dbaf37f | 260 | template <typename Base> |
1dbaf37f TR |
261 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const basic_symbol& other) |
262 | : Base (other) | |
263 | , value ()]b4_locations_if([ | |
264 | , location (other.location)])[ | |
1d6b689b | 265 | { |
1dbaf37f TR |
266 | ]b4_variant_if([b4_symbol_variant([other.type_get ()], [value], [copy], |
267 | [other.value])], | |
268 | [value = other.value;])[ | |
1d6b689b AD |
269 | } |
270 | ||
1d6b689b | 271 | |
1dbaf37f | 272 | template <typename Base> |
1dbaf37f TR |
273 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join( |
274 | [typename Base::value_type t], | |
275 | [const semantic_type& v], | |
276 | b4_locations_if([const location_type& l]))[) | |
277 | : Base (t) | |
278 | , value ()]b4_locations_if([ | |
279 | , location (l)])[ | |
1d6b689b | 280 | { |
733fb7c5 TR |
281 | // FIXME: The YYUSE macro is only available in the .cc skeleton files. It |
282 | // is not available in .hh files, where this code is when using %defines. | |
283 | (void) v; | |
1dbaf37f TR |
284 | ]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [copy], |
285 | [v])], | |
286 | [value = v;])[ | |
1d6b689b AD |
287 | } |
288 | ||
1dbaf37f | 289 | template <typename Base> |
1dbaf37f TR |
290 | ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join( |
291 | [typename Base::value_type t], | |
292 | b4_locations_if([const location_type& l]))[) | |
293 | : Base (t)]b4_locations_if([ | |
294 | , location (l)])[ | |
295 | {} | |
1d6b689b | 296 | |
1dbaf37f | 297 | template <typename Base> |
1dbaf37f TR |
298 | void |
299 | ]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s) | |
1d6b689b | 300 | { |
1dbaf37f TR |
301 | this->type = s.type_get ();]b4_locations_if([ |
302 | location = s.location;])[ | |
6656c9b5 | 303 | ]b4_variant_if([b4_symbol_variant([s.type_get ()], [value], [move], |
1dbaf37f TR |
304 | [s.value])], |
305 | [value = s.value;])[ | |
1d6b689b AD |
306 | } |
307 | ||
1dbaf37f | 308 | // by_type. |
1dbaf37f TR |
309 | ]b4_parser_class_name[::by_type::by_type () |
310 | : type () | |
311 | {} | |
1d6b689b | 312 | |
1dbaf37f TR |
313 | ]b4_parser_class_name[::by_type::by_type (const by_type& other) |
314 | : type (other.type) | |
315 | {} | |
1d6b689b | 316 | |
1dbaf37f TR |
317 | ]b4_parser_class_name[::by_type::by_type (token_type t) |
318 | : type (yytranslate_ (t)) | |
319 | {} | |
7be08dfb | 320 | |
1d6b689b | 321 | int |
1dbaf37f | 322 | ]b4_parser_class_name[::by_type::type_get () const |
1d6b689b AD |
323 | { |
324 | return type; | |
325 | } | |
e36ec1f4 | 326 | ]b4_token_ctor_if([[ |
1d6b689b | 327 | ]b4_parser_class_name[::token_type |
1dbaf37f | 328 | ]b4_parser_class_name[::by_type::token () const |
1d6b689b AD |
329 | { |
330 | // YYTOKNUM[NUM] -- (External) token number corresponding to the | |
331 | // (internal) symbol number NUM (which must be that of a token). */ | |
332 | static | |
333 | const ]b4_int_type_for([b4_toknum])[ | |
334 | yytoken_number_[] = | |
335 | { | |
336 | ]b4_toknum[ | |
337 | }; | |
338 | return static_cast<token_type> (yytoken_number_[type]); | |
339 | } | |
0623bacc AD |
340 | ]])[]dnl |
341 | b4_symbol_constructor_define]) | |
342 | ||
343 | ||
344 | # b4_symbol_constructor_declare | |
345 | # b4_symbol_constructor_define | |
346 | # ----------------------------- | |
347 | # Declare/define symbol constructors for all the value types. | |
348 | # Use at class-level. Redefined in variant.hh. | |
349 | m4_define([b4_symbol_constructor_declare], []) | |
350 | m4_define([b4_symbol_constructor_define], []) | |
351 | ||
1d6b689b | 352 | |
cbf25ce7 AD |
353 | # b4_yytranslate_define |
354 | # --------------------- | |
355 | # Define yytranslate_. Sometimes used in the header file, | |
356 | # sometimes in the cc file. | |
357 | m4_define([b4_yytranslate_define], | |
358 | [[ // Symbol number corresponding to token number t. | |
359 | ]b4_parser_class_name[::token_number_type | |
e36ec1f4 | 360 | ]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type], |
cbf25ce7 AD |
361 | [int])[ t) |
362 | { | |
363 | static | |
364 | const token_number_type | |
365 | translate_table[] = | |
366 | { | |
367 | ]b4_translate[ | |
368 | }; | |
369 | const unsigned int user_token_number_max_ = ]b4_user_token_number_max[; | |
370 | const token_number_type undef_token_ = ]b4_undef_token_number[; | |
371 | ||
372 | if (static_cast<int>(t) <= yyeof_) | |
373 | return yyeof_; | |
374 | else if (static_cast<unsigned int> (t) <= user_token_number_max_) | |
375 | return translate_table[t]; | |
376 | else | |
377 | return undef_token_; | |
378 | } | |
379 | ]]) | |
380 | ||
1d6b689b | 381 | |
cf147260 AD |
382 | # b4_lhs_value([TYPE]) |
383 | # -------------------- | |
384 | # Expansion of $<TYPE>$. | |
385 | m4_define([b4_lhs_value], | |
1fa5d8bb | 386 | [b4_symbol_value([yyval], [$1])]) |
cf147260 AD |
387 | |
388 | ||
389 | # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) | |
390 | # -------------------------------------- | |
391 | # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH | |
392 | # symbols on RHS. | |
393 | m4_define([b4_rhs_value], | |
1fa5d8bb AD |
394 | [b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])]) |
395 | ||
cf147260 AD |
396 | |
397 | # b4_lhs_location() | |
398 | # ----------------- | |
399 | # Expansion of @$. | |
400 | m4_define([b4_lhs_location], | |
401 | [(yyloc)]) | |
402 | ||
403 | ||
404 | # b4_rhs_location(RULE-LENGTH, NUM) | |
405 | # --------------------------------- | |
406 | # Expansion of @NUM, where the current rule has RULE-LENGTH symbols | |
407 | # on RHS. | |
408 | m4_define([b4_rhs_location], | |
d1ff7a7c | 409 | [(yylocation_stack_@{($1) - ($2)@})]) |
cf147260 AD |
410 | |
411 | ||
412 | # b4_parse_param_decl | |
413 | # ------------------- | |
414 | # Extra formal arguments of the constructor. | |
415 | # Change the parameter names from "foo" into "foo_yyarg", so that | |
416 | # there is no collision bw the user chosen attribute name, and the | |
417 | # argument name in the constructor. | |
418 | m4_define([b4_parse_param_decl], | |
419 | [m4_ifset([b4_parse_param], | |
420 | [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])]) | |
421 | ||
422 | m4_define([b4_parse_param_decl_1], | |
423 | [$1_yyarg]) | |
424 | ||
425 | ||
426 | ||
427 | # b4_parse_param_cons | |
428 | # ------------------- | |
429 | # Extra initialisations of the constructor. | |
430 | m4_define([b4_parse_param_cons], | |
431 | [m4_ifset([b4_parse_param], | |
e9690142 | 432 | [ |
cf147260 AD |
433 | b4_cc_constructor_calls(b4_parse_param)])]) |
434 | m4_define([b4_cc_constructor_calls], | |
e9690142 | 435 | [m4_map_sep([b4_cc_constructor_call], [, |
cf147260 AD |
436 | ], [$@])]) |
437 | m4_define([b4_cc_constructor_call], | |
e9690142 | 438 | [$2 ($2_yyarg)]) |
cf147260 AD |
439 | |
440 | # b4_parse_param_vars | |
441 | # ------------------- | |
442 | # Extra instance variables. | |
443 | m4_define([b4_parse_param_vars], | |
444 | [m4_ifset([b4_parse_param], | |
e9690142 | 445 | [ |
ac826bc4 | 446 | // User arguments. |
cf147260 AD |
447 | b4_cc_var_decls(b4_parse_param)])]) |
448 | m4_define([b4_cc_var_decls], | |
e9690142 | 449 | [m4_map_sep([b4_cc_var_decl], [ |
cf147260 AD |
450 | ], [$@])]) |
451 | m4_define([b4_cc_var_decl], | |
e9690142 | 452 | [ $1;]) |
426903aa AD |
453 | |
454 | ||
455 | ## ---------## | |
456 | ## Values. ## | |
457 | ## ---------## | |
458 | ||
459 | # b4_yylloc_default_define | |
460 | # ------------------------ | |
461 | # Define YYLLOC_DEFAULT. | |
462 | m4_define([b4_yylloc_default_define], | |
463 | [[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. | |
464 | If N is 0, then set CURRENT to the empty location which ends | |
465 | the previous symbol: RHS[0] (always defined). */ | |
466 | ||
467 | # ifndef YYLLOC_DEFAULT | |
468 | # define YYLLOC_DEFAULT(Current, Rhs, N) \ | |
469 | do \ | |
470 | if (N) \ | |
471 | { \ | |
472 | (Current).begin = YYRHSLOC (Rhs, 1).begin; \ | |
473 | (Current).end = YYRHSLOC (Rhs, N).end; \ | |
474 | } \ | |
475 | else \ | |
476 | { \ | |
477 | (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ | |
478 | } \ | |
479 | while (/*CONSTCOND*/ false) | |
480 | # endif | |
481 | ]]) |