3 # C++ skeleton for Bison
5 # Copyright (C) 2002-2015 Free Software Foundation, Inc.
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.
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.
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/>.
20 # Sanity checks, before defaults installed by c.m4.
21 b4_percent_define_ifdef([[api.value.union.name]],
22 [b4_complain_at(b4_percent_define_get_loc([[api.value.union.name]]),
23 [named %union is invalid in C++])])
25 m4_include(b4_pkgdatadir/[c.m4])
27 # b4_comment(TEXT, [PREFIX])
28 # --------------------------
29 # Put TEXT in comment. Prefix all the output lines with PREFIX.
30 m4_define([b4_comment],
31 [b4_comment_([$1], [$2// ], [$2// ])])
37 b4_percent_define_check_kind([api.namespace], [code], [deprecated])
38 b4_percent_define_check_kind([parser_class_name], [code], [deprecated])
40 ## ---------------- ##
42 ## ---------------- ##
44 b4_percent_define_default([[parser_class_name]], [[parser]])
46 # Don't do that so that we remember whether we're using a user
47 # request, or the default value.
49 # b4_percent_define_default([[api.location.type]], [[location]])
51 b4_percent_define_default([[filename_type]], [[std::string]])
52 # Make it a warning for those who used betas of Bison 3.0.
53 b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix]))
55 b4_percent_define_default([[global_tokens_and_yystype]], [[false]])
56 b4_percent_define_default([[define_location_comparison]],
57 [m4_if(b4_percent_define_get([[filename_type]]),
58 [std::string], [[true]], [[false]])])
66 m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])])
69 # Don't permit an empty b4_namespace_ref. Any '::parser::foo' appended to it
70 # would compile as an absolute reference with 'parser' in the global namespace.
71 # b4_namespace_open would open an anonymous namespace and thus establish
72 # internal linkage. This would compile. However, it's cryptic, and internal
73 # linkage for the parser would be specified in all translation units that
74 # include the header, which is always generated. If we ever need to permit
75 # internal linkage somehow, surely we can find a cleaner approach.
76 m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [],
77 [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
78 [[namespace reference is empty]])])
80 # Instead of assuming the C++ compiler will do it, Bison should reject any
81 # invalid b4_namepsace_ref that would be converted to a valid
82 # b4_namespace_open. The problem is that Bison doesn't always output
83 # b4_namespace_ref to uncommented code but should reserve the ability to do so
84 # in future releases without risking breaking any existing user grammars.
85 # Specifically, don't allow empty names as b4_namespace_open would just convert
86 # those into anonymous namespaces, and that might tempt some users.
87 m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [],
88 [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
89 [[namespace reference has consecutive "::"]])])
90 m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [],
91 [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
92 [[namespace reference has a trailing "::"]])])
94 m4_define([b4_namespace_open],
95 [b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
96 [namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref),
97 [^\(.\)[ ]*::], [\1])),
98 [::], [ { namespace ])[ {]])])
100 m4_define([b4_namespace_close],
101 [b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
102 m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]),
103 [^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*],
105 [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])])
110 # Output the definition of the tokens as enums.
111 m4_define([b4_token_enums],
116 b4_symbol_map([b4_token_enum]))[
123 ## ----------------- ##
124 ## Semantic Values. ##
125 ## ----------------- ##
129 # b4_value_type_declare
130 # ---------------------
131 # Declare semantic_type.
132 m4_define([b4_value_type_declare],
133 [b4_value_type_setup[]dnl
134 [ /// Symbol semantic values.
135 ]m4_bmatch(b4_percent_define_get_kind([[api.value.type]]),
137 [[ typedef ]b4_percent_define_get([[api.value.type]])[ semantic_type;]],
138 [m4_bmatch(b4_percent_define_get([[api.value.type]]),
139 [union\|union-directive],
140 [[ union semantic_type
142 ]b4_user_union_members[
147 # b4_public_types_declare
148 # -----------------------
149 # Define the public types: token, semantic value, location, and so forth.
150 # Depending on %define token_lex, may be output in the header or source file.
151 m4_define([b4_public_types_declare],
152 [[#ifndef ]b4_api_PREFIX[STYPE
153 ]b4_value_type_declare[
155 typedef ]b4_api_PREFIX[STYPE semantic_type;
156 #endif]b4_locations_if([
157 /// Symbol locations.
158 typedef b4_percent_define_get([[api.location.type]],
159 [[location]]) location_type;])[
161 /// Syntax errors thrown from user actions.
162 struct syntax_error : std::runtime_error
164 syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([
165 location_type location;])[
174 /// (External) token type, as returned by yylex.
175 typedef token::yytokentype token_type;
177 /// Internal symbol number.
178 typedef int symbol_number_type;
180 /// Internal symbol number for tokens (subsumed by symbol_number_type).
181 typedef ]b4_int_type_for([b4_translate])[ token_number_type;
183 /// A complete symbol.
185 /// Expects its Base type to provide access to the symbol type
188 /// Provide access to semantic value]b4_locations_if([ and location])[.
189 template <typename Base>
190 struct basic_symbol : Base
193 typedef Base super_type;
195 /// Default constructor.
198 /// Copy constructor.
199 basic_symbol (const basic_symbol& other);
201 /// Constructor for valueless symbols, and symbols from each type.
202 ]b4_type_foreach([b4_basic_symbol_constructor_declare])], [[
203 /// Constructor for valueless symbols.
204 basic_symbol (typename Base::kind_type t]b4_locations_if([,
205 const location_type& l])[);]])[
207 /// Constructor for symbols with semantic value.
208 basic_symbol (typename Base::kind_type t,
209 const semantic_type& v]b4_locations_if([,
210 const location_type& l])[);
212 /// Destroy the symbol.
215 /// Destructive move, \a s is emptied into this.
216 void move (basic_symbol& s);
218 /// The semantic value.
219 semantic_type value;]b4_locations_if([
222 location_type location;])[
225 /// Assignment operator.
226 basic_symbol& operator= (const basic_symbol& other);
229 /// Type access provider for token (enum) based symbols.
232 /// Default constructor.
235 /// Copy constructor.
236 by_type (const by_type& other);
238 /// The symbol type as needed by the constructor.
239 typedef token_type kind_type;
241 /// Constructor from (external) token numbers.
242 by_type (kind_type t);
244 /// Steal the symbol type from \a that.
245 void move (by_type& that);
247 /// The (internal) type number (corresponding to \a type).
248 /// \a empty when empty.
249 symbol_number_type type_get () const;
252 token_type token () const;
254 /// The type number used to denote an empty symbol.
258 /// \a empty when empty.
259 token_number_type type;
262 /// "External" symbols: returned by the scanner.
263 typedef basic_symbol<by_type> symbol_type;
265 ]b4_symbol_constructor_declare])
268 # b4_public_types_define
269 # ----------------------
270 # Provide the implementation needed by the public types.
271 m4_define([b4_public_types_define],
273 ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
274 : std::runtime_error (m)]b4_locations_if([
279 template <typename Base>
281 ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
285 template <typename Base>
287 ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const basic_symbol& other)
289 , value ()]b4_locations_if([
290 , location (other.location)])[
292 ]b4_variant_if([b4_symbol_variant([other.type_get ()], [value], [copy],
294 [value = other.value;])[
298 template <typename Base>
300 ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
301 [typename Base::kind_type t],
302 [const semantic_type& v],
303 b4_locations_if([const location_type& l]))[)
305 , value (]b4_variant_if([], [v])[)]b4_locations_if([
309 ]b4_symbol_variant([this->type_get ()], [value], [copy], [v])])[}
312 // Implementation of basic_symbol constructor for each type.
313 ]b4_type_foreach([b4_basic_symbol_constructor_define])], [[
314 /// Constructor for valueless symbols.
315 template <typename Base>
317 ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
318 [typename Base::kind_type t],
319 b4_locations_if([const location_type& l]))[)
321 , value ()]b4_locations_if([
325 template <typename Base>
327 ]b4_parser_class_name[::basic_symbol<Base>::~basic_symbol ()
330 symbol_number_type yytype = this->type_get ();
333 ]b4_symbol_foreach([b4_symbol_destructor])dnl
339 ]b4_symbol_variant([[yytype]], [[value]], [[template destroy]])])[
342 template <typename Base>
345 ]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s)
348 ]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [move],
350 [value = s.value;])[]b4_locations_if([
351 location = s.location;])[
356 ]b4_parser_class_name[::by_type::by_type ()
361 ]b4_parser_class_name[::by_type::by_type (const by_type& other)
366 ]b4_parser_class_name[::by_type::by_type (token_type t)
367 : type (yytranslate_ (t))
372 ]b4_parser_class_name[::by_type::move (by_type& that)
380 ]b4_parser_class_name[::by_type::type_get () const
386 ]b4_parser_class_name[::token_type
387 ]b4_parser_class_name[::by_type::token () const
389 // YYTOKNUM[NUM] -- (External) token number corresponding to the
390 // (internal) symbol number NUM (which must be that of a token). */
392 const ]b4_int_type_for([b4_toknum])[
397 return static_cast<token_type> (yytoken_number_[type]);
400 b4_symbol_constructor_define])
403 # b4_symbol_constructor_declare
404 # b4_symbol_constructor_define
405 # -----------------------------
406 # Declare/define symbol constructors for all the value types.
407 # Use at class-level. Redefined in variant.hh.
408 m4_define([b4_symbol_constructor_declare], [])
409 m4_define([b4_symbol_constructor_define], [])
412 # b4_yytranslate_define
413 # ---------------------
414 # Define yytranslate_. Sometimes used in the header file,
415 # sometimes in the cc file.
416 m4_define([b4_yytranslate_define],
417 [[ // Symbol number corresponding to token number t.
419 ]b4_parser_class_name[::token_number_type
420 ]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type],
424 const token_number_type
429 const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
430 const token_number_type undef_token_ = ]b4_undef_token_number[;
432 if (static_cast<int>(t) <= yyeof_)
434 else if (static_cast<unsigned int> (t) <= user_token_number_max_)
435 return translate_table[t];
442 # b4_lhs_value([TYPE])
443 # --------------------
444 # Expansion of $<TYPE>$.
445 m4_define([b4_lhs_value],
446 [b4_symbol_value([yyval], [$1])])
449 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
450 # --------------------------------------
451 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
453 m4_define([b4_rhs_value],
454 [b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])])
460 m4_define([b4_lhs_location],
464 # b4_rhs_location(RULE-LENGTH, NUM)
465 # ---------------------------------
466 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
468 m4_define([b4_rhs_location],
469 [(yylocation_stack_@{($1) - ($2)@})])
472 # b4_parse_param_decl
473 # -------------------
474 # Extra formal arguments of the constructor.
475 # Change the parameter names from "foo" into "foo_yyarg", so that
476 # there is no collision bw the user chosen attribute name, and the
477 # argument name in the constructor.
478 m4_define([b4_parse_param_decl],
479 [m4_ifset([b4_parse_param],
480 [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
482 m4_define([b4_parse_param_decl_1],
487 # b4_parse_param_cons
488 # -------------------
489 # Extra initialisations of the constructor.
490 m4_define([b4_parse_param_cons],
491 [m4_ifset([b4_parse_param],
493 b4_cc_constructor_calls(b4_parse_param)])])
494 m4_define([b4_cc_constructor_calls],
495 [m4_map_sep([b4_cc_constructor_call], [,
497 m4_define([b4_cc_constructor_call],
500 # b4_parse_param_vars
501 # -------------------
502 # Extra instance variables.
503 m4_define([b4_parse_param_vars],
504 [m4_ifset([b4_parse_param],
507 b4_cc_var_decls(b4_parse_param)])])
508 m4_define([b4_cc_var_decls],
509 [m4_map_sep([b4_cc_var_decl], [
511 m4_define([b4_cc_var_decl],
519 # b4_yylloc_default_define
520 # ------------------------
521 # Define YYLLOC_DEFAULT.
522 m4_define([b4_yylloc_default_define],
523 [[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
524 If N is 0, then set CURRENT to the empty location which ends
525 the previous symbol: RHS[0] (always defined). */
527 # ifndef YYLLOC_DEFAULT
528 # define YYLLOC_DEFAULT(Current, Rhs, N) \
532 (Current).begin = YYRHSLOC (Rhs, 1).begin; \
533 (Current).end = YYRHSLOC (Rhs, N).end; \
537 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
539 while (/*CONSTCOND*/ false)
547 b4_token_ctor_if([b4_variant_if([],
548 [b4_fatal_at(b4_percent_define_get_loc(api.token.constructor),
549 [cannot use '%s' without '%s'],
550 [%define api.token.constructor],
551 [%define api.value.type variant]))])])