c++: move stack<T> inside yy::parser

We used to define such auxiliary structures outside the class, mainly
as a matter of style to keep the definition of yy::parser short and
simple.  However, now there's a lot more code generated inside the
class definition (e.g., all the token constructors), so the
readability no longer applies.

However, if we move stack (and slice) inside yy::parser, then it
should no longer be needed to change the namespace to have multiple
parsers: changing the class name should suffice.

One common argument against inner classes is that they code bloat.  It
hardly applies here, since typically different parsers will have
different semantic value types, hence different actual stack types.

* data/skeletons/lalr1.cc: Invoke b4_stack_define inside yy::parser.

NEWS

@@ -209,7 +209,7 @@ GNU Bison NEWS
   The syntax is now as follows:
 
     %token TAG? ( ID NUMBER? STRING? )+ ( TAG ( ID NUMBER? STRING? )+ )*
-    %left  TAG? ( ID NUMBER?)+ ( TAG ( ID NUMBER? )+ )*
+    %left  TAG? ( ID NUMBER? )+ ( TAG ( ID NUMBER? )+ )*
     %type  TAG? ( ID | CHAR | STRING )+ ( TAG ( ID | CHAR | STRING )+ )*
     %nterm TAG? ID+ ( TAG ID+ )*
 

data/skeletons/lalr1.cc

@@ -172,7 +172,6 @@ m4_define([b4_shared_declarations],
 
 ]b4_namespace_open[
 
-]b4_stack_define[
 ]b4_bison_locations_if([m4_ifndef([b4_location_file],
                                   [b4_location_define])])[
 
@@ -339,6 +338,8 @@ m4_define([b4_shared_declarations],
 #endif
     };
 
+]b4_stack_define[
+
     /// Stack type.
     typedef stack<stack_symbol_type> stack_type;
 

data/skeletons/stack.hh

@@ -26,129 +26,129 @@ b4_defines_if([b4_required_version_if([302], [],
 # b4_stack_define
 # ---------------
 m4_define([b4_stack_define],
-[[  /// A stack with random access from its top.
+[[    /// A stack with random access from its top.
-  template <typename T, typename S = std::vector<T> >
+    template <typename T, typename S = std::vector<T> >
-  class stack
+    class stack
-  {
-  public:
-    // Hide our reversed order.
-    typedef typename S::reverse_iterator iterator;
-    typedef typename S::const_reverse_iterator const_iterator;
-    typedef typename S::size_type size_type;
-
-    stack (size_type n = 200)
-      : seq_ (n)
-    {}
-
-    /// Random access.
-    ///
-    /// Index 0 returns the topmost element.
-    T&
-    operator[] (size_type i)
     {
-      return seq_[size () - 1 - i];
+    public:
-    }
+      // Hide our reversed order.
+      typedef typename S::reverse_iterator iterator;
+      typedef typename S::const_reverse_iterator const_iterator;
+      typedef typename S::size_type size_type;
 
-    /// Random access.
+      stack (size_type n = 200)
-    ///
+        : seq_ (n)
-    /// Index 0 returns the topmost element.
+      {}
-    T&
+
-    operator[] (int i)
+      /// Random access.
+      ///
+      /// Index 0 returns the topmost element.
+      T&
+      operator[] (size_type i)
+      {
+        return seq_[size () - 1 - i];
+      }
+
+      /// Random access.
+      ///
+      /// Index 0 returns the topmost element.
+      T&
+      operator[] (int i)
+      {
+        return operator[] (size_type (i));
+      }
+
+      /// Random access.
+      ///
+      /// Index 0 returns the topmost element.
+      const T&
+      operator[] (size_type i) const
+      {
+        return seq_[size () - 1 - i];
+      }
+
+      /// Random access.
+      ///
+      /// Index 0 returns the topmost element.
+      const T&
+      operator[] (int i) const
+      {
+        return operator[] (size_type (i));
+      }
+
+      /// Steal the contents of \a t.
+      ///
+      /// Close to move-semantics.
+      void
+      push (YY_MOVE_REF (T) t)
+      {
+        seq_.push_back (T ());
+        operator[] (0).move (t);
+      }
+
+      /// Pop elements from the stack.
+      void
+      pop (int n = 1) YY_NOEXCEPT
+      {
+        for (; 0 < n; --n)
+          seq_.pop_back ();
+      }
+
+      /// Pop all elements from the stack.
+      void
+      clear () YY_NOEXCEPT
+      {
+        seq_.clear ();
+      }
+
+      /// Number of elements on the stack.
+      size_type
+      size () const YY_NOEXCEPT
+      {
+        return seq_.size ();
+      }
+
+      /// Iterator on top of the stack (going downwards).
+      const_iterator
+      begin () const YY_NOEXCEPT
+      {
+        return seq_.rbegin ();
+      }
+
+      /// Bottom of the stack.
+      const_iterator
+      end () const YY_NOEXCEPT
+      {
+        return seq_.rend ();
+      }
+
+    private:
+      stack (const stack&);
+      stack& operator= (const stack&);
+      /// The wrapped container.
+      S seq_;
+    };
+
+    /// Present a slice of the top of a stack.
+    template <typename T, typename S = stack<T> >
+    class slice
     {
-      return operator[] (size_type (i));
+    public:
-    }
+      slice (const S& stack, int range)
+        : stack_ (stack)
+        , range_ (range)
+      {}
 
-    /// Random access.
+      const T&
-    ///
+      operator[] (int i) const
-    /// Index 0 returns the topmost element.
+      {
-    const T&
+        return stack_[range_ - i];
-    operator[] (size_type i) const
+      }
-    {
-      return seq_[size () - 1 - i];
-    }
 
-    /// Random access.
+    private:
-    ///
+      const S& stack_;
-    /// Index 0 returns the topmost element.
+      int range_;
-    const T&
+    };
-    operator[] (int i) const
-    {
-      return operator[] (size_type (i));
-    }
-
-    /// Steal the contents of \a t.
-    ///
-    /// Close to move-semantics.
-    void
-    push (YY_MOVE_REF (T) t)
-    {
-      seq_.push_back (T ());
-      operator[](0).move (t);
-    }
-
-    /// Pop elements from the stack.
-    void
-    pop (int n = 1) YY_NOEXCEPT
-    {
-      for (; 0 < n; --n)
-        seq_.pop_back ();
-    }
-
-    /// Pop all elements from the stack.
-    void
-    clear () YY_NOEXCEPT
-    {
-      seq_.clear ();
-    }
-
-    /// Number of elements on the stack.
-    size_type
-    size () const YY_NOEXCEPT
-    {
-      return seq_.size ();
-    }
-
-    /// Iterator on top of the stack (going downwards).
-    const_iterator
-    begin () const YY_NOEXCEPT
-    {
-      return seq_.rbegin ();
-    }
-
-    /// Bottom of the stack.
-    const_iterator
-    end () const YY_NOEXCEPT
-    {
-      return seq_.rend ();
-    }
-
-  private:
-    stack (const stack&);
-    stack& operator= (const stack&);
-    /// The wrapped container.
-    S seq_;
-  };
-
-  /// Present a slice of the top of a stack.
-  template <typename T, typename S = stack<T> >
-  class slice
-  {
-  public:
-    slice (const S& stack, int range)
-      : stack_ (stack)
-      , range_ (range)
-    {}
-
-    const T&
-    operator[] (int i) const
-    {
-      return stack_[range_ - i];
-    }
-
-  private:
-    const S& stack_;
-    int range_;
-  };
 ]])
 
 m4_ifdef([b4_stack_file],