X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/fe1b448ada5e3a79ae3f523e08b5004396f30ca9..9c6a89660e930bf68907fb6141b517378147f38e:/data/lalr1.cc?ds=sidebyside

diff --git a/data/lalr1.cc b/data/lalr1.cc
index c3678887..86e6fd08 100644
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -18,72 +18,34 @@
 
 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.
-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
-  }dnl
+  };dnl
 ])
 
+
 # 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])
 
-# 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])
 # ----------------------------------------------------------------
@@ -101,14 +63,14 @@ m4_define([b4_assert_if],
 # --------------------
 # 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],
-[yylhs.location])
+          [yylhs.location])
 
 
 # b4_rhs_data(RULE-LENGTH, NUM)
@@ -120,7 +82,7 @@ m4_define([b4_rhs_data],
 
 
 # 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],
@@ -143,78 +105,27 @@ m4_define([b4_rhs_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.
-m4_define([b4_symbol_actions],
+m4_define([b4_symbol_action],
+[b4_symbol_if([$1], [has_$2],
 [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
-      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;
+
 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
@@ -238,7 +149,7 @@ b4_args(b4_symbol_if([$1], [has_type],
 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_foreach([b4_symbol_constructor_declaration_])])])
 
 
 
@@ -357,61 +268,7 @@ 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
-# 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_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_symbol_foreach([b4_symbol_constructor_definition_])])])
 
 
 # b4_yytranslate_definition
@@ -457,6 +314,8 @@ b4_locations_if(
 [# 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()
@@ -480,104 +339,7 @@ dnl FIXME: This is wrong, we want computed header guards.
 ]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_definition])[
 ]b4_namespace_close[
 
 ]b4_locations_if([#include "location.hh"])[
@@ -630,7 +392,7 @@ do {                                                            \
 ]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]))[};
+    {]b4_type_foreach([b4_char_sizeof])[};
 
     /// Symbol semantic values.
     typedef variant<sizeof(union_type)> semantic_type;],
@@ -693,36 +455,11 @@ m4_ifdef([b4_stype],
 
     /// 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_;
-
-    /// 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_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.
@@ -733,8 +470,8 @@ m4_ifdef([b4_stype],
     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.
@@ -1073,9 +810,9 @@ b4_percent_code_get[]dnl
     // 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.
@@ -1094,8 +831,8 @@ b4_percent_code_get[]dnl
         << 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 << ')';
@@ -1294,7 +1031,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     /* 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])[],[
+    ]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.
 
@@ -1332,16 +1069,18 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     yylhs.state = yystate;
     YY_SYMBOL_PRINT ("-> $$ =", yylhs);
 ]b4_variant_if([[
-    // Destroy the lhs symbols.
+    // Destroy the rhs symbols.
     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);
@@ -1352,9 +1091,9 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
     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_)
@@ -1491,7 +1230,8 @@ b4_error_verbose_if([int yystate, int yytoken],
 	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 };
@@ -1542,40 +1282,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[;
-  ]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[;
-  ]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.
@@ -1588,8 +1299,7 @@ b4_error_verbose_if([int yystate, int yytoken],
 #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
@@ -1622,105 +1332,6 @@ b4_error_verbose_if([int yystate, int yytoken],
 
 ]b4_lex_symbol_if([], [b4_yytranslate_definition])[
 ]b4_namespace_close[
-
 ]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