]> git.saurik.com Git - bison.git/blame_incremental - data/c++.m4
glr: formatting changes
[bison.git] / data / c++.m4
... / ...
CommitLineData
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
20m4_include(b4_pkgdatadir/[c.m4])
21
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## -------- ##
29## Checks. ##
30## -------- ##
31
32b4_percent_define_check_kind([api.namespace], [code], [deprecated])
33b4_percent_define_check_kind([parser_class_name], [code], [deprecated])
34
35## ---------------- ##
36## Default values. ##
37## ---------------- ##
38
39b4_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
46b4_percent_define_default([[filename_type]], [[std::string]])
47# Make it a warning for those who used betas of Bison 3.0.
48b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix]))
49
50b4_percent_define_default([[global_tokens_and_yystype]], [[false]])
51b4_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
61m4_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.
71m4_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.
82m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [],
83[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
84 [[namespace reference has consecutive "::"]])])
85m4_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
89m4_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
95m4_define([b4_namespace_close],
96[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
97m4_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.
106m4_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.
127m4_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.
146m4_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.
264m4_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
393b4_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.
401m4_define([b4_symbol_constructor_declare], [])
402m4_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.
409m4_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>$.
438m4_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.
446m4_define([b4_rhs_value],
447[b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])])
448
449
450# b4_lhs_location()
451# -----------------
452# Expansion of @$.
453m4_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.
461m4_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.
471m4_define([b4_parse_param_decl],
472[m4_ifset([b4_parse_param],
473 [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
474
475m4_define([b4_parse_param_decl_1],
476[$1_yyarg])
477
478
479
480# b4_parse_param_cons
481# -------------------
482# Extra initialisations of the constructor.
483m4_define([b4_parse_param_cons],
484 [m4_ifset([b4_parse_param],
485 [
486 b4_cc_constructor_calls(b4_parse_param)])])
487m4_define([b4_cc_constructor_calls],
488 [m4_map_sep([b4_cc_constructor_call], [,
489 ], [$@])])
490m4_define([b4_cc_constructor_call],
491 [$2 ($2_yyarg)])
492
493# b4_parse_param_vars
494# -------------------
495# Extra instance variables.
496m4_define([b4_parse_param_vars],
497 [m4_ifset([b4_parse_param],
498 [
499 // User arguments.
500b4_cc_var_decls(b4_parse_param)])])
501m4_define([b4_cc_var_decls],
502 [m4_map_sep([b4_cc_var_decl], [
503], [$@])])
504m4_define([b4_cc_var_decl],
505 [ $1;])
506
507
508## ---------##
509## Values. ##
510## ---------##
511
512# b4_yylloc_default_define
513# ------------------------
514# Define YYLLOC_DEFAULT.
515m4_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
540b4_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]))])])