Fix typo in grammar.

Add lexertl.

inc/lexertl/containers/bitvector.hpp

@@ -0,0 +1,228 @@
+// bitvector.hpp
+// Copyright (c) 2012 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef LEXERTL_BITVECTOR_HPP
+#define LEXERTL_BITVECTOR_HPP
+
+#include <vector>
+
+namespace lexertl
+{
+template<typename T>
+class basic_bitvector
+{
+public:
+    template<typename Ty>
+    class reference
+    {
+    public:
+        reference (Ty &block_, const std::size_t mask_) :
+            _block (block_),
+            _mask (mask_)
+        {
+        }
+
+        operator bool () const
+        {
+            return (_block & _mask) != 0;
+        }
+
+        reference<Ty> &operator = (const bool bit_)
+        {
+            if (bit_)
+            {
+                _block |= _mask;
+            }
+            else
+            {
+                _block &= ~_mask;
+            }
+
+            return *this;
+        }
+
+        reference<Ty> &operator = (reference<Ty> &rhs_)
+        {
+            if (rhs_)
+            {
+                _block |= _mask;
+            }
+            else
+            {
+                _block &= ~_mask;
+            }
+        }
+
+    private:
+        Ty &_block;
+        const std::size_t _mask;
+    };
+
+    basic_bitvector (const std::size_t size_) :
+        _vec (block (size_) + (bit (size_) ? 1 : 0), 0)
+    {
+    }
+
+    basic_bitvector (const basic_bitvector &rhs_) :
+        _vec (rhs_._vec)
+    {
+    }
+
+    basic_bitvector &operator = (const basic_bitvector &rhs_)
+    {
+        if (&rhs_ != this)
+        {
+            _vec = rhs_._vec;
+        }
+
+        return *this;
+    }
+
+    bool operator [] (const std::size_t index_) const
+    {
+        return (_vec[block (index_)] & (1 << bit (index_))) != 0;
+    }
+
+    reference<T> operator [] (const std::size_t index_)
+    {
+        return reference<T> (_vec[block (index_)], (1 << bit (index_)));
+    }
+
+    basic_bitvector<T> &operator |= (const basic_bitvector<T> &rhs_)
+    {
+        typename t_vector::iterator lhs_iter_ = _vec.begin ();
+        typename t_vector::iterator lhs_end_ = _vec.end ();
+        typename t_vector::const_iterator rhs_iter_ = rhs_._vec.begin ();
+        typename t_vector::const_iterator rhs_end_ = rhs_._vec.end ();
+
+        for (; lhs_iter_ != lhs_end_ && rhs_iter_ != rhs_end_;
+            ++lhs_iter_, ++rhs_iter_)
+        {
+            *lhs_iter_ |= *rhs_iter_;
+        }
+
+        return *this;
+    }
+
+    basic_bitvector<T> &operator &= (const basic_bitvector<T> &rhs_)
+    {
+        typename t_vector::iterator lhs_iter_ = _vec.begin ();
+        typename t_vector::iterator lhs_end_ = _vec.end ();
+        typename t_vector::const_iterator rhs_iter_ = rhs_._vec.begin ();
+        typename t_vector::const_iterator rhs_end_ = rhs_._vec.end ();
+
+        for (; lhs_iter_ != lhs_end_ && rhs_iter_ != rhs_end_;
+            ++lhs_iter_, ++rhs_iter_)
+        {
+            *lhs_iter_ &= *rhs_iter_;
+        }
+
+        return *this;
+    }
+
+    void clear ()
+    {
+        typename t_vector::iterator iter_ = _vec.begin ();
+        typename t_vector::iterator end_ = _vec.end ();
+
+        for (; iter_ != end_; ++iter_)
+        {
+            *iter_ = 0;
+        }
+    }
+
+    bool any () const
+    {
+        typename t_vector::const_iterator iter_ = _vec.begin ();
+        typename t_vector::const_iterator end_ = _vec.end ();
+
+        for (; iter_ != end_; ++iter_)
+        {
+            if (*iter_) break;
+        }
+
+        return iter_ != end_;
+    }
+
+    void negate ()
+    {
+        typename t_vector::iterator iter_ = _vec.begin ();
+        typename t_vector::iterator end_ = _vec.end ();
+
+        for (; iter_ != end_; ++iter_)
+        {
+            *iter_ = ~*iter_;
+        }
+    }
+
+    std::size_t find_first () const
+    {
+        return find_next (npos ());
+    }
+
+    std::size_t find_next (const std::size_t index_) const
+    {
+        std::size_t ret_ = npos ();
+        const std::size_t block_ = index_ == npos () ? 0 : block (index_ + 1);
+        std::size_t bit_ = index_ == npos () ? 0 : bit (index_ + 1);
+        typename t_vector::const_iterator iter_ = _vec.begin () + block_;
+        typename t_vector::const_iterator end_ = _vec.end ();
+
+        for (std::size_t i_ = block_; iter_ != end_; ++iter_, ++i_)
+        {
+            const bool bits_ = (*iter_ & (static_cast<T>(~0) << bit_)) != 0;
+
+            if (bits_)
+            {
+                std::size_t j_ = bit_;
+                std::size_t b_ = 1 << bit_;
+                bool found_ = false;
+
+                for (; j_ < sizeof(T) * 8; ++j_, b_ <<= 1)
+                {
+                    if (*iter_ & b_)
+                    {
+                        found_ = true;
+                        break;
+                    }
+                }
+
+                if (found_)
+                {
+                    ret_ = i_ * sizeof(T) * 8 + j_;
+                    break;
+                }
+            }
+
+            bit_ = 0;
+        }
+
+        return ret_;
+    }
+
+    std::size_t npos () const
+    {
+        return static_cast<std::size_t>(~0);
+    }
+
+private:
+    typedef std::vector<T> t_vector;
+
+    t_vector _vec;
+
+    std::size_t block (const std::size_t index_) const
+    {
+        return index_ / (sizeof(T) * 8);
+    }
+
+    std::size_t bit (const std::size_t index_) const
+    {
+        return index_ % (sizeof(T) * 8);
+    }
+};
+}
+
+#endif

inc/lexertl/containers/ptr_list.hpp

@@ -0,0 +1,69 @@
+// ptr_list.hpp
+// Copyright (c) 2005-2012 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef LEXERTL_PTR_LIST_HPP
+#define LEXERTL_PTR_LIST_HPP
+
+#include <list>
+
+namespace lexertl
+{
+namespace detail
+{
+template<typename ptr_type>
+class ptr_list
+{
+public:
+    typedef std::list<ptr_type *> list;
+
+    ptr_list () :
+        _list ()
+    {
+    }
+
+    ~ptr_list ()
+    {
+        clear ();
+    }
+
+    list *operator -> ()
+    {
+        return &_list;
+    }
+
+    const list *operator -> () const
+    {
+        return &_list;
+    }
+
+    list &operator * ()
+    {
+        return _list;
+    }
+
+    const list &operator * () const
+    {
+        return _list;
+    }
+
+    void clear ()
+    {
+        while (!_list.empty ())
+        {
+            delete _list.front ();
+            _list.pop_front ();
+        }
+    }
+
+private:
+    list _list;
+
+    ptr_list (const ptr_list &); // No copy construction.
+    ptr_list &operator = (const ptr_list &); // No assignment.
+};
+}
+}
+
+#endif

inc/lexertl/containers/ptr_map.hpp

@@ -0,0 +1,72 @@
+// ptr_map.hpp
+// Copyright (c) 2005-2012 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef LEXERTL_PTR_MAP_HPP
+#define LEXERTL_PTR_MAP_HPP
+
+#include <map>
+
+namespace lexertl
+{
+namespace detail
+{
+template<typename key_type, typename ptr_type>
+class ptr_map
+{
+public:
+    typedef std::map<key_type, ptr_type *> map;
+    typedef std::pair<key_type, ptr_type *> pair;
+    typedef std::pair<typename map::iterator, bool> iter_pair;
+
+    ptr_map ()
+    {
+    }
+
+    ~ptr_map ()
+    {
+        clear ();
+    }
+
+    map *operator -> ()
+    {
+        return &_map;
+    }
+
+    const map *operator -> () const
+    {
+        return &_map;
+    }
+
+    map &operator * ()
+    {
+        return _map;
+    }
+
+    const map &operator * () const
+    {
+        return _map;
+    }
+
+    void clear ()
+    {
+        for (typename map::iterator iter_ = _map.begin (), end_ = _map.end ();
+            iter_ != end_; ++iter_)
+        {
+            delete iter_->second;
+        }
+
+        _map.clear ();
+    }
+
+private:
+    map _map;
+
+    ptr_map (const ptr_map &); // No copy construction.
+    ptr_map &operator = (const ptr_map &); // No assignment.
+};
+}
+}
+
+#endif

inc/lexertl/containers/ptr_stack.hpp

@@ -0,0 +1,69 @@
+// ptr_stack.hpp
+// Copyright (c) 2005-2012 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef LEXERTL_PTR_STACK_HPP
+#define LEXERTL_PTR_STACK_HPP
+
+#include <stack>
+
+namespace lexertl
+{
+namespace detail
+{
+template<typename ptr_type>
+class ptr_stack
+{
+public:
+    typedef std::stack<ptr_type *> stack;
+
+    ptr_stack () :
+        _stack ()
+    {
+    }
+
+    ~ptr_stack ()
+    {
+        clear ();
+    }
+
+    stack *operator -> ()
+    {
+        return &_stack;
+    }
+
+    const stack *operator -> () const
+    {
+        return &_stack;
+    }
+
+    stack &operator * ()
+    {
+        return _stack;
+    }
+
+    const stack &operator * () const
+    {
+        return _stack;
+    }
+
+    void clear ()
+    {
+        while (!_stack.empty ())
+        {
+            delete _stack.top ();
+            _stack.pop ();
+        }
+    }
+
+private:
+    stack _stack;
+
+    ptr_stack (const ptr_stack &); // No copy construction.
+    ptr_stack &operator = (const ptr_stack &); // No assignment.
+};
+}
+}
+
+#endif

inc/lexertl/containers/ptr_vector.hpp

@@ -0,0 +1,106 @@
+// ptr_vector.hpp
+// Copyright (c) 2005-2012 Ben Hanson (http://www.benhanson.net/)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef LEXERTL_PTR_VECTOR_HPP
+#define LEXERTL_PTR_VECTOR_HPP
+
+#include "../size_t.hpp"
+#include <vector>
+
+namespace lexertl
+{
+namespace detail
+{
+template<typename ptr_type>
+class ptr_vector
+{
+public:
+    typedef std::vector<ptr_type *> vector;
+
+    ptr_vector () :
+        _vector ()
+    {
+    }
+
+    ~ptr_vector ()
+    {
+        clear ();
+    }
+
+    vector *operator -> ()
+    {
+        return &_vector;
+    }
+
+    const vector *operator -> () const
+    {
+        return &_vector;
+    }
+
+    vector &operator * ()
+    {
+        return _vector;
+    }
+
+    const vector &operator * () const
+    {
+        return _vector;
+    }
+
+    ptr_type * &operator [] (const std::size_t index_)
+    {
+        return _vector[index_];
+    }
+
+    ptr_type * const &operator [] (const std::size_t index_) const
+    {
+        return _vector[index_];
+    }
+
+    bool operator == (const ptr_vector &rhs_) const
+    {
+        bool equal_ = _vector.size () == rhs_._vector.size ();
+
+        if (equal_)
+        {
+            typename vector::const_iterator lhs_iter_ = _vector.begin ();
+            typename vector::const_iterator end_ = _vector.end ();
+            typename vector::const_iterator rhs_iter_ = rhs_._vector.begin ();
+
+            for (; equal_ && lhs_iter_ != end_; ++lhs_iter_, ++rhs_iter_)
+            {
+                equal_ = **lhs_iter_ == **rhs_iter_;
+            }
+        }
+
+        return  equal_;
+    }
+
+    void clear ()
+    {
+        if (!_vector.empty ())
+        {
+            ptr_type **iter_ = &_vector.front ();
+            ptr_type **end_ = iter_ + _vector.size ();
+
+            for (; iter_ != end_; ++iter_)
+            {
+                delete *iter_;
+            }
+        }
+
+        _vector.clear ();
+    }
+
+private:
+    vector _vector;
+
+    ptr_vector (const ptr_vector &); // No copy construction.
+    ptr_vector &operator = (const ptr_vector &); // No assignment.
+};
+}
+}
+
+#endif