Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-09 12:23:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
Akim Demaille
2018-12-25 18:55:18 +01:00
parent a4ede8f85b
commit f44fcd30ea
3 changed files with 121 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
data/skeletons/lalr1.cc
View File

@@ -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;

236
data/skeletons/stack.hh
View File

@@ -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.
template <typename T, typename 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;
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)
[[ /// A stack with random access from its top.
template <typename T, typename S = std::vector<T> >
class stack
{
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.
///
/// Index 0 returns the topmost element.
T&
operator[] (int i)
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];
}
/// 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.
///
/// Index 0 returns the topmost element.
const T&
operator[] (size_type i) const
{
return seq_[size () - 1 - i];
}
const T&
operator[] (int i) const
{
return stack_[range_ - 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
{
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_;
};
private:
const S& stack_;
int range_;
};
]])
m4_ifdef([b4_stack_file],