mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 12:23:04 +00:00
573654ca9e
This is consistent with what is done with yacc.c and glr.c. Because it also avoids that the stack needs to be resized very soon, it should help keeping tests about destructors more reliable. Indeed, if the stack is created too small, very soon the C++ library needs to enlarge it, which means creating a new one, copying the elements from the initial one onto it, and then destroy the elements of the initial stack: that would be a spurious call to a destructor. Reported by Thomas Jahns. http://lists.gnu.org/archive/html/bug-bison/2015-01/msg00059.html * data/stack.hh (stack::stack): Reserve 200 slots. * tests/c++.at: Remove traces of stack expansions.
154 lines
2.9 KiB
C++
154 lines
2.9 KiB
C++
# C++ skeleton for Bison
|
|
|
|
# Copyright (C) 2002-2015 Free Software Foundation, Inc.
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
m4_pushdef([b4_copyright_years],
|
|
[2002-2015])
|
|
|
|
# b4_stack_define
|
|
# ---------------
|
|
m4_define([b4_stack_define],
|
|
[[ template <class T, class S = std::vector<T> >
|
|
class stack
|
|
{
|
|
public:
|
|
// Hide our reversed order.
|
|
typedef typename S::reverse_iterator iterator;
|
|
typedef typename S::const_reverse_iterator const_iterator;
|
|
|
|
stack ()
|
|
: seq_ ()
|
|
{
|
|
seq_.reserve (200);
|
|
}
|
|
|
|
stack (unsigned int n)
|
|
: seq_ (n)
|
|
{}
|
|
|
|
inline
|
|
T&
|
|
operator[] (unsigned int i)
|
|
{
|
|
return seq_[seq_.size () - 1 - i];
|
|
}
|
|
|
|
inline
|
|
const T&
|
|
operator[] (unsigned int i) const
|
|
{
|
|
return seq_[seq_.size () - 1 - i];
|
|
}
|
|
|
|
/// Steal the contents of \a t.
|
|
///
|
|
/// Close to move-semantics.
|
|
inline
|
|
void
|
|
push (T& t)
|
|
{
|
|
seq_.push_back (T());
|
|
operator[](0).move (t);
|
|
}
|
|
|
|
inline
|
|
void
|
|
pop (unsigned int n = 1)
|
|
{
|
|
for (; n; --n)
|
|
seq_.pop_back ();
|
|
}
|
|
|
|
void
|
|
clear ()
|
|
{
|
|
seq_.clear ();
|
|
}
|
|
|
|
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:
|
|
stack (const stack&);
|
|
stack& operator= (const stack&);
|
|
/// 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_defines_if(
|
|
[b4_output_begin([b4_dir_prefix[]stack.hh])
|
|
b4_copyright([Stack handling for Bison parsers in C++])[
|
|
|
|
/**
|
|
** \file ]b4_dir_prefix[stack.hh
|
|
** Define the ]b4_namespace_ref[::stack class.
|
|
*/
|
|
|
|
]b4_cpp_guard_open([b4_dir_prefix[]stack.hh])[
|
|
|
|
# include <vector>
|
|
|
|
]b4_namespace_open[
|
|
]b4_stack_define[
|
|
]b4_namespace_close[
|
|
|
|
]b4_cpp_guard_close([b4_dir_prefix[]stack.hh])
|
|
b4_output_end()
|
|
])
|
|
|
|
m4_popdef([b4_copyright_years])
|