Add commit 43aab01 of BenHanson/lexertl14 from github

YACReaderLibrary/lexertl/parser/tree/node.hpp

@@ -0,0 +1,242 @@
+// node.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_NODE_HPP
+#define LEXERTL_NODE_HPP
+
+#include <assert.h>
+#include <memory>
+#include "../../observer_ptr.hpp"
+#include "../../runtime_error.hpp"
+#include <stack>
+#include <vector>
+
+namespace lexertl
+{
+namespace detail
+{
+template<typename id_type>
+class basic_node
+{
+public:
+    enum node_type {LEAF, SEQUENCE, SELECTION, ITERATION, END};
+
+    using bool_stack = std::stack<bool>;
+    using node_stack = std::stack<observer_ptr<basic_node>>;
+    using const_node_stack = std::stack<observer_ptr<const basic_node>>;
+    using node_vector = std::vector<observer_ptr<basic_node>>;
+    using node_ptr_vector = std::vector<std::unique_ptr<basic_node>>;
+
+    basic_node() :
+        _nullable(false),
+        _firstpos(),
+        _lastpos()
+    {
+    }
+
+    basic_node(const bool nullable_) :
+        _nullable(nullable_),
+        _firstpos(),
+        _lastpos()
+    {
+    }
+
+    virtual ~basic_node()
+    {
+    }
+
+    static id_type null_token()
+    {
+        return static_cast<id_type>(~0);
+    }
+
+    bool nullable() const
+    {
+        return _nullable;
+    }
+
+    void append_firstpos(node_vector &firstpos_) const
+    {
+        firstpos_.insert(firstpos_.end(),
+            _firstpos.begin(), _firstpos.end());
+    }
+
+    void append_lastpos(node_vector &lastpos_) const
+    {
+        lastpos_.insert(lastpos_.end(),
+            _lastpos.begin(), _lastpos.end());
+    }
+
+    virtual void append_followpos(const node_vector &/*followpos_*/)
+    {
+        throw runtime_error("Internal error node::append_followpos().");
+    }
+
+    observer_ptr<basic_node> copy(node_ptr_vector &node_ptr_vector_) const
+    {
+        observer_ptr<basic_node> new_root_ = nullptr;
+        const_node_stack node_stack_;
+        bool_stack perform_op_stack_;
+        bool down_ = true;
+        node_stack new_node_stack_;
+
+        node_stack_.push(this);
+
+        while (!node_stack_.empty())
+        {
+            while (down_)
+            {
+                down_ = node_stack_.top()->traverse(node_stack_,
+                    perform_op_stack_);
+            }
+
+            while (!down_ && !node_stack_.empty())
+            {
+                observer_ptr<const basic_node> top_ = node_stack_.top();
+
+                top_->copy_node(node_ptr_vector_, new_node_stack_,
+                    perform_op_stack_, down_);
+
+                if (!down_) node_stack_.pop();
+            }
+        }
+
+        assert(new_node_stack_.size() == 1);
+        new_root_ = new_node_stack_.top();
+        new_node_stack_.pop();
+        return new_root_;
+    }
+
+    virtual node_type what_type() const = 0;
+
+    virtual bool traverse(const_node_stack &node_stack_,
+        bool_stack &perform_op_stack_) const = 0;
+
+    node_vector &firstpos()
+    {
+        return _firstpos;
+    }
+
+    const node_vector &firstpos() const
+    {
+        return _firstpos;
+    }
+
+    // _lastpos modified externally, so not const &
+    node_vector &lastpos()
+    {
+        return _lastpos;
+    }
+
+    virtual bool end_state() const
+    {
+        return false;
+    }
+
+    virtual id_type id() const
+    {
+        throw runtime_error("Internal error node::id().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return id_type();
+#endif
+    }
+
+    virtual id_type user_id() const
+    {
+        throw runtime_error("Internal error node::user_id().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return id_type();
+#endif
+    }
+
+    virtual id_type next_dfa() const
+    {
+        throw runtime_error("Internal error node::next_dfa().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return id_type();
+#endif
+    }
+
+    virtual id_type push_dfa() const
+    {
+        throw runtime_error("Internal error node::push_dfa().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return id_type();
+#endif
+    }
+
+    virtual bool pop_dfa() const
+    {
+        throw runtime_error("Internal error node::pop_dfa().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return false;
+#endif
+    }
+
+    virtual id_type token() const
+    {
+        throw runtime_error("Internal error node::token().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return id_type();
+#endif
+    }
+
+    virtual void greedy(const bool /*greedy_*/)
+    {
+        throw runtime_error("Internal error node::greedy(bool).");
+    }
+
+    virtual bool greedy() const
+    {
+        throw runtime_error("Internal error node::greedy().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return false;
+#endif
+    }
+
+    virtual const node_vector &followpos() const
+    {
+        throw runtime_error("Internal error node::followpos().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return firstpos;
+#endif
+    }
+
+    virtual node_vector &followpos()
+    {
+        throw runtime_error("Internal error node::followpos().");
+#ifdef __SUNPRO_CC
+        // Stop bogus Solaris compiler warning
+        return firstpos;
+#endif
+    }
+
+protected:
+    const bool _nullable;
+    node_vector _firstpos;
+    node_vector _lastpos;
+
+    virtual void copy_node(node_ptr_vector &node_ptr_vector_,
+        node_stack &new_node_stack_, bool_stack &perform_op_stack_,
+        bool &down_) const = 0;
+
+private:
+    // No copy construction.
+    basic_node(const basic_node &) = delete;
+    // No assignment.
+    const basic_node &operator =(const basic_node &) = delete;
+};
+}
+}
+
+#endif