data/c++.m4

   1                                                             -*- Autoconf -*-
   2
   3 # C++ skeleton for Bison
   4
   5 # Copyright (C) 2002-2012 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 # Default parser class name.
  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([[namespace]], m4_defn([b4_prefix]))
  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 ## Namespace.  ##
  44 ## ----------- ##
  45
  46 m4_define([b4_namespace_ref], [b4_percent_define_get([[namespace]])])
  47
  48 # Don't permit an empty b4_namespace_ref.  Any `::parser::foo' appended to it
  49 # would compile as an absolute reference with `parser' in the global namespace.
  50 # b4_namespace_open would open an anonymous namespace and thus establish
  51 # internal linkage.  This would compile.  However, it's cryptic, and internal
  52 # linkage for the parser would be specified in all translation units that
  53 # include the header, which is always generated.  If we ever need to permit
  54 # internal linkage somehow, surely we can find a cleaner approach.
  55 m4_if(m4_bregexp(b4_namespace_ref, [^[   ]*$]), [-1], [],
  56 [b4_complain_at(b4_percent_define_get_loc([[namespace]]),
  57                 [[namespace reference is empty]])])
  58
  59 # Instead of assuming the C++ compiler will do it, Bison should reject any
  60 # invalid b4_namepsace_ref that would be converted to a valid
  61 # b4_namespace_open.  The problem is that Bison doesn't always output
  62 # b4_namespace_ref to uncommented code but should reserve the ability to do so
  63 # in future releases without risking breaking any existing user grammars.
  64 # Specifically, don't allow empty names as b4_namespace_open would just convert
  65 # those into anonymous namespaces, and that might tempt some users.
  66 m4_if(m4_bregexp(b4_namespace_ref, [::[  ]*::]), [-1], [],
  67 [b4_complain_at(b4_percent_define_get_loc([[namespace]]),
  68                 [[namespace reference has consecutive "::"]])])
  69 m4_if(m4_bregexp(b4_namespace_ref, [::[  ]*$]), [-1], [],
  70 [b4_complain_at(b4_percent_define_get_loc([[namespace]]),
  71                 [[namespace reference has a trailing "::"]])])
  72
  73 m4_define([b4_namespace_open],
  74 [b4_user_code([b4_percent_define_get_syncline([[namespace]])
  75 [namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref),
  76                                                 [^\(.\)[         ]*::], [\1])),
  77                          [::], [ { namespace ])[ {]])])
  78
  79 m4_define([b4_namespace_close],
  80 [b4_user_code([b4_percent_define_get_syncline([[namespace]])
  81 m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]),
  82                                     [^\(.\)[     ]*\(::\)?\([^][:]\|:[^:]\)*],
  83                                     [\1])),
  84              [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])])
  85
  86
  87 # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
  88 # -----------------------------------------------------
  89 # Output the definition of the tokens as enums.
  90 m4_define([b4_token_enums],
  91 [/* Tokens.  */
  92    enum yytokentype {
  93 m4_map_sep([     b4_token_enum], [,
  94 ],
  95            [$@])
  96    };
  97 ])
  98
  99
 100
 101
 102 ## ----------------- ##
 103 ## Semantic Values.  ##
 104 ## ----------------- ##
 105
 106
 107 # b4_lhs_value([TYPE])
 108 # --------------------
 109 # Expansion of $<TYPE>$.
 110 m4_define([b4_lhs_value],
 111 [(yyval[]m4_ifval([$1], [.$1]))])
 112
 113
 114 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
 115 # --------------------------------------
 116 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 117 # symbols on RHS.
 118 m4_define([b4_rhs_value],
 119 [(yysemantic_stack_@{($1) - ($2)@}m4_ifval([$3], [.$3]))])
 120
 121 # b4_lhs_location()
 122 # -----------------
 123 # Expansion of @$.
 124 m4_define([b4_lhs_location],
 125 [(yyloc)])
 126
 127
 128 # b4_rhs_location(RULE-LENGTH, NUM)
 129 # ---------------------------------
 130 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 131 # on RHS.
 132 m4_define([b4_rhs_location],
 133 [(yylocation_stack_@{($1) - ($2)@})])
 134
 135
 136 # b4_parse_param_decl
 137 # -------------------
 138 # Extra formal arguments of the constructor.
 139 # Change the parameter names from "foo" into "foo_yyarg", so that
 140 # there is no collision bw the user chosen attribute name, and the
 141 # argument name in the constructor.
 142 m4_define([b4_parse_param_decl],
 143 [m4_ifset([b4_parse_param],
 144           [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
 145
 146 m4_define([b4_parse_param_decl_1],
 147 [$1_yyarg])
 148
 149
 150
 151 # b4_parse_param_cons
 152 # -------------------
 153 # Extra initialisations of the constructor.
 154 m4_define([b4_parse_param_cons],
 155           [m4_ifset([b4_parse_param],
 156                     [
 157       b4_cc_constructor_calls(b4_parse_param)])])
 158 m4_define([b4_cc_constructor_calls],
 159           [m4_map_sep([b4_cc_constructor_call], [,
 160       ], [$@])])
 161 m4_define([b4_cc_constructor_call],
 162           [$2 ($2_yyarg)])
 163
 164 # b4_parse_param_vars
 165 # -------------------
 166 # Extra instance variables.
 167 m4_define([b4_parse_param_vars],
 168           [m4_ifset([b4_parse_param],
 169                     [
 170     /* User arguments.  */
 171 b4_cc_var_decls(b4_parse_param)])])
 172 m4_define([b4_cc_var_decls],
 173           [m4_map_sep([b4_cc_var_decl], [
 174 ], [$@])])
 175 m4_define([b4_cc_var_decl],
 176           [    $1;])
 177
 178
 179 ## ---------##
 180 ## Values.  ##
 181 ## ---------##
 182
 183 # b4_yylloc_default_define
 184 # ------------------------
 185 # Define YYLLOC_DEFAULT.
 186 m4_define([b4_yylloc_default_define],
 187 [[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 188    If N is 0, then set CURRENT to the empty location which ends
 189    the previous symbol: RHS[0] (always defined).  */
 190
 191 # ifndef YYLLOC_DEFAULT
 192 #  define YYLLOC_DEFAULT(Current, Rhs, N)                               \
 193     do                                                                  \
 194       if (N)                                                            \
 195         {                                                               \
 196           (Current).begin  = YYRHSLOC (Rhs, 1).begin;                   \
 197           (Current).end    = YYRHSLOC (Rhs, N).end;                     \
 198         }                                                               \
 199       else                                                              \
 200         {                                                               \
 201           (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end;      \
 202         }                                                               \
 203     while (/*CONSTCOND*/ false)
 204 # endif
 205 ]])