1 files changed, 216 insertions, 215 deletions

diff --git a/src/MoonP/ast.hpp b/src/MoonP/ast.hpp
index 38141e2..8bcfc21 100644
--- a/src/MoonP/ast.hpp
+++ b/src/MoonP/ast.hpp
@@ -1,12 +1,13 @@
 /* Copyright (c) 2012, Achilleas Margaritis, modified by Jin Li
 All rights reserved.
 
-        Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 
-        Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-        Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.*/
 
 #pragma once
 
@@ -28,7 +29,7 @@ template <class T> class ast;
 
 
 /** type of AST node stack.
- */
+*/
 typedef std::vector<ast_node*> ast_stack;
 typedef std::list<ast_node*> node_container;
 
@@ -47,7 +48,7 @@ enum class traversal {
 };
 
 /** Base class for AST nodes.
- */
+*/
 class ast_node : public input_range {
 public:
         ast_node() : _ref(0) {}
@@ -63,14 +64,14 @@ public:
                 }
         }
 
-    /** interface for filling the contents of the node
-        from a node stack.
-        @param st stack.
-     */
-    virtual void construct(ast_stack&) {}
+        /** interface for filling the contents of the node
+                from a node stack.
+                @param st stack.
+        */
+        virtual void construct(ast_stack&) {}
 
-    /** interface for visiting AST tree use.
-     */
+        /** interface for visiting AST tree use.
+        */
         virtual traversal traverse(const std::function<traversal (ast_node*)>& func);
 
         template <typename... Ts>
@@ -128,12 +129,12 @@ bool ast_is(ast_node* node) {
 class ast_member;
 
 /** type of ast member vector.
- */
+*/
 typedef std::vector<ast_member*> ast_member_vector;
 
 
 /** base class for AST nodes with children.
- */
+*/
 class ast_container : public ast_node {
 public:
         void add_members(std::initializer_list<ast_member*> members) {
@@ -142,42 +143,42 @@ public:
                 }
         }
 
-    /** returns the vector of AST members.
-        @return the vector of AST members.
-     */
-    const ast_member_vector& members() const {
-        return m_members;
-    }
+        /** returns the vector of AST members.
+                @return the vector of AST members.
+        */
+        const ast_member_vector& members() const {
+                return m_members;
+        }
 
-    /** Asks all members to construct themselves from the stack.
-        The members are asked to construct themselves in reverse order.
-        from a node stack.
-        @param st stack.
-     */
-    virtual void construct(ast_stack& st) override;
+        /** Asks all members to construct themselves from the stack.
+                The members are asked to construct themselves in reverse order.
+                from a node stack.
+                @param st stack.
+        */
+        virtual void construct(ast_stack& st) override;
 
         virtual traversal traverse(const std::function<traversal (ast_node*)>& func) override;
 
         virtual bool visitChild(const std::function<bool (ast_node*)>& func) override;
 private:
-    ast_member_vector m_members;
+        ast_member_vector m_members;
 
-    friend class ast_member;
+        friend class ast_member;
 };
 
 
 /** Base class for children of ast_container.
- */
+*/
 class ast_member {
 public:
-    virtual ~ast_member() {}
+        virtual ~ast_member() {}
 
-    /** interface for filling the the member from a node stack.
-        @param st stack.
-     */
-    virtual void construct(ast_stack& st) = 0;
+        /** interface for filling the the member from a node stack.
+                @param st stack.
+        */
+        virtual void construct(ast_stack& st) = 0;
 
-    virtual bool accept(ast_node* node) = 0;
+        virtual bool accept(ast_node* node) = 0;
 
         virtual int get_type() { return ast_type<ast_member>(); }
 };
@@ -193,12 +194,12 @@ public:
                 if (node) node->retain();
         }
 
-    virtual ~_ast_ptr() {
-        if (m_ptr) {
-                m_ptr->release();
-                m_ptr = nullptr;
-        }
-    }
+        virtual ~_ast_ptr() {
+                if (m_ptr) {
+                        m_ptr->release();
+                        m_ptr = nullptr;
+                }
+        }
 
         ast_node* get() const {
                 return m_ptr;
@@ -242,109 +243,109 @@ protected:
 };
 
 /** pointer to an AST object.
-    It assumes ownership of the object.
-    It pops an object of the given type from the stack.
-    @tparam Required if true, the object is required.
-    @tparam T type of object to control.
- */
+        It assumes ownership of the object.
+        It pops an object of the given type from the stack.
+        @tparam Required if true, the object is required.
+        @tparam T type of object to control.
+*/
 template <bool Required, class T> class ast_ptr : public _ast_ptr {
 public:
-    ast_ptr(T* node = nullptr) : _ast_ptr(node) {}
-
-    ast_ptr(const ast_ptr& other) : _ast_ptr(other.get()) {}
-
-    ast_ptr& operator=(const ast_ptr& other) {
-        set(other.get());
-        return *this;
-        }
-
-    /** gets the underlying ptr value.
-        @return the underlying ptr value.
-     */
-    T* get() const {
-        return static_cast<T*>(m_ptr);
-    }
-
-    /** auto conversion to the underlying object ptr.
-        @return the underlying ptr value.
-     */
-    operator T*() const {
-        return static_cast<T*>(m_ptr);
-    }
-
-    /** member access.
-        @return the underlying ptr value.
-     */
-    T* operator->() const {
-        assert(m_ptr);
-        return static_cast<T*>(m_ptr);
-    }
-
-    /** Pops a node from the stack.
-        @param st stack.
-        @exception std::logic_error thrown if the node is not of the appropriate type;
-            thrown only if Required == true or if the stack is empty.
-     */
-    virtual void construct(ast_stack& st) override {
-        // check the stack node
-        if (st.empty()) {
+        ast_ptr(T* node = nullptr) : _ast_ptr(node) {}
+
+        ast_ptr(const ast_ptr& other) : _ast_ptr(other.get()) {}
+
+        ast_ptr& operator=(const ast_ptr& other) {
+                set(other.get());
+                return *this;
+        }
+
+        /** gets the underlying ptr value.
+                @return the underlying ptr value.
+        */
+        T* get() const {
+                return static_cast<T*>(m_ptr);
+        }
+
+        /** auto conversion to the underlying object ptr.
+                @return the underlying ptr value.
+        */
+        operator T*() const {
+                return static_cast<T*>(m_ptr);
+        }
+
+        /** member access.
+                @return the underlying ptr value.
+        */
+        T* operator->() const {
+                assert(m_ptr);
+                return static_cast<T*>(m_ptr);
+        }
+
+        /** Pops a node from the stack.
+                @param st stack.
+                @exception std::logic_error thrown if the node is not of the appropriate type;
+                        thrown only if Required == true or if the stack is empty.
+        */
+        virtual void construct(ast_stack& st) override {
+                // check the stack node
+                if (st.empty()) {
                         if (!Required) return;
                         throw std::logic_error("Invalid AST stack.");
                 }
-        ast_node* node = st.back();
+                ast_node* node = st.back();
                 if (!ast_ptr::accept(node)) {
                         // if the object is not required, simply return
                         if (!Required) return;
                         // else if the object is mandatory, throw an exception
                         throw std::logic_error("Invalid AST node.");
                 }
-        st.pop_back();
-        m_ptr = node;
-        node->retain();
-    }
+                st.pop_back();
+                m_ptr = node;
+                node->retain();
+        }
 private:
-    virtual bool accept(ast_node* node) override {
+        virtual bool accept(ast_node* node) override {
                 return node && (std::is_same<ast_node,T>() || ast_type<T>() == node->get_type());
         }
 };
 
 template <bool Required, class ...Args> class ast_sel : public _ast_ptr {
 public:
-    ast_sel() : _ast_ptr(nullptr) {}
+        ast_sel() : _ast_ptr(nullptr) {}
 
-    ast_sel(const ast_sel& other) : _ast_ptr(other.get()) {}
+        ast_sel(const ast_sel& other) : _ast_ptr(other.get()) {}
 
-    ast_sel& operator=(const ast_sel& other) {
-        set(other.get());
-        return *this;
+        ast_sel& operator=(const ast_sel& other) {
+                set(other.get());
+                return *this;
         }
 
-    operator ast_node*() const {
-        return m_ptr;
-    }
+        operator ast_node*() const {
+                return m_ptr;
+        }
 
-    ast_node* operator->() const {
-        assert(m_ptr);
-        return m_ptr;
-    }
+        ast_node* operator->() const {
+                assert(m_ptr);
+                return m_ptr;
+        }
 
-    virtual void construct(ast_stack& st) override {
-        if (st.empty()) {
-                if (!Required) return;
+        virtual void construct(ast_stack& st) override {
+                if (st.empty()) {
+                        if (!Required) return;
                         throw std::logic_error("Invalid AST stack.");
                 }
-        ast_node* node = st.back();
-        if (!ast_sel::accept(node)) {
-                if (!Required) return;
-                throw std::logic_error("Invalid AST node.");
+                ast_node* node = st.back();
+                if (!ast_sel::accept(node)) {
+                        if (!Required) return;
+                        throw std::logic_error("Invalid AST node.");
                 }
-        st.pop_back();
-        m_ptr = node;
-        node->retain();
-    }
+                st.pop_back();
+                m_ptr = node;
+                node->retain();
+        }
 private:
-    virtual bool accept(ast_node* node) override {
-        if (!node) return false;
+        virtual bool accept(ast_node* node) override {
+                if (!node) return false;
                 using swallow = bool[];
                 bool result = false;
                 (void)swallow{result || (result = ast_type<Args>() == node->get_type())...};
@@ -355,8 +356,8 @@ private:
 class _ast_list : public ast_member {
 public:
    ~_ast_list() {
-        clear();
-    }
+                clear();
+        }
 
         inline ast_node* back() const {
                 return m_objects.back();
@@ -374,14 +375,14 @@ public:
                 return m_objects.empty();
         }
 
-    void push_back(ast_node* node) {
-        assert(node && accept(node));
+        void push_back(ast_node* node) {
+                assert(node && accept(node));
                 m_objects.push_back(node);
                 node->retain();
         }
 
-    void push_front(ast_node* node) {
-        assert(node && accept(node));
+        void push_front(ast_node* node) {
+                assert(node && accept(node));
                 m_objects.push_front(node);
                 node->retain();
         }
@@ -399,22 +400,22 @@ public:
         }
 
          const node_container& objects() const {
-        return m_objects;
-    }
-
-    void clear() {
-        for(ast_node* obj : m_objects) {
-            if (obj) obj->release();
-        }
-        m_objects.clear();
-    }
-
-    void dup(const _ast_list& src) {
-        for(ast_node* obj : src.m_objects) {
-            m_objects.push_back(obj);
-            obj->retain();
-        }
-    }
+                return m_objects;
+        }
+
+        void clear() {
+                for(ast_node* obj : m_objects) {
+                        if (obj) obj->release();
+                }
+                m_objects.clear();
+        }
+
+        void dup(const _ast_list& src) {
+                for(ast_node* obj : src.m_objects) {
+                        m_objects.push_back(obj);
+                        obj->retain();
+                }
+        }
 
         virtual int get_type() override { return ast_type<_ast_list>(); }
 protected:
@@ -422,50 +423,50 @@ protected:
 };
 
 /** A list of objects.
-    It pops objects of the given type from the ast stack, until no more objects can be popped.
-    It assumes ownership of objects.
-    @tparam Required if true, the object is required.
-    @tparam T type of object to control.
- */
+        It pops objects of the given type from the ast stack, until no more objects can be popped.
+        It assumes ownership of objects.
+        @tparam Required if true, the object is required.
+        @tparam T type of object to control.
+*/
 template <bool Required, class T> class ast_list : public _ast_list {
 public:
         ast_list() { }
 
-    ast_list(const ast_list& other) {
-        dup(other);
+        ast_list(const ast_list& other) {
+                dup(other);
         }
 
-    ast_list& operator=(const ast_list& other) {
-        clear();
-        dup(other);
-        return *this;
+        ast_list& operator=(const ast_list& other) {
+                clear();
+                dup(other);
+                return *this;
         }
 
-    /** Pops objects of type T from the stack until no more objects can be popped.
-        @param st stack.
-     */
-    virtual void construct(ast_stack &st) override {
-        while (!st.empty()) {
-            ast_node* node = st.back();
-            // if the object was not not of the appropriate type,
-            // end the list parsing
-            if (!ast_list::accept(node)) {
-                if (Required && m_objects.empty()) {
-                        throw std::logic_error("Invalid AST node.");
+        /** Pops objects of type T from the stack until no more objects can be popped.
+                @param st stack.
+        */
+        virtual void construct(ast_stack &st) override {
+                while (!st.empty()) {
+                        ast_node* node = st.back();
+                        // if the object was not not of the appropriate type,
+                        // end the list parsing
+                        if (!ast_list::accept(node)) {
+                                if (Required && m_objects.empty()) {
+                                        throw std::logic_error("Invalid AST node.");
                                 }
-                return;
-            }
-            st.pop_back();
-            // insert the object in the list, in reverse order
-            m_objects.push_front(node);
-            node->retain();
-        }
+                                return;
+                        }
+                        st.pop_back();
+                        // insert the object in the list, in reverse order
+                        m_objects.push_front(node);
+                        node->retain();
+                }
                 if (Required && m_objects.empty()) {
                         throw std::logic_error("Invalid AST stack.");
                 }
-    }
+        }
 private:
-    virtual bool accept(ast_node* node) override {
+        virtual bool accept(ast_node* node) override {
                 return node && (std::is_same<ast_node,T>() || ast_type<T>() == node->get_type());
         }
 };
@@ -474,36 +475,36 @@ template <bool Required, class ...Args> class ast_sel_list : public _ast_list {
 public:
         ast_sel_list() { }
 
-    ast_sel_list(const ast_sel_list& other) {
-        dup(other);
+        ast_sel_list(const ast_sel_list& other) {
+                dup(other);
         }
 
-    ast_sel_list& operator=(const ast_sel_list& other) {
-        clear();
-        dup(other);
-        return *this;
+        ast_sel_list& operator=(const ast_sel_list& other) {
+                clear();
+                dup(other);
+                return *this;
         }
 
-    virtual void construct(ast_stack &st) override {
-        while (!st.empty()) {
-            ast_node* node = st.back();
-            if (!ast_sel_list::accept(node)) {
-                if (Required && m_objects.empty()) {
-                        throw std::logic_error("Invalid AST node.");
+        virtual void construct(ast_stack &st) override {
+                while (!st.empty()) {
+                        ast_node* node = st.back();
+                        if (!ast_sel_list::accept(node)) {
+                                if (Required && m_objects.empty()) {
+                                        throw std::logic_error("Invalid AST node.");
                                 }
-                return;
-            }
-            st.pop_back();
-            m_objects.push_front(node);
-            node->retain();
-        }
+                                return;
+                        }
+                        st.pop_back();
+                        m_objects.push_front(node);
+                        node->retain();
+                }
                 if (Required && m_objects.empty()) {
                         throw std::logic_error("Invalid AST stack.");
                 }
-    }
+        }
 private:
-    virtual bool accept(ast_node* node) override {
-        if (!node) return false;
+        virtual bool accept(ast_node* node) override {
+                if (!node) return false;
                 using swallow = bool[];
                 bool result = false;
                 (void)swallow{result || (result = ast_type<Args>() == node->get_type())...};
@@ -512,37 +513,37 @@ private:
 };
 
 /** AST function which creates an object of type T
-    and pushes it to the node stack.
- */
+        and pushes it to the node stack.
+*/
 template <class T> class ast {
 public:
-    /** constructor.
-        @param r rule to attach the AST function to.
-     */
-    ast(rule& r) {
-        r.set_parse_proc(&_parse_proc);
-    }
+        /** constructor.
+                @param r rule to attach the AST function to.
+        */
+        ast(rule& r) {
+                r.set_parse_proc(&_parse_proc);
+        }
 private:
-    //parse proc
-    static void _parse_proc(const pos& b, const pos& e, void* d) {
-        ast_stack* st = reinterpret_cast<ast_stack*>(d);
-        T* obj = new T;
-        obj->m_begin = b;
-        obj->m_end = e;
-        obj->construct(*st);
-        st->push_back(obj);
-    }
+        //parse proc
+        static void _parse_proc(const pos& b, const pos& e, void* d) {
+                ast_stack* st = reinterpret_cast<ast_stack*>(d);
+                T* obj = new T;
+                obj->m_begin = b;
+                obj->m_end = e;
+                obj->construct(*st);
+                st->push_back(obj);
+        }
 };
 
 
 /** parses the given input.
-    @param i input.
-    @param g root rule of grammar.
-    @param el list of errors.
-    @param ud user data, passed to the parse procedures.
-    @return pointer to ast node created, or null if there was an error.
-        The return object must be deleted by the caller.
- */
+        @param i input.
+        @param g root rule of grammar.
+        @param el list of errors.
+        @param ud user data, passed to the parse procedures.
+        @return pointer to ast node created, or null if there was an error.
+                The return object must be deleted by the caller.
+*/
 ast_node* parse(input& i, rule& g, error_list& el, void* ud);