Introduce make_symbol.

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index 7a048152ee8d383a0bc50efa143db28b08e0d594..4915caa245f55e49d035c5aa4bc9d9a6361929aa 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -113,6 +113,17 @@ m4_define([b4_symbol],
 [m4_indir([b4_symbol($1, $2)])])
 
 
 [m4_indir([b4_symbol($1, $2)])])
 
 

+# b4_symbol_if(NUM, FIELD, IF-TRUE, IF-FALSE)
+# -------------------------------------------
+# If FIELD about symbol #NUM is 1 expand IF-TRUE, if is 0, expand IF-FALSE.
+# Otherwise an error.
+m4_define([b4_symbol_if],
+[m4_case(b4_symbol([$1], [$2]),
+         [1], [$3],
+         [0], [$4],
+         [m4_fatal([$0: field $2 of $1 is not a Boolean:] b4_symbol([$1], [$2]))])])
+
+

 # b4_symbol_actions(FILENAME, LINENO,
 #                   SYMBOL-TAG, SYMBOL-NUM,
 #                   SYMBOL-ACTION, SYMBOL-TYPENAME)
 # b4_symbol_actions(FILENAME, LINENO,
 #                   SYMBOL-TAG, SYMBOL-NUM,
 #                   SYMBOL-ACTION, SYMBOL-TYPENAME)


@@ -132,19 +143,109 @@ m4_popdef([b4_dollar_dollar])dnl
 ])
 
 
 ])
 
 

-# b4_symbol_action_(NUM)
-# ----------------------
-# Invoke b4_dollar_dollar(SYMBOL_TYPENAME) for each symbol.
-m4_define([b4_symbol_action_],
-[m4_ifval(b4_symbol([$1], [type_name]),
+# b4_symbol_case_(SYMBOL-NUM)
+# ---------------------------
+# Issue a "case NUM" for SYMBOL-NUM.
+m4_define([b4_symbol_case_],

 [      case b4_symbol([$1], [number]): // b4_symbol([$1], [tag])
 [      case b4_symbol([$1], [number]): // b4_symbol([$1], [tag])

+])
+
+
+# b4_type_action_(NUMS)
+# ---------------------
+# Run actions for the symbol NUMS that all have the same type-name.
+# Skip NUMS that have no type-name.
+m4_define([b4_type_action_],
+[b4_symbol_if([$1], [has_type_name],
+[m4_map([b4_symbol_case_], [$@])[]dnl

         b4_dollar_dollar([b4_symbol([$1], [number])],
                          [b4_symbol([$1], [tag])],
                          [b4_symbol([$1], [type_name])]);
        break;
         b4_dollar_dollar([b4_symbol([$1], [number])],
                          [b4_symbol([$1], [tag])],
                          [b4_symbol([$1], [type_name])]);
        break;

+

 ])])
 
 
 ])])
 
 

+# b4_symbol_constructor_declaration_(SYMBOL-NUMBERS)
+# ----------------------------------------------------
+# Declare the overloaded version of make_symbol for the (common) type of
+# these SYMBOL-NUMBERS.  Use at class-level.
+m4_define([b4_symbol_constructor_declaration_],
+[    template <token_type>
+    static inline symbol_type
+    make_symbol (b4_symbol_if([$1], [has_type_name],
+                              [const b4_symbol([$1], [type_name])& v, ])dnl
+const location_type& l);
+
+])
+
+# b4_symbol_constructor_declarations
+# ----------------------------------
+# Declare the overloaded versions of make_symbol for all the value types.
+# Use at class-level.
+m4_define([b4_symbol_constructor_declarations],
+[b4_variant_if([
+    // Declaration of make_symbol for each value type.
+m4_map([b4_symbol_constructor_declaration_], m4_defn([b4_type_names]))])])
+
+
+
+# b4_symbol_constructor_specialization_(SYMBOL-NUMBER)
+# ----------------------------------------------------
+# Declare the specialization of make_symbol for this each SYMBOL-NUMBER.
+# Specializations cannot be declared at class-level, this must be done
+# at namespace-level.
+m4_define([b4_symbol_constructor_specialization_],
+[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [tag_is_id],
+[  template <>
+  inline
+  b4_parser_class_name::symbol_type
+  b4_parser_class_name::make_symbol <b4_parser_class_name::token::b4_symbol([$1], [tag])> (dnl
+b4_symbol_if([$1], [has_type_name],
+             [const b4_symbol([$1], [type_name])& v, ])dnl
+const b4_parser_class_name::location_type& l);
+])])])
+
+# b4_symbol_constructor_specializations
+# -------------------------------------
+# Declare specializations of make_symbol.
+m4_define([b4_symbol_constructor_specializations],
+[b4_variant_if([
+  // Specializations of make_symbol for each symbol type.
+m4_map([b4_symbol_constructor_specialization_],
+       m4_defn([b4_symbol_numbers]))])dnl
+])
+
+
+
+# b4_symbol_constructor_definition_(SYMBOL-NUMBER)
+# ------------------------------------------------
+# Define make_symbol for this SYMBOL-NUMBER.
+m4_define([b4_symbol_constructor_definition_],
+[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [tag_is_id],
+[  template <>
+  b4_parser_class_name::symbol_type
+  b4_parser_class_name::make_symbol <b4_parser_class_name::token::b4_symbol([$1], [tag])> (dnl
+b4_symbol_if([$1], [has_type_name],
+             [const b4_symbol([$1], [type_name])& v, ])dnl
+const location_type& l)
+  {
+    return symbol_type (yytranslate_ (token::b4_symbol([$1], [tag])),dnl
+ b4_symbol_if([$1], [has_type_name], [v, ])l);
+  }
+
+])])])
+
+
+# b4_symbol_constructor_declarations
+# ----------------------------------
+# Define the overloaded versions of make_symbol for all the value types.
+m4_define([b4_symbol_constructor_definitions],
+[b4_variant_if(
+[  // Implementation of make_symbol for each symbol type.
+m4_map([b4_symbol_constructor_definition_], m4_defn([b4_symbol_numbers]))])])
+
+

 # b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
 # ------------------------------------------------
 # Run some ACTION ("build", or "destroy") on YYVAL of symbol type
 # b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
 # ------------------------------------------------
 # Run some ACTION ("build", or "destroy") on YYVAL of symbol type


@@ -154,9 +255,9 @@ m4_define([b4_symbol_variant],
             [$2.$3<$][3>(m4_shift3($@))])dnl
   switch ($1)
     {
             [$2.$3<$][3>(m4_shift3($@))])dnl
   switch ($1)
     {

-m4_map([b4_symbol_action_], m4_defn([b4_symbol_numbers]))
-     default:
-       break;
+m4_map([b4_type_action_], m4_defn([b4_type_names]))[]dnl
+      default:
+        break;

     }
 m4_popdef([b4_dollar_dollar])dnl
 ])
     }
 m4_popdef([b4_dollar_dollar])dnl
 ])


@@ -241,11 +342,12 @@ dnl FIXME: This is wrong, we want computed header guards.
   {]b4_assert_if([
     /// Whether something is contained.
     bool built;
   {]b4_assert_if([
     /// Whether something is contained.
     bool built;

-
-    /// Initially uninitialized.
-    variant ()
-      : built(false)
-    {}])[
+])[
+    /// Empty construction.
+    inline
+    variant ()]b4_assert_if([
+      : built(false)])[
+    {}

 
     /// Instantiate a \a T in here.
     template <typename T>
 
     /// Instantiate a \a T in here.
     template <typename T>


@@ -267,6 +369,15 @@ dnl FIXME: This is wrong, we want computed header guards.
       return *new (buffer) T(t);
     }
 
       return *new (buffer) T(t);
     }
 

+    /// Construct and fill.
+    template <typename T>
+    inline
+    variant (const T& t)]b4_assert_if([
+      : built(true)])[
+    {
+      new (buffer) T(t);
+    }
+

     /// Accessor to a built \a T.
     template <typename T>
     inline T&
     /// Accessor to a built \a T.
     template <typename T>
     inline T&


@@ -489,7 +600,7 @@ m4_ifdef([b4_stype],
 #endif
 
     /// Convert a scanner token number \a t to a symbol number.
 #endif
 
     /// Convert a scanner token number \a t to a symbol number.

-    token_number_type yytranslate_ (int t);
+    static inline token_number_type yytranslate_ (int t);

 
     /// A complete symbol, with its type.
     template <typename Exact>
 
     /// A complete symbol, with its type.
     template <typename Exact>


@@ -499,6 +610,7 @@ m4_ifdef([b4_stype],
       inline symbol_base_type ();
 
       /// Constructor.
       inline symbol_base_type ();
 
       /// Constructor.

+      inline symbol_base_type (const location_type& l);

       inline symbol_base_type (const semantic_type& v, const location_type& l);
 
       /// Return this with its exact type.
       inline symbol_base_type (const semantic_type& v, const location_type& l);
 
       /// Return this with its exact type.


@@ -532,6 +644,7 @@ m4_ifdef([b4_stype],
     inline void yy_destroy_ (const char* yymsg,
                              symbol_base_type<Exact>& yysym) const;
 
     inline void yy_destroy_ (const char* yymsg,
                              symbol_base_type<Exact>& yysym) const;
 

+  public:

     /// Element of the stack: a state and its attributes.
     struct symbol_type : symbol_base_type<symbol_type>
     {
     /// Element of the stack: a state and its attributes.
     struct symbol_type : symbol_base_type<symbol_type>
     {


@@ -545,6 +658,9 @@ m4_ifdef([b4_stype],
       inline symbol_type (int t,
                           const semantic_type& v, const location_type& l);
 
       inline symbol_type (int t,
                           const semantic_type& v, const location_type& l);
 

+      inline symbol_type (int t,
+                          const location_type& l);
+

       /// The symbol type.
       int type;
 
       /// The symbol type.
       int type;
 


@@ -552,6 +668,9 @@ m4_ifdef([b4_stype],
       inline int type_get_ () const;
     };
 
       inline int type_get_ () const;
     };
 

+]b4_symbol_constructor_declarations[
+
+  private:

     /// Element of the stack: a state and its attributes.
     struct stack_symbol_type : symbol_base_type<stack_symbol_type>
     {
     /// Element of the stack: a state and its attributes.
     struct stack_symbol_type : symbol_base_type<stack_symbol_type>
     {


@@ -597,20 +716,21 @@ m4_ifdef([b4_stype],
     inline void yypop_ (unsigned int n = 1);
 
     /* Constants.  */
     inline void yypop_ (unsigned int n = 1);
 
     /* Constants.  */

-    static const int yyeof_;
-    /* LAST_ -- Last index in TABLE_.  */
-    static const int yylast_;
-    static const int yynnts_;
-    static const int yyempty_;
-    static const int yyfinal_;
-    static const int yyterror_;
-    static const int yyerrcode_;
-    static const int yyntokens_;
-    static const unsigned int yyuser_token_number_max_;
-    static const token_number_type yyundef_token_;
+    enum
+    {
+      yyeof_ = 0,
+      yylast_ = ]b4_last[,           //< Last index in yytable_.
+      yynnts_ = ]b4_nterms_number[,  //< Number of nonterminal symbols.
+      yyempty_ = -2,
+      yyfinal_ = ]b4_final_state_number[, //< Termination state number.
+      yyterror_ = 1,
+      yyerrcode_ = 256,
+      yyntokens_ = ]b4_tokens_number[,   //< Number of tokens.
+    };
+

 ]b4_parse_param_vars[
   };
 ]b4_parse_param_vars[
   };

-
+]b4_symbol_constructor_specializations[

 ]b4_namespace_close[
 
 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],
 ]b4_namespace_close[
 
 ]b4_percent_define_flag_if([[global_tokens_and_yystype]],


@@ -772,6 +892,13 @@ b4_percent_code_get[]dnl
   {
   }
 
   {
   }
 

+  template <typename Exact>
+  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const location_type& l)
+    : value()
+    , location(l)
+  {
+  }
+

   template <typename Exact>
   ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const semantic_type& v, const location_type& l)
     : value(v)
   template <typename Exact>
   ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type (const semantic_type& v, const location_type& l)
     : value(v)


@@ -807,6 +934,13 @@ b4_percent_code_get[]dnl
   {
   }
 
   {
   }
 

+  ]b4_parser_class_name[::symbol_type::symbol_type (int t,
+                           const location_type& l)
+    : super_type (l)
+    , type (t)
+  {
+  }
+

   ]b4_parser_class_name[::symbol_type::symbol_type (int t,
                            const semantic_type& v, const location_type& l)
     : super_type (v, l)
   ]b4_parser_class_name[::symbol_type::symbol_type (int t,
                            const semantic_type& v, const location_type& l)
     : super_type (v, l)


@@ -820,6 +954,8 @@ b4_percent_code_get[]dnl
     return type;
   }
 
     return type;
   }
 

+]b4_symbol_constructor_definitions[
+

   // stack_symbol_type.
   ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
     : super_type ()
   // stack_symbol_type.
   ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type ()
     : super_type ()


@@ -860,7 +996,7 @@ b4_percent_code_get[]dnl
       }]b4_variant_if([
 
     // Type destructor.
       }]b4_variant_if([
 
     // Type destructor.

-    b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[
+  b4_symbol_variant([[yytype]], [[yysym.value]], [[template destroy]])])[

   }
 
 #if YYDEBUG
   }
 
 #if YYDEBUG


@@ -875,8 +1011,8 @@ b4_percent_code_get[]dnl
         << yysym.location << ": ";
     switch (yytype)
       {
         << yysym.location << ": ";
     switch (yytype)
       {

-]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
-[       default:
+]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))[
+       default:

          break;
       }
     yyo << ')';
          break;
       }
     yyo << ')';


@@ -1015,7 +1151,6 @@ b4_locations_if([, [[location*], [&yyla.location]]])dnl
 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       }
 
 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       }
 

-

     /* Convert token to internal form.  */
     if (yychar <= yyeof_)
       {
     /* Convert token to internal form.  */
     if (yychar <= yyeof_)
       {


@@ -1096,7 +1231,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     YY_REDUCE_PRINT (yyn);
     switch (yyn)
       {
     YY_REDUCE_PRINT (yyn);
     switch (yyn)
       {

-       ]b4_user_actions[
+]b4_user_actions[

        default:
           break;
       }
        default:
           break;
       }


@@ -1395,26 +1530,17 @@ b4_error_verbose_if([ tok])[)
     const token_number_type
     translate_table[] =
     {
     const token_number_type
     translate_table[] =
     {

-  ]b4_translate[
+]b4_translate[

     };
     };

-    if ((unsigned int) t <= yyuser_token_number_max_)
+    const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
+    const token_number_type undef_token_ = ]b4_undef_token_number[;
+
+    if (static_cast<unsigned int> (t) <= user_token_number_max_)

       return translate_table[t];
     else
       return translate_table[t];
     else

-      return yyundef_token_;
+      return undef_token_;

   }
 
   }
 

-  const int ]b4_parser_class_name[::yyeof_ = 0;
-  const int ]b4_parser_class_name[::yylast_ = ]b4_last[;
-  const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
-  const int ]b4_parser_class_name[::yyempty_ = -2;
-  const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
-  const int ]b4_parser_class_name[::yyterror_ = 1;
-  const int ]b4_parser_class_name[::yyerrcode_ = 256;
-  const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
-
-  const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
-  const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
-

 ]b4_namespace_close[
 
 ]b4_epilogue[]dnl
 ]b4_namespace_close[
 
 ]b4_epilogue[]dnl