data/c++.m4

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