tests: enhance AT_SYNCLINES_COMPILE.
[bison.git] / data / c++.m4
1 -*- Autoconf -*-
2
3 # C++ skeleton for Bison
4
5 # Copyright (C) 2002-2010 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
20 m4_include(b4_pkgdatadir/[c.m4])
21
22 ## ---------------- ##
23 ## Default values. ##
24 ## ---------------- ##
25
26 b4_percent_define_default([[parser_class_name]], [[parser]])
27
28 # Don't do that so that we remember whether we're using a user
29 # request, or the default value.
30 #
31 # b4_percent_define_default([[location_type]], [[location_type]])
32
33 b4_percent_define_default([[filename_type]], [[std::string]])
34 b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix]))
35
36 b4_percent_define_default([[global_tokens_and_yystype]], [[false]])
37 b4_percent_define_default([[define_location_comparison]],
38 [m4_if(b4_percent_define_get([[filename_type]]),
39 [std::string], [[true]], [[false]])])
40
41
42
43 ## ----------- ##
44 ## Namespace. ##
45 ## ----------- ##
46
47 m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])])
48
49
50 # Don't permit an empty b4_namespace_ref. Any `::parser::foo' appended to it
51 # would compile as an absolute reference with `parser' in the global namespace.
52 # b4_namespace_open would open an anonymous namespace and thus establish
53 # internal linkage. This would compile. However, it's cryptic, and internal
54 # linkage for the parser would be specified in all translation units that
55 # include the header, which is always generated. If we ever need to permit
56 # internal linkage somehow, surely we can find a cleaner approach.
57 m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [],
58 [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
59 [[namespace reference is empty]])])
60
61 # Instead of assuming the C++ compiler will do it, Bison should reject any
62 # invalid b4_namepsace_ref that would be converted to a valid
63 # b4_namespace_open. The problem is that Bison doesn't always output
64 # b4_namespace_ref to uncommented code but should reserve the ability to do so
65 # in future releases without risking breaking any existing user grammars.
66 # Specifically, don't allow empty names as b4_namespace_open would just convert
67 # those into anonymous namespaces, and that might tempt some users.
68 m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [],
69 [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
70 [[namespace reference has consecutive "::"]])])
71 m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [],
72 [b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
73 [[namespace reference has a trailing "::"]])])
74
75 m4_define([b4_namespace_open],
76 [b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
77 [namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref),
78 [^\(.\)[ ]*::], [\1])),
79 [::], [ { namespace ])[ {]])])
80
81 m4_define([b4_namespace_close],
82 [b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
83 m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]),
84 [^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*],
85 [\1])),
86 [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])])
87
88
89 # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
90 # -----------------------------------------------------
91 # Output the definition of the tokens as enums.
92 m4_define([b4_token_enums],
93 [/* Tokens. */
94 enum yytokentype {
95 m4_map_sep([ b4_token_enum], [,
96 ],
97 [$@])
98 };
99 ])
100
101
102 ## ----------------- ##
103 ## Semantic Values. ##
104 ## ----------------- ##
105
106 # b4_semantic_type_declare
107 # ------------------------
108 # Declare semantic_type.
109 m4_define([b4_semantic_type_declare],
110 [ /// Symbol semantic values.
111 m4_ifdef([b4_stype],
112 [ union semantic_type
113 {b4_user_stype
114 };],
115 [m4_if(b4_tag_seen_flag, 0,
116 [[ typedef int semantic_type;]],
117 [[ typedef YYSTYPE semantic_type;]])])])
118
119
120 # b4_public_types_declare
121 # -----------------------
122 # Define the public types: token, semantic value, location, and so forth.
123 # Depending on %define token_lex, may be output in the header or source file.
124 m4_define([b4_public_types_declare],
125 [[#ifndef YYSTYPE
126 ]b4_semantic_type_declare[
127 #else
128 typedef YYSTYPE semantic_type;
129 #endif]b4_locations_if([
130 /// Symbol locations.
131 typedef b4_percent_define_get([[location_type]],
132 [[location]]) location_type;])[
133
134 /// Syntax errors thrown from user actions.
135 struct syntax_error : std::runtime_error
136 {
137 syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([
138 location_type location;])[
139 };
140
141 /// Tokens.
142 struct token
143 {
144 ]b4_token_enums(b4_tokens)[
145 };
146
147 /// Token type.
148 typedef token::yytokentype token_type;
149
150 /// A complete symbol, with its type.
151 template <typename Exact>
152 struct symbol_base_type
153 {
154 /// Default constructor.
155 inline symbol_base_type ();
156
157 /// Constructor.]b4_locations_if([
158 inline symbol_base_type (const location_type& l)])[;
159 inline symbol_base_type (]b4_args(
160 [const semantic_type& v],
161 b4_locations_if([const location_type& l]))[);
162
163 /// Return this with its exact type.
164 const Exact& self () const;
165 Exact& self ();
166
167 /// Return the type of this symbol.
168 int type_get () const;
169
170 /// The semantic value.
171 semantic_type value;]b4_locations_if([
172
173 /// The location.
174 location_type location;])[
175 };
176
177 /// External form of a symbol: its type and attributes.
178 struct symbol_type : symbol_base_type<symbol_type>
179 {
180 /// The parent class.
181 typedef symbol_base_type<symbol_type> super_type;
182
183 /// Default constructor.
184 inline symbol_type ();
185
186 /// Constructor for tokens with semantic value.
187 inline symbol_type (]b4_args([token_type t],
188 [const semantic_type& v],
189 b4_locations_if([const location_type& l]))[);
190
191 /// Constructor for valueless tokens.
192 inline symbol_type (]b4_args([token_type t],
193 b4_locations_if([const location_type& l]))[);
194
195 /// The symbol type.
196 int type;
197
198 /// The symbol type.
199 inline int type_get_ () const;
200
201 /// The token.
202 inline token_type token () const;
203 };
204 ]b4_symbol_constructor_declare])
205
206
207 # b4_public_types_define
208 # ----------------------
209 # Provide the implementation needed by the public types.
210 m4_define([b4_public_types_define],
211 [[ inline
212 ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
213 : std::runtime_error (m)]b4_locations_if([
214 , location (l)])[
215 {}
216
217 // symbol_base_type.
218 template <typename Exact>
219 inline
220 ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type ()
221 : value()]b4_locations_if([
222 , location()])[
223 {
224 }]b4_locations_if([[
225
226 template <typename Exact>
227 inline
228 ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const location_type& l)
229 : value()
230 , location(l)
231 {
232 }]])[
233
234 template <typename Exact>
235 inline
236 ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (]b4_args(
237 [const semantic_type& v],
238 b4_locations_if([const location_type& l]))[)
239 : value(v)]b4_locations_if([
240 , location(l)])[
241 {
242 }
243
244 template <typename Exact>
245 inline
246 const Exact&
247 ]b4_parser_class_name[::symbol_base_type<Exact>::self () const
248 {
249 return static_cast<const Exact&>(*this);
250 }
251
252 template <typename Exact>
253 inline
254 Exact&
255 ]b4_parser_class_name[::symbol_base_type<Exact>::self ()
256 {
257 return static_cast<Exact&>(*this);
258 }
259
260 template <typename Exact>
261 inline
262 int
263 ]b4_parser_class_name[::symbol_base_type<Exact>::type_get () const
264 {
265 return self ().type_get_ ();
266 }
267
268 // symbol_type.
269 inline
270 ]b4_parser_class_name[::symbol_type::symbol_type ()
271 : super_type ()
272 , type ()
273 {
274 }
275
276 inline
277 ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
278 [token_type t],
279 b4_locations_if([const location_type& l]))[)
280 : super_type (]b4_locations_if([l])[)
281 , type (yytranslate_ (t))
282 {
283 }
284
285 inline
286 ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
287 [token_type t],
288 [const semantic_type& v],
289 b4_locations_if([const location_type& l]))[)
290 : super_type (v]b4_locations_if([, l])[)
291 , type (yytranslate_ (t))
292 {
293 }
294
295 inline
296 int
297 ]b4_parser_class_name[::symbol_type::type_get_ () const
298 {
299 return type;
300 }
301 ]b4_lex_symbol_if([[
302 inline
303 ]b4_parser_class_name[::token_type
304 ]b4_parser_class_name[::symbol_type::token () const
305 {
306 // YYTOKNUM[NUM] -- (External) token number corresponding to the
307 // (internal) symbol number NUM (which must be that of a token). */
308 static
309 const ]b4_int_type_for([b4_toknum])[
310 yytoken_number_[] =
311 {
312 ]b4_toknum[
313 };
314 return static_cast<token_type> (yytoken_number_[type]);
315 }
316 ]])[]dnl
317 b4_symbol_constructor_define])
318
319
320 # b4_symbol_constructor_declare
321 # b4_symbol_constructor_define
322 # -----------------------------
323 # Declare/define symbol constructors for all the value types.
324 # Use at class-level. Redefined in variant.hh.
325 m4_define([b4_symbol_constructor_declare], [])
326 m4_define([b4_symbol_constructor_define], [])
327
328
329 # b4_yytranslate_define
330 # ---------------------
331 # Define yytranslate_. Sometimes used in the header file,
332 # sometimes in the cc file.
333 m4_define([b4_yytranslate_define],
334 [[ // Symbol number corresponding to token number t.
335 ]b4_parser_class_name[::token_number_type
336 ]b4_parser_class_name[::yytranslate_ (]b4_lex_symbol_if([token_type],
337 [int])[ t)
338 {
339 static
340 const token_number_type
341 translate_table[] =
342 {
343 ]b4_translate[
344 };
345 const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
346 const token_number_type undef_token_ = ]b4_undef_token_number[;
347
348 if (static_cast<int>(t) <= yyeof_)
349 return yyeof_;
350 else if (static_cast<unsigned int> (t) <= user_token_number_max_)
351 return translate_table[t];
352 else
353 return undef_token_;
354 }
355 ]])
356
357
358 # b4_lhs_value([TYPE])
359 # --------------------
360 # Expansion of $<TYPE>$.
361 m4_define([b4_lhs_value],
362 [b4_symbol_value([yyval], [$1])])
363
364
365 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
366 # --------------------------------------
367 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
368 # symbols on RHS.
369 m4_define([b4_rhs_value],
370 [b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])])
371
372
373 # b4_lhs_location()
374 # -----------------
375 # Expansion of @$.
376 m4_define([b4_lhs_location],
377 [(yyloc)])
378
379
380 # b4_rhs_location(RULE-LENGTH, NUM)
381 # ---------------------------------
382 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
383 # on RHS.
384 m4_define([b4_rhs_location],
385 [(yylocation_stack_@{($1) - ($2)@})])
386
387
388 # b4_parse_param_decl
389 # -------------------
390 # Extra formal arguments of the constructor.
391 # Change the parameter names from "foo" into "foo_yyarg", so that
392 # there is no collision bw the user chosen attribute name, and the
393 # argument name in the constructor.
394 m4_define([b4_parse_param_decl],
395 [m4_ifset([b4_parse_param],
396 [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
397
398 m4_define([b4_parse_param_decl_1],
399 [$1_yyarg])
400
401
402
403 # b4_parse_param_cons
404 # -------------------
405 # Extra initialisations of the constructor.
406 m4_define([b4_parse_param_cons],
407 [m4_ifset([b4_parse_param],
408 [
409 b4_cc_constructor_calls(b4_parse_param)])])
410 m4_define([b4_cc_constructor_calls],
411 [m4_map_sep([b4_cc_constructor_call], [,
412 ], [$@])])
413 m4_define([b4_cc_constructor_call],
414 [$2 ($2_yyarg)])
415
416 # b4_parse_param_vars
417 # -------------------
418 # Extra instance variables.
419 m4_define([b4_parse_param_vars],
420 [m4_ifset([b4_parse_param],
421 [
422 /* User arguments. */
423 b4_cc_var_decls(b4_parse_param)])])
424 m4_define([b4_cc_var_decls],
425 [m4_map_sep([b4_cc_var_decl], [
426 ], [$@])])
427 m4_define([b4_cc_var_decl],
428 [ $1;])