data/c++.m4

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