lalr1.cc: use state_type.

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index c3678887386728d64805d2ac7217748f958a86b2..2a9316de82cf1720be01c3ff7d9b54be9e864ad6 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -1,6 +1,6 @@
 # C++ skeleton for Bison
 
 # C++ skeleton for Bison
 

-# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009

 # Free Software Foundation, Inc.
 
 # This program is free software: you can redistribute it and/or modify
 # Free Software Foundation, Inc.
 
 # This program is free software: you can redistribute it and/or modify


@@ -18,97 +18,47 @@
 
 m4_include(b4_pkgdatadir/[c++.m4])
 
 
 m4_include(b4_pkgdatadir/[c++.m4])
 

-# b4_subtract(LHS, RHS)
-# ---------------------
-# Evaluate LHS - RHS if they are integer literals, otherwise expand
-# to (LHS) - (RHS).
-m4_define([b4_subtract],
-[m4_bmatch([$1$2], [^[0123456789]*$],
-           [m4_eval([$1 - $2])],
-           [($1) - ($2)])])
-
-
-# b4_args(ARG1, ...)
-# _b4_args(ARG1, ...)
-# -------------------
-# Join with comma, skipping empty arguments.
-# b4_args calls itself recursively until it sees the first non-empty
-# argument, then calls _b4_args which prepends each non-empty argument
-# with a comma.
-m4_define([b4_args],
-[m4_if([$#$1],
-       [1], [],
-       [m4_ifval([$1],
-                 [$1[]_$0(m4_shift($@))],
-                 [$0(m4_shift($@))])])])
-
-# _b4_args(ARGS1, ...)
-# --------------------
-m4_define([_b4_args],
-[m4_if([$#$1],
-       [1], [],
-       [m4_ifval([$1], [, $1])[]$0(m4_shift($@))])])

 
 

+# b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT)
+# --------------------------------------------------------------
+# Declare "parser::yy<TABLE-NAME>_" which contents is CONTENT.
+m4_define([b4_integral_parser_table_declare],
+[m4_ifval([$3], [b4_c_comment([$3], [  ])
+])dnl
+  static const b4_int_type_for([$2]) yy$1_[[]];dnl
+])

 
 

-# b4_table_define(TABLE-NAME, CONTENT)
-# ------------------------------------
+# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
+# ---------------------------------------------

 # Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.
 # Define "parser::yy<TABLE-NAME>_" which contents is CONTENT.

-m4_define([b4_table_define],
-[const b4_int_type_for([$2])
+m4_define([b4_integral_parser_table_define],
+[  const b4_int_type_for([$2])

   b4_parser_class_name::yy$1_[[]] =
   {
   $2
   b4_parser_class_name::yy$1_[[]] =
   {
   $2

-  }dnl
+  };dnl

 ])
 
 ])
 

+

 # b4_symbol_value_template(VAL, [TYPE])
 # -------------------------------------
 # b4_symbol_value_template(VAL, [TYPE])
 # -------------------------------------

-# Same as b4_symbol_value, but used in a template method.
+# Same as b4_symbol_value, but used in a template method.  It makes
+# a difference when using variants.

 m4_copy([b4_symbol_value], [b4_symbol_value_template])
 
 m4_copy([b4_symbol_value], [b4_symbol_value_template])
 

-# How the semantic value is extracted when using variants.
-b4_variant_if([
-  # b4_symbol_value(VAL, [TYPE])
-  # ----------------------------
-  m4_define([b4_symbol_value],
-  [m4_ifval([$2],
-            [$1.as<$2>()],
-            [$1])])
-
-  # b4_symbol_value_template(VAL, [TYPE])
-  # -------------------------------------
-  # Same as b4_symbol_value, but used in a template method.
-  m4_define([b4_symbol_value_template],
-  [m4_ifval([$2],
-            [$1.template as<$2>()],
-            [$1])])
-]) # b4_variant_if
-
-
-# b4_lex_symbol_if([IF-YYLEX-RETURNS-A-COMPLETE-SYMBOL], [IF-NOT])
-# ----------------------------------------------------------------
-m4_define([b4_lex_symbol_if],
-[b4_percent_define_ifdef([[lex_symbol]], [$1], [$2])])
-
-
-# b4_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT])
-# ------------------------------------------------
-m4_define([b4_assert_if],
-[b4_percent_define_ifdef([[assert]], [$1], [$2])])
-

 
 # b4_lhs_value([TYPE])
 # --------------------
 # Expansion of $<TYPE>$.
 m4_define([b4_lhs_value],
 
 # b4_lhs_value([TYPE])
 # --------------------
 # Expansion of $<TYPE>$.
 m4_define([b4_lhs_value],

-[b4_symbol_value([yylhs.value], [$1])])
+          [b4_symbol_value([yylhs.value], [$1])])

 
 
 # b4_lhs_location()
 # -----------------
 # Expansion of @$.
 m4_define([b4_lhs_location],
 
 
 # b4_lhs_location()
 # -----------------
 # Expansion of @$.
 m4_define([b4_lhs_location],

-[yylhs.location])
+          [yylhs.location])

 
 
 # b4_rhs_data(RULE-LENGTH, NUM)
 
 
 # b4_rhs_data(RULE-LENGTH, NUM)


@@ -120,7 +70,7 @@ m4_define([b4_rhs_data],
 
 
 # b4_rhs_state(RULE-LENGTH, NUM)
 
 
 # b4_rhs_state(RULE-LENGTH, NUM)

-# -----------------------------
+# ------------------------------

 # The state corresponding to the symbol #NUM, where the current
 # rule has RULE-LENGTH symbols on RHS.
 m4_define([b4_rhs_state],
 # The state corresponding to the symbol #NUM, where the current
 # rule has RULE-LENGTH symbols on RHS.
 m4_define([b4_rhs_state],


@@ -143,308 +93,30 @@ m4_define([b4_rhs_location],
           [b4_rhs_data([$1], [$2]).location])
 
 
           [b4_rhs_data([$1], [$2]).location])
 
 

-# b4_symbol_(NUM, FIELD)
-# ----------------------
-# Recover a FIELD about symbol #NUM.  Thanks to m4_indir, fails if
-# undefined.
-m4_define([b4_symbol_],
-[m4_indir([b4_symbol($1, $2)])])
-
-
-# b4_symbol(NUM, FIELD)
-# ---------------------
-# Recover a FIELD about symbol #NUM.  Thanks to m4_indir, fails if
-# undefined.  If FIELD = id, prepend the prefix.
-m4_define([b4_symbol],
-[m4_case([$2],
-         [id],    [m4_do([b4_percent_define_get([token.prefix])],
-                         [b4_symbol_([$1], [id])])],
-         [b4_symbol_($@)])])
-
-
-# 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_action(SYMBOL-NUM, KIND)
+# ----------------------------------
+# Run the action KIND (destructor or printer) for SYMBOL-NUM.

 # Same as in C, but using references instead of pointers.
 # Same as in C, but using references instead of pointers.

-m4_define([b4_symbol_actions],
+m4_define([b4_symbol_action],
+[b4_symbol_if([$1], [has_$2],

 [m4_pushdef([b4_dollar_dollar],
 [m4_pushdef([b4_dollar_dollar],

-            [b4_symbol_value_template([yysym.value], [$6])])dnl
+    [b4_symbol_value_template([yysym.value],
+                              b4_symbol_if([$1], [has_type],
+                                           [b4_symbol([$1], [type])]))])dnl

 m4_pushdef([b4_at_dollar], [yysym.location])dnl
 m4_pushdef([b4_at_dollar], [yysym.location])dnl

-      case $4: // $3
-b4_syncline([$2], [$1])
-        $5;
+      b4_symbol_case_([$1])
+b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"])
+        b4_symbol([$1], [$2])

 b4_syncline([@oline@], [@ofile@])
         break;
 b4_syncline([@oline@], [@ofile@])
         break;

-m4_popdef([b4_at_dollar])dnl
-m4_popdef([b4_dollar_dollar])dnl
-])
-
-
-# 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])
-])
-
-
-# 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],
-[m4_map([b4_symbol_case_], [$@])[]dnl
-        b4_dollar_dollar([b4_symbol([$1], [number])],
-                         [b4_symbol([$1], [tag])],
-                         [b4_symbol([$1], [type])]);
-       break;
-
-])])
-
-
-# b4_symbol_constructor_declaration_(SYMBOL-NUMBER)
-# -------------------------------------------------
-# 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_],
-[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
-[    static inline
-    symbol_type
-    make_[]b4_symbol_([$1], [id]) (dnl
-b4_args(b4_symbol_if([$1], [has_type],
-                     [const b4_symbol([$1], [type])& v]),
-        b4_locations_if([const location_type& l])));
-
-])])])
-
-
-# b4_symbol_constructor_declarations
-# ----------------------------------
-# Declare symbol constructors for all the value types.
-# Use at class-level.
-m4_define([b4_symbol_constructor_declarations],
-[b4_variant_if([
-    // Symbol constructors declarations.
-m4_map([b4_symbol_constructor_declaration_], m4_defn([b4_symbol_numbers]))])])
-
-
-
-# b4_symbol_constructor_definition_(SYMBOL-NUMBER)
-# ------------------------------------------------
-# Define symbol constructor for this SYMBOL-NUMBER.
-m4_define([b4_symbol_constructor_definition_],
-[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
-[  b4_parser_class_name::symbol_type
-  b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
-b4_args(b4_symbol_if([$1], [has_type],
-                     [const b4_symbol([$1], [type])& v]),
-        b4_locations_if([const location_type& l])))
-  {
-    return symbol_type (b4_args([yytranslate_ (token::b4_symbol([$1], [id]))],
-                                b4_symbol_if([$1], [has_type], [v]),
-                                b4_locations_if([l])));
-  }
-
-])])])

 
 

-
-# b4_symbol_constructor_definitions
-# ----------------------------------
-# Define the overloaded versions of make_symbol for all the value types.
-m4_define([b4_symbol_constructor_definitions],
-[[  // symbol_base_type.
-  template <typename Exact>
-  ]b4_parser_class_name[::symbol_base_type<Exact>::symbol_base_type ()
-    : value()]b4_locations_if([
-    , location()])[
-  {
-  }]b4_locations_if([[
-
-  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 (]b4_args(
-          [const semantic_type& v],
-          b4_locations_if([const location_type& l]))[)
-    : value(v)]b4_locations_if([
-    , location(l)])[
-  {
-  }
-
-  template <typename Exact>
-  const Exact&
-  ]b4_parser_class_name[::symbol_base_type<Exact>::self () const
-  {
-    return static_cast<const Exact&>(*this);
-  }
-
-  template <typename Exact>
-  Exact&
-  ]b4_parser_class_name[::symbol_base_type<Exact>::self ()
-  {
-    return static_cast<Exact&>(*this);
-  }
-
-  template <typename Exact>
-  int
-  ]b4_parser_class_name[::symbol_base_type<Exact>::type_get () const
-  {
-    return self ().type_get_ ();
-  }
-
-  // symbol_type.
-  ]b4_parser_class_name[::symbol_type::symbol_type ()
-    : super_type ()
-    , type ()
-  {
-  }
-
-  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
-                [int t],
-                b4_locations_if([const location_type& l]))[)
-    : super_type (]b4_locations_if([l])[)
-    , type (t)
-  {
-  }
-
-  ]b4_parser_class_name[::symbol_type::symbol_type (]b4_args(
-                 [int t],
-                 [const semantic_type& v],
-                 b4_locations_if([const location_type& l]))[)
-    : super_type (v]b4_locations_if([, l])[)
-    , type (t)
-  {
-  }
-
-  int
-  ]b4_parser_class_name[::symbol_type::type_get_ () const
-  {
-    return type;
-  }
-]b4_lex_symbol_if([[
-  ]b4_parser_class_name[::token_type
-  ]b4_parser_class_name[::symbol_type::token () const
-  {
-    // YYTOKNUM[NUM] -- (External) token number corresponding to the
-    // (internal) symbol number NUM (which must be that of a token).  */
-    static
-    const ]b4_int_type_for([b4_toknum])[
-    yytoken_number_[] =
-    {
-  ]b4_toknum[
-    };
-    return static_cast<token_type> (yytoken_number_[type]);
-  }
-]])[
-
-]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
-# YYTYPE.
-m4_define([b4_symbol_variant],
-[m4_pushdef([b4_dollar_dollar],
-            [$2.$3<$][3>(m4_shift3($@))])dnl
-  switch ($1)
-    {
-m4_map([b4_type_action_], m4_defn([b4_type_names]))[]dnl
-      default:
-        break;
-    }
+m4_popdef([b4_at_dollar])dnl

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

-])
-
-
-# _b4_char_sizeof_counter
-# -----------------------
-# A counter used by _b4_char_sizeof_dummy to create fresh symbols.
-m4_define([_b4_char_sizeof_counter],
-[0])
-
-# _b4_char_sizeof_dummy
-# ---------------------
-# At each call return a new C++ identifier.
-m4_define([_b4_char_sizeof_dummy],
-[m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl
-dummy[]_b4_char_sizeof_counter])
-
-
-# b4_char_sizeof_(SYMBOL-NUM)
-# ---------------------------
-# A comment describing this symbol.
-m4_define([b4_char_sizeof_],
-[      // b4_symbol([$1], [tag])
-])
-
-# b4_char_sizeof(SYMBOL-NUMS)
-# --------------------------
-# To be mapped on the list of type names to produce:
-#
-#    char dummy1[sizeof(type_name_1)];
-#    char dummy2[sizeof(type_name_2)];
-#
-# for defined type names.
-m4_define([b4_char_sizeof],
-[b4_symbol_if([$1], [has_type],
-[
-m4_map([b4_char_sizeof_], [$@])dnl
-      char _b4_char_sizeof_dummy@{sizeof([b4_symbol([$1], [type])])@};

 ])])
 
 
 ])])
 
 

-# b4_yytranslate_definition
-# -------------------------
-# Define yytranslate_.  Sometimes we want it in the header file,
-# sometimes the cc file suffices.
-m4_define([b4_yytranslate_definition],
-[[  // Symbol number corresponding to token number t.
-  ]b4_parser_class_name[::token_number_type
-  ]b4_parser_class_name[::yytranslate_ (]b4_lex_symbol_if([token_type],
-                                                          [int])[ t)
-  {
-    static
-    const token_number_type
-    translate_table[] =
-    {
-]b4_translate[
-    };
-    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<int>(t) <= yyeof_)
-      return yyeof_;
-    else if (static_cast<unsigned int> (t) <= user_token_number_max_)
-      return translate_table[t];
-    else
-      return undef_token_;
-  }
-]])
-
-

 m4_pushdef([b4_copyright_years],
 m4_pushdef([b4_copyright_years],

-           [2002, 2003, 2004, 2005, 2006, 2007, 2008])
+           [2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009])

 
 m4_define([b4_parser_class_name],
           [b4_percent_define_get([[parser_class_name]])])
 
 m4_define([b4_parser_class_name],
           [b4_percent_define_get([[parser_class_name]])])


@@ -457,6 +129,8 @@ b4_locations_if(
 [# Backward compatibility.
 m4_define([b4_location_constructors])
 m4_include(b4_pkgdatadir/[location.cc])])
 [# Backward compatibility.
 m4_define([b4_location_constructors])
 m4_include(b4_pkgdatadir/[location.cc])])

+m4_include(b4_pkgdatadir/[stack.hh])
+b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])])

 
 # We do want M4 expansion after # for CPP macros.
 m4_changecom()
 
 # We do want M4 expansion after # for CPP macros.
 m4_changecom()


@@ -472,7 +146,7 @@ dnl FIXME: This is wrong, we want computed header guards.
 
 ]b4_percent_code_get([[requires]])[
 
 
 ]b4_percent_code_get([[requires]])[
 

-]b4_assert_if([#include <cassert>])[
+]b4_parse_assert_if([#include <cassert>])[

 #include <string>
 #include <iostream>
 #include "stack.hh"
 #include <string>
 #include <iostream>
 #include "stack.hh"


@@ -480,111 +154,14 @@ dnl FIXME: This is wrong, we want computed header guards.
 ]b4_namespace_open[
 ]b4_locations_if([  class position;
   class location;])[
 ]b4_namespace_open[
 ]b4_locations_if([  class position;
   class location;])[

-]b4_variant_if(
-[[
-  /// A char[S] buffer to store and retrieve objects.
-  ///
-  /// Sort of a variant, but does not keep track of the nature
-  /// of the stored data, since that knowledge is available
-  /// via the current state.
-  template <size_t S>
-  struct variant
-  {]b4_assert_if([
-    /// Whether something is contained.
-    bool built;
-])[
-    /// Empty construction.
-    inline
-    variant ()]b4_assert_if([
-      : built(false)])[
-    {}
-
-    /// Instantiate a \a T in here.
-    template <typename T>
-    inline T&
-    build()
-    {]b4_assert_if([
-      assert(!built);
-      built = true;])[
-      return *new (buffer) T;
-    }
-
-    /// Instantiate a \a T in here from \a t.
-    template <typename T>
-    inline T&
-    build(const T& t)
-    {]b4_assert_if([
-      assert(!built);
-      built = true;])[
-      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&
-    as()
-    {]b4_assert_if([
-      assert(built);])[
-      return reinterpret_cast<T&>(buffer);
-    }
-
-    /// Const accessor to a built \a T (for %printer).
-    template <typename T>
-    inline const T&
-    as() const
-    {]b4_assert_if([
-      assert(built);])[
-      return reinterpret_cast<const T&>(buffer);
-    }
-
-    /// Swap the content with \a other.
-    template <typename T>
-    inline void
-    swap(variant<S>& other)
-    {
-      std::swap(as<T>(), other.as<T>());
-    }
-
-    /// Assign the content of \a other to this.
-    /// Destroys \a other.
-    template <typename T>
-    inline void
-    build(variant<S>& other)
-    {
-      build<T>();
-      swap<T>(other);
-      other.destroy<T>();
-    }
-
-    /// Destroy the stored \a T.
-    template <typename T>
-    inline void
-    destroy()
-    {
-      as<T>().~T();]b4_assert_if([
-      built = false;])[
-    }
-
-    /// A buffer large enough to store any of the semantic values.
-    char buffer[S];
-  };
-]])[
+]b4_variant_if([b4_variant_define])[

 ]b4_namespace_close[
 
 ]b4_locations_if([#include "location.hh"])[
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
 ]b4_namespace_close[
 
 ]b4_locations_if([#include "location.hh"])[
 
 /* Enabling traces.  */
 #ifndef YYDEBUG

-# define YYDEBUG ]b4_debug_flag[
+# define YYDEBUG ]b4_parse_trace_if([1], [0])[

 #endif
 
 /* Enabling verbose error messages.  */
 #endif
 
 /* Enabling verbose error messages.  */


@@ -592,7 +169,7 @@ dnl FIXME: This is wrong, we want computed header guards.
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else

-# define YYERROR_VERBOSE ]b4_error_verbose_flag[
+# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[

 #endif
 
 /* Enabling the token table.  */
 #endif
 
 /* Enabling the token table.  */


@@ -626,35 +203,7 @@ do {                                                            \
   class ]b4_parser_class_name[
   {
   public:
   class ]b4_parser_class_name[
   {
   public:

-#ifndef YYSTYPE
-]b4_variant_if(
-[    /// An auxiliary type to compute the largest semantic type.
-    union union_type
-    {]m4_map([b4_char_sizeof], m4_defn([b4_type_names]))[};
-
-    /// Symbol semantic values.
-    typedef variant<sizeof(union_type)> semantic_type;],
-[    /// Symbol semantic values.
-m4_ifdef([b4_stype],
-[    union semantic_type
-    {b4_user_stype
-    };],
-[m4_if(b4_tag_seen_flag, 0,
-[[    typedef int semantic_type;]],
-[[    typedef YYSTYPE semantic_type;]])])])[
-#else
-    typedef YYSTYPE semantic_type;
-#endif]b4_locations_if([
-    /// Symbol locations.
-    typedef b4_percent_define_get([[location_type]]) location_type;])[
-    /// Tokens.
-    struct token
-    {
-      ]b4_token_enums(b4_tokens)[
-    };
-    /// Token type.
-    typedef token::yytokentype token_type;
-
+]b4_public_types_declare[

     /// Build a parser object.
     ]b4_parser_class_name[ (]b4_parse_param_decl[);
     virtual ~]b4_parser_class_name[ ();
     /// Build a parser object.
     ]b4_parser_class_name[ (]b4_parse_param_decl[);
     virtual ~]b4_parser_class_name[ ();


@@ -677,52 +226,32 @@ m4_ifdef([b4_stype],
     void set_debug_level (debug_level_type l);
 #endif
 
     void set_debug_level (debug_level_type l);
 #endif
 

-  private:

     /// Report a syntax error.]b4_locations_if([
     /// \param loc    where the syntax error is found.])[
     /// \param msg    a description of the syntax error.
     virtual void error (]b4_locations_if([const location_type& loc, ])[const std::string& msg);
 
     /// Report a syntax error.]b4_locations_if([
     /// \param loc    where the syntax error is found.])[
     /// \param msg    a description of the syntax error.
     virtual void error (]b4_locations_if([const location_type& loc, ])[const std::string& msg);
 

-    /// Generate an error message.
-    /// \param state   the state where the error occurred.
-    /// \param tok     the lookahead token.
-    virtual std::string yysyntax_error_ (int yystate, int tok);
-
+  private:

     /// State numbers.
     typedef int state_type;
 
     /// State numbers.
     typedef int state_type;
 

+    /// Generate an error message.
+    /// \param yystate   the state where the error occurred.
+    /// \param yytoken   the lookahead token.
+    virtual std::string yysyntax_error_ (state_type yystate, int yytoken);
+
+    /// Compute post-reduction state.
+    /// \param yystate   the current state
+    /// \param yylhs     the nonterminal to push on the stack
+    state_type yy_lr_goto_state_ (state_type yystate, int yylhs);
+

     /// Internal symbol numbers.
     typedef ]b4_int_type_for([b4_translate])[ token_number_type;
     /// Internal symbol numbers.
     typedef ]b4_int_type_for([b4_translate])[ token_number_type;

-    /* Tables.  */
-    /// For a state, the index in \a yytable_ of its portion.
-    static const ]b4_int_type_for([b4_pact])[ yypact_[];

     static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
     static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;

-
-    /// For a state, default rule to reduce.
-    /// Unless\a  yytable_ specifies something else to do.
-    /// Zero means the default is an error.
-    static const ]b4_int_type_for([b4_defact])[ yydefact_[];
-
-    static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
-    static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
-
-    /// What to do in a state.
-    /// \a yytable_[yypact_[s]]: what to do in state \a s.
-    /// - if positive, shift that token.
-    /// - if negative, reduce the rule which number is the opposite.
-    /// - if zero, do what YYDEFACT says.
-    static const ]b4_int_type_for([b4_table])[ yytable_[];

     static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
 
     static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
 

-    static const ]b4_int_type_for([b4_check])[ yycheck_[];
-
-    /// For a state, its accessing symbol.
-    static const ]b4_int_type_for([b4_stos])[ yystos_[];
-
-    /// For a rule, its LHS.
-    static const ]b4_int_type_for([b4_r1])[ yyr1_[];
-    /// For a rule, its RHS length.
-    static const ]b4_int_type_for([b4_r2])[ yyr2_[];
+    /* Tables.  */
+]b4_parser_tables_declare[

 
 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
     /// For a symbol, its name in clear.
 
 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
     /// For a symbol, its name in clear.


@@ -733,8 +262,8 @@ m4_ifdef([b4_stype],
     static std::string yytnamerr_ (const char *n);])[
 
 #if YYDEBUG
     static std::string yytnamerr_ (const char *n);])[
 
 #if YYDEBUG

-    /// For each rule, its source line number.
-    static const ]b4_int_type_for([b4_rline])[ yyrline_[];
+]b4_integral_parser_table_declare([rline], [b4_rline],
+     [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[

     /// Report on the debug stream that the rule \a r is going to be reduced.
     virtual void yy_reduce_print_ (int r);
     /// Print the state stack on the debug stream.
     /// Report on the debug stream that the rule \a r is going to be reduced.
     virtual void yy_reduce_print_ (int r);
     /// Print the state stack on the debug stream.


@@ -748,33 +277,6 @@ m4_ifdef([b4_stype],
     /// Convert a scanner token number \a t to a symbol number.
     static inline token_number_type yytranslate_ (]b4_lex_symbol_if([token_type], [int])[ t);
 
     /// Convert a scanner token number \a t to a symbol number.
     static inline token_number_type yytranslate_ (]b4_lex_symbol_if([token_type], [int])[ t);
 

-    /// A complete symbol, with its type.
-    template <typename Exact>
-    struct symbol_base_type
-    {
-      /// Default constructor.
-      inline symbol_base_type ();
-
-      /// Constructor.]b4_locations_if([
-      inline symbol_base_type (const location_type& l)])[;
-      inline symbol_base_type (]b4_args(
-        [const semantic_type& v],
-        b4_locations_if([const location_type& l]))[);
-
-      /// Return this with its exact type.
-      const Exact& self () const;
-      Exact& self ();
-
-      /// Return the type of this symbol.
-      int type_get () const;
-
-      /// The semantic value.
-      semantic_type value;]b4_locations_if([
-
-      /// The location.
-      location_type location;])[
-    };
-

 #if YYDEBUG
     /// \brief Display a symbol type, value and location.
     /// \param yyo    The output stream.
 #if YYDEBUG
     /// \brief Display a symbol type, value and location.
     /// \param yyo    The output stream.


@@ -792,36 +294,6 @@ 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>
-    {
-      /// The parent class.
-      typedef symbol_base_type<symbol_type> super_type;
-
-      /// Default constructor.
-      inline symbol_type ();
-
-      /// Constructor.
-      inline symbol_type (]b4_args([int t],
-                                   [const semantic_type& v],
-                                   b4_locations_if([const location_type& l]))[);
-
-      inline symbol_type (]b4_args([int t],
-                                   b4_locations_if([const location_type& l]))[);
-
-      /// The symbol type.
-      int type;
-
-      /// Return the type corresponding to this state.
-      inline int type_get_ () const;
-
-      /// Its token.
-      inline token_type token () 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>
   private:
     /// Element of the stack: a state and its attributes.
     struct stack_symbol_type : symbol_base_type<stack_symbol_type>


@@ -884,8 +356,8 @@ m4_ifdef([b4_stype],
 ]b4_parse_param_vars[
   };
 
 ]b4_parse_param_vars[
   };
 

-]b4_lex_symbol_if([b4_yytranslate_definition])[
-]b4_lex_symbol_if([b4_symbol_constructor_definitions])[
+]b4_lex_symbol_if([b4_yytranslate_define
+b4_public_types_define])[

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


@@ -1035,7 +507,7 @@ b4_percent_code_get[]dnl
   | Symbol types.  |
   `---------------*/
 
   | Symbol types.  |
   `---------------*/
 

-]b4_lex_symbol_if([], [b4_symbol_constructor_definitions])[
+]b4_lex_symbol_if([], [b4_public_types_define])[

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


@@ -1073,9 +545,9 @@ b4_percent_code_get[]dnl
     // User destructor.
     switch (yytype)
       {
     // User destructor.
     switch (yytype)
       {

-]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
-       default:
-         break;
+]b4_symbol_foreach([b4_symbol_destructor])dnl
+[       default:
+          break;

       }]b4_variant_if([
 
     // Type destructor.
       }]b4_variant_if([
 
     // Type destructor.


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

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

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


@@ -1169,6 +641,16 @@ b4_percent_code_get[]dnl
   }
 #endif
 
   }
 #endif
 

+  inline ]b4_parser_class_name[::state_type
+  ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs)
+  {
+    int yyr = yypgoto_[yylhs - yyntokens_] + yystate;
+    if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
+      return yytable_[yyr];
+    else
+      return yydefgoto_[yylhs - yyntokens_];
+  }
+

   int
   ]b4_parser_class_name[::parse ()
   {
   int
   ]b4_parser_class_name[::parse ()
   {


@@ -1178,7 +660,6 @@ b4_percent_code_get[]dnl
     /* State.  */
     int yyn;
     int yylen = 0;
     /* State.  */
     int yyn;
     int yylen = 0;

-    int yystate = 0;

 
     /* Error handling.  */
     int yynerrs_ = 0;
 
     /* Error handling.  */
     int yynerrs_ = 0;


@@ -1213,14 +694,12 @@ m4_popdef([b4_at_dollar])])dnl
     yystack_ = stack_type (0);
     yypush_ (0, 0, yyla);
 
     yystack_ = stack_type (0);
     yypush_ (0, 0, yyla);
 

-    // A new state was pushed on the stack.
-    // Invariant: yystate == yystack_[0].state, i.e.,
-    // yystate was just pushed onto the state stack.
+    // A new symbol was pushed on the stack.

   yynewstate:
   yynewstate:

-    YYCDEBUG << "Entering state " << yystate << std::endl;
+    YYCDEBUG << "Entering state " << yystack_[0].state << std::endl;

 
     /* Accept?  */
 
     /* Accept?  */

-    if (yystate == yyfinal_)
+    if (yystack_[0].state == yyfinal_)

       goto yyacceptlab;
 
     goto yybackup;
       goto yyacceptlab;
 
     goto yybackup;


@@ -1229,7 +708,7 @@ m4_popdef([b4_at_dollar])])dnl
   yybackup:
 
     /* Try to take a decision without lookahead.  */
   yybackup:
 
     /* Try to take a decision without lookahead.  */

-    yyn = yypact_[yystate];
+    yyn = yypact_[yystack_[0].state];

     if (yyn == yypact_ninf_)
       goto yydefault;
 
     if (yyn == yypact_ninf_)
       goto yydefault;
 


@@ -1273,15 +752,14 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
       --yyerrstatus_;
 
     /* Shift the lookahead token.  */
       --yyerrstatus_;
 
     /* Shift the lookahead token.  */

-    yystate = yyn;
-    yypush_ ("Shifting", yystate, yyla);
+    yypush_ ("Shifting", yyn, yyla);

     goto yynewstate;
 
   /*-----------------------------------------------------------.
   | yydefault -- do the default action for the current state.  |
   `-----------------------------------------------------------*/
   yydefault:
     goto yynewstate;
 
   /*-----------------------------------------------------------.
   | yydefault -- do the default action for the current state.  |
   `-----------------------------------------------------------*/
   yydefault:

-    yyn = yydefact_[yystate];
+    yyn = yydefact_[yystack_[0].state];

     if (yyn == 0)
       goto yyerrlab;
     goto yyreduce;
     if (yyn == 0)
       goto yyerrlab;
     goto yyreduce;


@@ -1290,11 +768,12 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
   | yyreduce -- Do a reduction.  |
   `-----------------------------*/
   yyreduce:
   | yyreduce -- Do a reduction.  |
   `-----------------------------*/
   yyreduce:

-    yylen = yyr2_[yyn];]b4_variant_if([
+    yylen = yyr2_[yyn];
+    yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([

     /* Variants are always initialized to an empty instance of the
     /* Variants are always initialized to an empty instance of the

-       correct type. The default $$=$1 rule is NOT applied when using
-       variants */
-    ]b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])[],[
+       correct type. The default $$=$1 action is NOT applied when using
+       variants.  */
+    b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])],[

     /* If YYLEN is nonzero, implement the default value of the action:
        `$$ = $1'.  Otherwise, use the top of the stack.
 
     /* If YYLEN is nonzero, implement the default value of the action:
        `$$ = $1'.  Otherwise, use the top of the stack.
 


@@ -1321,27 +800,20 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
        default:
           break;
       }
        default:
           break;
       }

-    // Compute post-reduction state.
-    yyn = yyr1_[yyn];
-    yystate = yypgoto_[yyn - yyntokens_] + yystack_[yylen].state;
-    if (0 <= yystate && yystate <= yylast_
-       && yycheck_[yystate] == yystack_[yylen].state)
-      yystate = yytable_[yystate];
-    else
-      yystate = yydefgoto_[yyn - yyntokens_];
-    yylhs.state = yystate;

     YY_SYMBOL_PRINT ("-> $$ =", yylhs);
 ]b4_variant_if([[
     YY_SYMBOL_PRINT ("-> $$ =", yylhs);
 ]b4_variant_if([[

-    // Destroy the lhs symbols.
+    // Destroy the rhs symbols.

     for (int i = 0; i < yylen; ++i)
     for (int i = 0; i < yylen; ++i)

-      // Destroy a variant which value may have be swapped with
-      // yylhs.value.  The value of yylhs.value (hence maybe one of
-      // these lhs symbols) depends on what does the default
-      // contruction for this type.  In the case of pointers for
-      // instance, nothing is done, so the value is junk.  Therefore
-      // do not try to report the content in the debug trace, it's
-      // junk.  Hence yymsg = 0.  Besides, that keeps exactly the same
-      // traces as with the other Bison skeletons.
+      // Destroy a variant which value may have been swapped with
+      // yylhs.value (for instance if the action was "std::swap($$,
+      // $1)").  The value of yylhs.value (hence possibly one of these
+      // rhs symbols) depends on the default contruction for this
+      // type.  In the case of pointers for instance, no
+      // initialization is done, so the value is junk.  Therefore do
+      // not try to report the value of symbols about to be destroyed
+      // in the debug trace, it's possibly junk.  Hence yymsg = 0.
+      // Besides, that keeps exactly the same traces as with the other
+      // Bison skeletons.

       yy_destroy_ (0, yystack_[i]);]])[
 
     yypop_ (yylen);
       yy_destroy_ (0, yystack_[i]);]])[
 
     yypop_ (yylen);


@@ -1352,16 +824,16 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     yypush_ (0, yylhs);
     goto yynewstate;
 
     yypush_ (0, yylhs);
     goto yynewstate;
 

-  /*------------------------------------.
-  | yyerrlab -- here on detecting error |
-  `------------------------------------*/
+  /*--------------------------------------.
+  | yyerrlab -- here on detecting error.  |
+  `--------------------------------------*/

   yyerrlab:
     /* If not already recovering from an error, report this error.  */
     if (!yyerrstatus_)
       {
        ++yynerrs_;
        error (]b4_args(b4_locations_if([yyla.location]),
   yyerrlab:
     /* If not already recovering from an error, report this error.  */
     if (!yyerrstatus_)
       {
        ++yynerrs_;
        error (]b4_args(b4_locations_if([yyla.location]),

-                        [yysyntax_error_ (yystate, yyla.type)])[);
+                        [[yysyntax_error_ (yystack_[0].state, yyla.type)]])[);

       }
 
 ]b4_locations_if([[
       }
 
 ]b4_locations_if([[


@@ -1395,15 +867,14 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
        YYERROR and the label yyerrorlab therefore never appears in user
        code.  */
     if (false)
        YYERROR and the label yyerrorlab therefore never appears in user
        code.  */
     if (false)

-      goto yyerrorlab;
-
-]b4_locations_if([[
-    yyerror_range[0].location = yystack_[yylen - 1].location;]])[
+      goto yyerrorlab;]b4_locations_if([[
+    yyerror_range[0].location = yystack_[yylen - 1].location;]])b4_variant_if([[
+    /* $$ was initialized before running the user action.  */
+    yy_destroy_ ("Error: discarding", yylhs);]])[

     /* Do not reclaim the symbols of the rule which action triggered
        this YYERROR.  */
     yypop_ (yylen);
     yylen = 0;
     /* Do not reclaim the symbols of the rule which action triggered
        this YYERROR.  */
     yypop_ (yylen);
     yylen = 0;

-    yystate = yystack_[0].state;

     goto yyerrlab1;
 
   /*-------------------------------------------------------------.
     goto yyerrlab1;
 
   /*-------------------------------------------------------------.


@@ -1415,7 +886,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
       stack_symbol_type error_token;
       for (;;)
         {
       stack_symbol_type error_token;
       for (;;)
         {

-          yyn = yypact_[yystate];
+          yyn = yypact_[yystack_[0].state];

           if (yyn != yypact_ninf_)
             {
               yyn += yyterror_;
           if (yyn != yypact_ninf_)
             {
               yyn += yyterror_;


@@ -1434,7 +905,6 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
           yyerror_range[0].location = yystack_[0].location;]])[
           yy_destroy_ ("Error: popping", yystack_[0]);
           yypop_ ();
           yyerror_range[0].location = yystack_[0].location;]])[
           yy_destroy_ ("Error: popping", yystack_[0]);
           yypop_ ();

-          yystate = yystack_[0].state;

           YY_STACK_PRINT ();
         }
 ]b4_locations_if([[
           YY_STACK_PRINT ();
         }
 ]b4_locations_if([[


@@ -1442,7 +912,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
       YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2);]])[
 
       /* Shift the error token.  */
       YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2);]])[
 
       /* Shift the error token.  */

-      error_token.state = yystate = yyn;
+      error_token.state = yyn;

       yypush_ ("Shifting", error_token);
     }
     goto yynewstate;
       yypush_ ("Shifting", error_token);
     }
     goto yynewstate;


@@ -1476,7 +946,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
   // Generate an error message.
   std::string
   ]b4_parser_class_name[::yysyntax_error_ (]dnl
   // Generate an error message.
   std::string
   ]b4_parser_class_name[::yysyntax_error_ (]dnl

-b4_error_verbose_if([int yystate, int yytoken],
+b4_error_verbose_if([state_type yystate, int yytoken],

                     [int, int])[)
   {
     std::string yyres;]b4_error_verbose_if([[
                     [int, int])[)
   {
     std::string yyres;]b4_error_verbose_if([[


@@ -1491,7 +961,8 @@ b4_error_verbose_if([int yystate, int yytoken],
        int yychecklim = yylast_ - yyn + 1;
        int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
 
        int yychecklim = yylast_ - yyn + 1;
        int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
 

-        // Number of "expected" tokens.
+        // Number of reported tokens (one for the "unexpected", one per
+        // "expected").

        size_t yycount = 0;
         // Its maximum.
         enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
        size_t yycount = 0;
         // Its maximum.
         enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };


@@ -1542,40 +1013,11 @@ b4_error_verbose_if([int yystate, int yytoken],
   }
 
 
   }
 
 

-  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-     STATE-NUM.  */

   const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
   const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;

-  ]b4_table_define([pact], [b4_pact])[;
-
-  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
-     doesn't specify something else to do.  Zero means the default is an
-     error.  */
-  ]b4_table_define([defact], [b4_defact])[;
-
-  /* YYPGOTO[NTERM-NUM].  */
-  ]b4_table_define([pgoto], [b4_pgoto])[;
-
-  /* YYDEFGOTO[NTERM-NUM].  */
-  ]b4_table_define([defgoto], [b4_defgoto])[;

 
 

-  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-     positive, shift that token.  If negative, reduce the rule which
-     number is the opposite.  If zero, do what YYDEFACT says.  */

   const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
   const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;

-  ]b4_table_define([table], [b4_table])[;

 
 

-  /* YYCHECK.  */
-  ]b4_table_define([check], [b4_check])[;
-
-  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
-     symbol of state STATE-NUM.  */
-  ]b4_table_define([stos], [b4_stos])[;
-
-  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-  ]b4_table_define([r1], [b4_r1])[;
-
-  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-  ]b4_table_define([r2], [b4_r2])[;
+]b4_parser_tables_define[

 
 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 
 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.


@@ -1588,8 +1030,7 @@ b4_error_verbose_if([int yystate, int yytoken],
 #endif
 
 #if YYDEBUG
 #endif
 
 #if YYDEBUG

-  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
-  ]b4_table_define([rline], [b4_rline])[;
+]b4_integral_parser_table_define([rline], [b4_rline])[

 
   // Print the state stack on the debug stream.
   void
 
   // Print the state stack on the debug stream.
   void


@@ -1620,107 +1061,8 @@ b4_error_verbose_if([int yystate, int yytoken],
   }
 #endif // YYDEBUG
 
   }
 #endif // YYDEBUG
 

-]b4_lex_symbol_if([], [b4_yytranslate_definition])[
+]b4_lex_symbol_if([], [b4_yytranslate_define])[

 ]b4_namespace_close[
 ]b4_namespace_close[

-

 ]b4_epilogue[]dnl
 ]b4_epilogue[]dnl

-@output(b4_dir_prefix[]stack.hh@)@
-b4_copyright([Stack handling for Bison parsers in C++])[
-
-#ifndef BISON_STACK_HH
-# define BISON_STACK_HH
-
-#include <deque>
-
-]b4_namespace_open[
-  template <class T, class S = std::deque<T> >
-  class stack
-  {
-  public:
-
-    // Hide our reversed order.
-    typedef typename S::reverse_iterator iterator;
-    typedef typename S::const_reverse_iterator const_iterator;
-
-    stack () : seq_ ()
-    {
-    }
-
-    stack (unsigned int n) : seq_ (n)
-    {
-    }
-
-    inline
-    T&
-    operator [] (unsigned int i)
-    {
-      return seq_[i];
-    }
-
-    inline
-    const T&
-    operator [] (unsigned int i) const
-    {
-      return seq_[i];
-    }
-
-    inline
-    void
-    push (const T& t)
-    {
-      seq_.push_front (t);
-    }
-
-    inline
-    void
-    pop (unsigned int n = 1)
-    {
-      for (; n; --n)
-       seq_.pop_front ();
-    }
-
-    inline
-    typename S::size_type
-    size () const
-    {
-      return seq_.size ();
-    }
-
-    inline const_iterator begin () const { return seq_.rbegin (); }
-    inline const_iterator end ()   const { return seq_.rend ();   }
-
-  private:
-    /// The wrapped container.
-    S seq_;
-  };
-
-  /// Present a slice of the top of a stack.
-  template <class T, class S = stack<T> >
-  class slice
-  {
-  public:
-
-    slice (const S& stack,
-          unsigned int range) : stack_ (stack),
-                                range_ (range)
-    {
-    }
-
-    inline
-    const T&
-    operator [] (unsigned int i) const
-    {
-      return stack_[range_ - i];
-    }
-
-  private:
-
-    const S& stack_;
-    unsigned int range_;
-  };
-]b4_namespace_close[
-
-#endif // not BISON_STACK_HH[]dnl
-]

 m4_divert_pop(0)
 m4_popdef([b4_copyright_years])dnl
 m4_divert_pop(0)
 m4_popdef([b4_copyright_years])dnl