data/c++.m4

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