Add commit 43aab01 of BenHanson/lexertl14 from github

YACReaderLibrary/lexertl/partition/charset.hpp

@@ -0,0 +1,72 @@
+// charset.hpp
+// Copyright (c) 2005-2018 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_CHARSET_HPP
+#define LEXERTL_CHARSET_HPP
+
+#include <algorithm>
+#include <iterator>
+#include <set>
+#include "../string_token.hpp"
+
+namespace lexertl
+{
+namespace detail
+{
+template<typename char_type, typename id_type>
+struct basic_charset
+{
+    using token = basic_string_token<char_type>;
+    using index_set = std::set<id_type>;
+
+    token _token;
+    index_set _index_set;
+
+    basic_charset() :
+        _token(),
+        _index_set()
+    {
+    }
+
+    basic_charset(const token &token_, const id_type index_) :
+        _token(token_),
+        _index_set()
+    {
+        _index_set.insert(index_);
+    }
+
+    bool empty() const
+    {
+        return _token.empty() && _index_set.empty();
+    }
+
+    void intersect(basic_charset &rhs_, basic_charset &overlap_)
+    {
+        _token.intersect(rhs_._token, overlap_._token);
+
+        if (!overlap_._token.empty())
+        {
+            std::merge(_index_set.begin(), _index_set.end(),
+                rhs_._index_set.begin(), rhs_._index_set.end(),
+                std::inserter(overlap_._index_set,
+                overlap_._index_set.end()));
+
+            if (_token.empty())
+            {
+                _index_set.clear();
+            }
+
+            if (rhs_._token.empty())
+            {
+                rhs_._index_set.clear();
+            }
+        }
+    }
+};
+}
+}
+
+#endif

YACReaderLibrary/lexertl/partition/equivset.hpp

@@ -0,0 +1,135 @@
+// equivset.hpp
+// Copyright (c) 2005-2018 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_EQUIVSET_HPP
+#define LEXERTL_EQUIVSET_HPP
+
+#include <algorithm>
+#include "../parser/tree/node.hpp"
+#include <set>
+
+namespace lexertl
+{
+namespace detail
+{
+template<typename id_type>
+struct basic_equivset
+{
+    using index_set = std::set<id_type>;
+    using index_vector = std::vector<id_type>;
+    using node = basic_node<id_type>;
+    using node_vector = std::vector<observer_ptr<node>>;
+
+    index_vector _index_vector;
+    id_type _id;
+    bool _greedy;
+    node_vector _followpos;
+
+    basic_equivset() :
+        _index_vector(),
+        _id(0),
+        _greedy(true),
+        _followpos()
+    {
+    }
+
+    basic_equivset(const index_set &index_set_, const id_type id_,
+        const bool greedy_, const node_vector &followpos_) :
+        _index_vector(index_set_.begin(), index_set_.end()),
+        _id(id_),
+        _greedy(greedy_),
+        _followpos(followpos_)
+    {
+    }
+
+    bool empty() const
+    {
+        return _index_vector.empty() && _followpos.empty();
+    }
+
+    void intersect(basic_equivset &rhs_, basic_equivset &overlap_)
+    {
+        intersect_indexes(rhs_._index_vector, overlap_._index_vector);
+
+        if (!overlap_._index_vector.empty())
+        {
+            // Note that the LHS takes priority in order to
+            // respect rule ordering priority in the lex spec.
+            overlap_._id = _id;
+            overlap_._greedy = _greedy;
+            overlap_._followpos = _followpos;
+
+            auto overlap_begin_ = overlap_._followpos.cbegin();
+            auto overlap_end_ = overlap_._followpos.cend();
+
+            for (observer_ptr<node> node_ : rhs_._followpos)
+            {
+                if (std::find(overlap_begin_, overlap_end_, node_) ==
+                    overlap_end_)
+                {
+                    overlap_._followpos.push_back(node_);
+                    overlap_begin_ = overlap_._followpos.begin();
+                    overlap_end_ = overlap_._followpos.end();
+                }
+            }
+
+            if (_index_vector.empty())
+            {
+                _followpos.clear();
+            }
+
+            if (rhs_._index_vector.empty())
+            {
+                rhs_._followpos.clear();
+            }
+        }
+    }
+
+private:
+    void intersect_indexes(index_vector &rhs_, index_vector &overlap_)
+    {
+        std::set_intersection(_index_vector.begin(), _index_vector.end(),
+            rhs_.begin(), rhs_.end(), std::back_inserter(overlap_));
+
+        if (!overlap_.empty())
+        {
+            remove(overlap_, _index_vector);
+            remove(overlap_, rhs_);
+        }
+    }
+
+    void remove(const index_vector &source_, index_vector &dest_)
+    {
+        auto inter_ = source_.begin();
+        auto inter_end_ = source_.end();
+        auto reader_ = std::find(dest_.begin(), dest_.end(), *inter_);
+        auto writer_ = reader_;
+        auto dest_end_ = dest_.end();
+
+        while (writer_ != dest_end_ && inter_ != inter_end_)
+        {
+            if (*reader_ == *inter_)
+            {
+                ++inter_;
+                ++reader_;
+            }
+            else
+            {
+                *writer_++ = *reader_++;
+            }
+        }
+
+        while (reader_ != dest_end_)
+        {
+            *writer_++ = *reader_++;
+        }
+
+        dest_.resize(dest_.size() - source_.size());
+    }
+};
+}
+}
+
+#endif