]> git.saurik.com Git - bison.git/blame - data/c++.m4
c++: formatting and comment changes
[bison.git] / data / c++.m4
CommitLineData
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
20m4_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.
25m4_define([b4_comment],
26[b4_comment_([$1], [$2// ], [$2// ])])
27
28
cf147260
AD
29## ---------------- ##
30## Default values. ##
31## ---------------- ##
32
a4e25e1d 33b4_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 40b4_percent_define_default([[filename_type]], [[std::string]])
171ad99d 41b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix]))
67501061 42
c1d19e10 43b4_percent_define_default([[global_tokens_and_yystype]], [[false]])
a4e25e1d
JD
44b4_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
54m4_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.
64m4_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.
75m4_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 "::"]])])
78m4_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
82m4_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
88m4_define([b4_namespace_close],
67501061 89[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
4977e0a7 90m4_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 99m4_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.
118m4_define([b4_semantic_type_declare],
119[ /// Symbol semantic values.
120m4_ifdef([b4_stype],
121[ union semantic_type
d2e3c807
AD
122 {
123b4_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 134m4_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.
234m4_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
341b4_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.
349m4_define([b4_symbol_constructor_declare], [])
350m4_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.
357m4_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>$.
385m4_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.
393m4_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 @$.
400m4_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.
408m4_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.
418m4_define([b4_parse_param_decl],
419[m4_ifset([b4_parse_param],
420 [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
421
422m4_define([b4_parse_param_decl_1],
423[$1_yyarg])
424
425
426
427# b4_parse_param_cons
428# -------------------
429# Extra initialisations of the constructor.
430m4_define([b4_parse_param_cons],
431 [m4_ifset([b4_parse_param],
e9690142 432 [
cf147260
AD
433 b4_cc_constructor_calls(b4_parse_param)])])
434m4_define([b4_cc_constructor_calls],
e9690142 435 [m4_map_sep([b4_cc_constructor_call], [,
cf147260
AD
436 ], [$@])])
437m4_define([b4_cc_constructor_call],
e9690142 438 [$2 ($2_yyarg)])
cf147260
AD
439
440# b4_parse_param_vars
441# -------------------
442# Extra instance variables.
443m4_define([b4_parse_param_vars],
444 [m4_ifset([b4_parse_param],
e9690142 445 [
ac826bc4 446 // User arguments.
cf147260
AD
447b4_cc_var_decls(b4_parse_param)])])
448m4_define([b4_cc_var_decls],
e9690142 449 [m4_map_sep([b4_cc_var_decl], [
cf147260
AD
450], [$@])])
451m4_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.
462m4_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]])