5 files changed, 1461 insertions, 1470 deletions

diff --git a/src/MoonP/ast.cpp b/src/MoonP/ast.cpp
index 7cdefba..71c90c5 100644
--- a/src/MoonP/ast.cpp
+++ b/src/MoonP/ast.cpp
@@ -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.*/
 
 #include <cassert>
 #include "MoonP/ast.hpp"
@@ -48,20 +49,20 @@ bool ast_node::visitChild(const std::function<bool (ast_node*)>&) {
         return false;
 }
 
-    
+        
 /** 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.
- */
+        The members are asked to construct themselves in reverse order.
+        from a node stack.
+        @param st stack.
+*/
 void ast_container::construct(ast_stack &st) {
-    for(ast_member_vector::reverse_iterator it = m_members.rbegin();
-        it != m_members.rend();
-        ++it)
-    {
-        ast_member* member = *it;
-        member->construct(st);
-    }
+        for(ast_member_vector::reverse_iterator it = m_members.rbegin();
+                it != m_members.rend();
+                ++it)
+        {
+                ast_member* member = *it;
+                member->construct(st);
+        }
 }
 
 traversal ast_container::traverse(const std::function<traversal (ast_node*)>& func) {
@@ -108,24 +109,24 @@ bool ast_container::visitChild(const std::function<bool (ast_node*)>& func) {
 
 
 /** 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.
- */
-ast_node* parse(input &i, rule &g, error_list &el, void* ud) {
-    ast_stack st;
-    if (!parse(i, g, el, &st, ud)) {
-        for (auto node : st) {
-                delete node;
+        @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) {
+        ast_stack st;
+        if (!parse(i, g, el, &st, ud)) {
+                for (auto node : st) {
+                        delete node;
                 }
                 st.clear();
-        return nullptr;
+                return nullptr;
         }
-    assert(st.size() == 1);
-    return st.front();
+        assert(st.size() == 1);
+        return st.front();
 }
 
 
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);
 
 
diff --git a/src/MoonP/moon_compiler.cpp b/src/MoonP/moon_compiler.cpp
index d3e78ed..f74d056 100644
--- a/src/MoonP/moon_compiler.cpp
+++ b/src/MoonP/moon_compiler.cpp
@@ -4,7 +4,7 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/
 
 #include <string>
 #include <unordered_set>
diff --git a/src/MoonP/parser.cpp b/src/MoonP/parser.cpp
index cb896c2..07f6e41 100644
--- a/src/MoonP/parser.cpp
+++ b/src/MoonP/parser.cpp
@@ -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.*/
 
 #include <cstdlib>
 #include <cstring>
@@ -24,25 +25,25 @@ namespace parserlib {
 //internal private class that manages access to the public classes' internals.
 class _private {
 public:
-    //get the internal expression object from the expression.
-    static _expr *get_expr(const expr &e) {
-        return e.m_expr;
-    }
-
-    //create new expression from given expression
-    static expr construct_expr(_expr *e) {
-        return e;
-    }
-
-    //get the internal expression object from the rule.
-    static _expr *get_expr(rule &r) {
-        return r.m_expr;
-    }
-
-    //get the internal parse proc from the rule.
-    static parse_proc get_parse_proc(rule &r) {
-        return r.m_parse_proc;
-    }
+        //get the internal expression object from the expression.
+        static _expr* get_expr(const expr& e) {
+                return e.m_expr;
+        }
+
+        //create new expression from given expression
+        static expr construct_expr(_expr* e) {
+                return e;
+        }
+
+        //get the internal expression object from the rule.
+        static _expr* get_expr(rule& r) {
+                return r.m_expr;
+        }
+
+        //get the internal parse proc from the rule.
+        static parse_proc get_parse_proc(rule& r) {
+                return r.m_parse_proc;
+        }
 };
 
 
@@ -52,39 +53,39 @@ class _context;
 //parser state
 class _state {
 public:
-    //position
-    pos m_pos;
+        //position
+        pos m_pos;
 
-    //size of match vector
-    size_t m_matches;
+        //size of match vector
+        size_t m_matches;
 
-    //constructor
-    _state(_context &con);
+        //constructor
+        _state(_context& con);
 };
 
 
 //match
 class _match {
 public:
-    //rule matched
-    rule *m_rule;
+        //rule matched
+        rule* m_rule;
 
-    //begin position
-    pos m_begin;
+        //begin position
+        pos m_begin;
 
-    //end position
-    pos m_end;
+        //end position
+        pos m_end;
 
-    //null constructor
-    _match() {}
+        //null constructor
+        _match() {}
 
-    //constructor from parameters
-    _match(rule *r, const pos &b, const pos &e) :
-        m_rule(r),
-        m_begin(b),
-        m_end(e)
-    {
-    }
+        //constructor from parameters
+        _match(rule* r, const pos& b, const pos& e) :
+                m_rule(r),
+                m_begin(b),
+                m_end(e)
+        {
+        }
 };
 
 
@@ -98,226 +99,226 @@ public:
         //user data
         void* m_user_data;
 
-    //current position
-    pos m_pos;
-
-    //error position
-    pos m_error_pos;
-
-    //input begin
-    input::iterator m_begin;
-
-    //input end
-    input::iterator m_end;
-
-    //matches
-    _match_vector m_matches;
-
-    //constructor
-    _context(input &i, void* ud) :
-        m_user_data(ud),
-        m_pos(i),
-        m_error_pos(i),
-        m_begin(i.begin()),
-        m_end(i.end())
-    {
-    }
-
-    //check if the end is reached
-    bool end() const {
-        return m_pos.m_it == m_end;
-    }
-
-    //get the current symbol
-    input::value_type symbol() const {
-        assert(!end());
-        return *m_pos.m_it;
-    }
-
-    //set the longest possible error
-    void set_error_pos() {
-        if (m_pos.m_it > m_error_pos.m_it) {
-            m_error_pos = m_pos;
-        }
-    }
-
-    //next column
-    void next_col() {
-        ++m_pos.m_it;
-        ++m_pos.m_col;
-    }
-
-    //next line
-    void next_line() {
-        ++m_pos.m_line;
-        m_pos.m_col = 1;
-    }
-
-    //restore the state
-    void restore(const _state &st) {
-        m_pos = st.m_pos;
-        m_matches.resize(st.m_matches);
-    }
-
-    //parse non-term rule.
-    bool parse_non_term(rule &r);
-
-    //parse term rule.
-    bool parse_term(rule &r);
-
-    //execute all the parse procs
-    void do_parse_procs(void *d) const {
-        for(_match_vector::const_iterator it = m_matches.begin();
-            it != m_matches.end();
-            ++it)
-        {
-            const _match &m = *it;
-            parse_proc p = _private::get_parse_proc(*m.m_rule);
-            p(m.m_begin, m.m_end, d);
-        }
-    }
+        //current position
+        pos m_pos;
+
+        //error position
+        pos m_error_pos;
+
+        //input begin
+        input::iterator m_begin;
+
+        //input end
+        input::iterator m_end;
+
+        //matches
+        _match_vector m_matches;
+
+        //constructor
+        _context(input& i, void* ud) :
+                m_user_data(ud),
+                m_pos(i),
+                m_error_pos(i),
+                m_begin(i.begin()),
+                m_end(i.end())
+        {
+        }
+
+        //check if the end is reached
+        bool end() const {
+                return m_pos.m_it == m_end;
+        }
+
+        //get the current symbol
+        input::value_type symbol() const {
+                assert(!end());
+                return *m_pos.m_it;
+        }
+
+        //set the longest possible error
+        void set_error_pos() {
+                if (m_pos.m_it > m_error_pos.m_it) {
+                        m_error_pos = m_pos;
+                }
+        }
+
+        //next column
+        void next_col() {
+                ++m_pos.m_it;
+                ++m_pos.m_col;
+        }
+
+        //next line
+        void next_line() {
+                ++m_pos.m_line;
+                m_pos.m_col = 1;
+        }
+
+        //restore the state
+        void restore(const _state& st) {
+                m_pos = st.m_pos;
+                m_matches.resize(st.m_matches);
+        }
+
+        //parse non-term rule.
+        bool parse_non_term(rule& r);
+
+        //parse term rule.
+        bool parse_term(rule& r);
+
+        //execute all the parse procs
+        void do_parse_procs(void* d) const {
+                for(_match_vector::const_iterator it = m_matches.begin();
+                        it != m_matches.end();
+                        ++it)
+                {
+                        const _match &m = *it;
+                        parse_proc p = _private::get_parse_proc(*m.m_rule);
+                        p(m.m_begin, m.m_end, d);
+                }
+        }
 
 private:
-    //parse non-term rule.
-    bool _parse_non_term(rule &r);
+        //parse non-term rule.
+        bool _parse_non_term(rule& r);
 
-    //parse term rule.
-    bool _parse_term(rule &r);
+        //parse term rule.
+        bool _parse_term(rule& r);
 };
 
 
 //base class for expressions
 class _expr {
 public:
-    //destructor.
-    virtual ~_expr() {
-    }
+        //destructor.
+        virtual ~_expr() {
+        }
 
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const = 0;
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const = 0;
 
-    //parse terminal
-    virtual bool parse_term(_context &con) const = 0;
+        //parse terminal
+        virtual bool parse_term(_context& con) const = 0;
 };
 
 
 //single character expression.
 class _char : public _expr {
 public:
-    //constructor.
-    _char(char c) :
-        m_char(c)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        return _parse(con);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        return _parse(con);
-    }
+        //constructor.
+        _char(char c) :
+                m_char(c)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                return _parse(con);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                return _parse(con);
+        }
 
 private:
-    //character
-    input::value_type m_char;
-
-    //internal parse
-    bool _parse(_context &con) const {
-        if (!con.end()) {
-            input::value_type ch = con.symbol();
-            if (ch == m_char) {
-                con.next_col();
-                return true;
-            }
-        }
-        con.set_error_pos();
-        return false;
-    }
+        //character
+        input::value_type m_char;
+
+        //internal parse
+        bool _parse(_context& con) const {
+                if (!con.end()) {
+                        input::value_type ch = con.symbol();
+                        if (ch == m_char) {
+                                con.next_col();
+                                return true;
+                        }
+                }
+                con.set_error_pos();
+                return false;
+        }
 };
 
 
 //string expression.
 class _string : public _expr {
 public:
-    //constructor from ansi string.
-    _string(const char *s) :
-        m_string(Converter{}.from_bytes(s))
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        return _parse(con);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        return _parse(con);
-    }
+        //constructor from ansi string.
+        _string(const char* s) :
+                m_string(Converter{}.from_bytes(s))
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                return _parse(con);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                return _parse(con);
+        }
 
 private:
-    //string
-    input m_string;
-
-    //parse the string
-    bool _parse(_context &con) const {
-        for(input::const_iterator it = m_string.begin(),
-            end = m_string.end();;)
-        {
-            if (it == end) return true;
-            if (con.end()) break;
-            if (con.symbol() != *it) break;
-            ++it;
-            con.next_col();
-        }
-        con.set_error_pos();
-        return false;
-    }
+        //string
+        input m_string;
+
+        //parse the string
+        bool _parse(_context& con) const {
+                for(input::const_iterator it = m_string.begin(),
+                        end = m_string.end();;)
+                {
+                        if (it == end) return true;
+                        if (con.end()) break;
+                        if (con.symbol() != *it) break;
+                        ++it;
+                        con.next_col();
+                }
+                con.set_error_pos();
+                return false;
+        }
 };
 
 
 //set expression.
 class _set : public _expr {
 public:
-    //constructor from ansi string.
-    _set(const char *s) {
-        auto str = Converter{}.from_bytes(s);
-        for (auto ch : str) {
-                 _add(ch);
-        }
-    }
-
-    //constructor from range.
-    _set(int min, int max) {
-        assert(min >= 0);
-        assert(min <= max);
-        m_quick_set.resize((size_t)max + 1U);
-        for(; min <= max; ++min) {
-            m_quick_set[(size_t)min] = true;
-        }
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        return _parse(con);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        return _parse(con);
-    }
+        //constructor from ansi string.
+        _set(const char* s) {
+                auto str = Converter{}.from_bytes(s);
+                for (auto ch : str) {
+                         _add(ch);
+                }
+        }
+
+        //constructor from range.
+        _set(int min, int max) {
+                assert(min >= 0);
+                assert(min <= max);
+                m_quick_set.resize((size_t)max + 1U);
+                for(; min <= max; ++min) {
+                        m_quick_set[(size_t)min] = true;
+                }
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                return _parse(con);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                return _parse(con);
+        }
 
 private:
-    //set is kept as an array of flags, for quick access
-    std::vector<bool> m_quick_set;
-    std::unordered_set<size_t> m_large_set;
+        //set is kept as an array of flags, for quick access
+        std::vector<bool> m_quick_set;
+        std::unordered_set<size_t> m_large_set;
 
-    //add character
-    void _add(size_t i) {
-        if (i <= m_quick_set.size() || i <= 255) {
+        //add character
+        void _add(size_t i) {
+                if (i <= m_quick_set.size() || i <= 255) {
                         if (i >= m_quick_set.size()) {
                                 m_quick_set.resize(i + 1);
                         }
@@ -325,66 +326,66 @@ private:
                 } else {
                         m_large_set.insert(i);
                 }
-    }
-
-    //internal parse
-    bool _parse(_context &con) const {
-        if (!con.end()) {
-            size_t ch = con.symbol();
-            if (ch < m_quick_set.size()) {
-                if (m_quick_set[ch]) {
+        }
+
+        //internal parse
+        bool _parse(_context& con) const {
+                if (!con.end()) {
+                        size_t ch = con.symbol();
+                        if (ch < m_quick_set.size()) {
+                                if (m_quick_set[ch]) {
                                         con.next_col();
                                         return true;
                                 }
                         } else if (m_large_set.find(ch) != m_large_set.end()) {
-                con.next_col();
-                return true;
-            }
+                                con.next_col();
+                                return true;
+                        }
                 }
-        con.set_error_pos();
-        return false;
-    }
+                con.set_error_pos();
+                return false;
+        }
 };
 
 
 //base class for unary expressions
 class _unary : public _expr {
 public:
-    //constructor.
-    _unary(_expr *e) :
-        m_expr(e)
-    {
-    }
+        //constructor.
+        _unary(_expr* e) :
+                m_expr(e)
+        {
+        }
 
-    //destructor.
-    virtual ~_unary() {
-        delete m_expr;
-    }
+        //destructor.
+        virtual ~_unary() {
+                delete m_expr;
+        }
 
 protected:
-    //expression
-    _expr *m_expr;
+        //expression
+        _expr *m_expr;
 };
 
 
 //terminal
 class _term : public _unary {
 public:
-    //constructor.
-    _term(_expr *e) :
-        _unary(e)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        return m_expr->parse_term(con);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        return m_expr->parse_term(con);
-    }
+        //constructor.
+        _term(_expr* e) :
+                _unary(e)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                return m_expr->parse_term(con);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                return m_expr->parse_term(con);
+        }
 };
 
 
@@ -392,14 +393,14 @@ public:
 class _user : public _unary {
 public:
         //constructor.
-        _user(_expr *e, const user_handler &callback) :
+        _user(_expr* e, const user_handler& callback) :
                 _unary(e),
                 m_handler(callback)
         {
         }
 
         //parse with whitespace
-        virtual bool parse_non_term(_context &con) const {
+        virtual bool parse_non_term(_context& con) const {
                 pos pos = con.m_pos;
                 if (m_expr->parse_non_term(con)) {
                         item_t item = {pos.m_it, con.m_pos.m_it, con.m_user_data};
@@ -409,7 +410,7 @@ public:
         }
 
         //parse terminal
-        virtual bool parse_term(_context &con) const {
+        virtual bool parse_term(_context& con) const {
                 pos pos = con.m_pos;
                 if (m_expr->parse_term(con)) {
                         item_t item = {pos.m_it, con.m_pos.m_it, con.m_user_data};
@@ -425,333 +426,333 @@ private:
 //loop 0
 class _loop0 : public _unary {
 public:
-    //constructor.
-    _loop0(_expr *e) :
-        _unary(e)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        //if parsing of the first fails, restore the context and stop
-        _state st(con);
-        if (!m_expr->parse_non_term(con)) {
-            con.restore(st);
-            return true;
-        }
-
-        //parse the rest
-        for(;;) {
-            _state st(con);
-            if (!m_expr->parse_non_term(con)) {
-                con.restore(st);
-                break;
-            }
-        }
-
-        return true;
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        //if parsing of the first fails, restore the context and stop
-        _state st(con);
-        if (!m_expr->parse_term(con)) {
-            con.restore(st);
-            return true;
-        }
-
-        //parse the rest until no more parsing is possible
-        for(;;) {
-            _state st(con);
-            if (!m_expr->parse_term(con)) {
-                con.restore(st);
-                break;
-            }
-        }
-
-        return true;
-    }
+        //constructor.
+        _loop0(_expr* e) :
+                _unary(e)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                //if parsing of the first fails, restore the context and stop
+                _state st(con);
+                if (!m_expr->parse_non_term(con)) {
+                        con.restore(st);
+                        return true;
+                }
+
+                //parse the rest
+                for(;;) {
+                        _state st(con);
+                        if (!m_expr->parse_non_term(con)) {
+                                con.restore(st);
+                                break;
+                        }
+                }
+
+                return true;
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                //if parsing of the first fails, restore the context and stop
+                _state st(con);
+                if (!m_expr->parse_term(con)) {
+                        con.restore(st);
+                        return true;
+                }
+
+                //parse the rest until no more parsing is possible
+                for(;;) {
+                        _state st(con);
+                        if (!m_expr->parse_term(con)) {
+                                con.restore(st);
+                                break;
+                        }
+                }
+
+                return true;
+        }
 };
 
 
 //loop 1
 class _loop1 : public _unary {
 public:
-    //constructor.
-    _loop1(_expr *e) :
-        _unary(e)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        //parse the first; if the first fails, stop
-        if (!m_expr->parse_non_term(con)) return false;
-
-        //parse the rest until no more parsing is possible
-        for(;;) {
-            _state st(con);
-            if (!m_expr->parse_non_term(con)) {
-                con.restore(st);
-                break;
-            }
-        }
-
-        return true;
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        //parse the first; if the first fails, stop
-        if (!m_expr->parse_term(con)) return false;
-
-        //parse the rest until no more parsing is possible
-        for(;;) {
-            _state st(con);
-            if (!m_expr->parse_term(con)) {
-                con.restore(st);
-                break;
-            }
-        }
-
-        return true;
-    }
+        //constructor.
+        _loop1(_expr* e) :
+                _unary(e)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                //parse the first; if the first fails, stop
+                if (!m_expr->parse_non_term(con)) return false;
+
+                //parse the rest until no more parsing is possible
+                for(;;) {
+                        _state st(con);
+                        if (!m_expr->parse_non_term(con)) {
+                                con.restore(st);
+                                break;
+                        }
+                }
+
+                return true;
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                //parse the first; if the first fails, stop
+                if (!m_expr->parse_term(con)) return false;
+
+                //parse the rest until no more parsing is possible
+                for(;;) {
+                        _state st(con);
+                        if (!m_expr->parse_term(con)) {
+                                con.restore(st);
+                                break;
+                        }
+                }
+
+                return true;
+        }
 };
 
 
 //optional
 class _optional : public _unary {
 public:
-    //constructor.
-    _optional(_expr *e) :
-        _unary(e)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        _state st(con);
-        if (!m_expr->parse_non_term(con)) con.restore(st);
-        return true;
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        _state st(con);
-        if (!m_expr->parse_term(con)) con.restore(st);
-        return true;
-    }
+        //constructor.
+        _optional(_expr* e) :
+                _unary(e)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                _state st(con);
+                if (!m_expr->parse_non_term(con)) con.restore(st);
+                return true;
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                _state st(con);
+                if (!m_expr->parse_term(con)) con.restore(st);
+                return true;
+        }
 };
 
 
 //and
 class _and : public _unary {
 public:
-    //constructor.
-    _and(_expr *e) :
-        _unary(e)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        _state st(con);
-        bool ok = m_expr->parse_non_term(con);
-        con.restore(st);
-        return ok;
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        _state st(con);
-        bool ok = m_expr->parse_term(con);
-        con.restore(st);
-        return ok;
-    }
+        //constructor.
+        _and(_expr* e) :
+                _unary(e)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                _state st(con);
+                bool ok = m_expr->parse_non_term(con);
+                con.restore(st);
+                return ok;
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                _state st(con);
+                bool ok = m_expr->parse_term(con);
+                con.restore(st);
+                return ok;
+        }
 };
 
 
 //not
 class _not : public _unary {
 public:
-    //constructor.
-    _not(_expr *e) :
-        _unary(e)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        _state st(con);
-        bool ok = !m_expr->parse_non_term(con);
-        con.restore(st);
-        return ok;
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        _state st(con);
-        bool ok = !m_expr->parse_term(con);
-        con.restore(st);
-        return ok;
-    }
+        //constructor.
+        _not(_expr* e) :
+                _unary(e)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                _state st(con);
+                bool ok = !m_expr->parse_non_term(con);
+                con.restore(st);
+                return ok;
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                _state st(con);
+                bool ok = !m_expr->parse_term(con);
+                con.restore(st);
+                return ok;
+        }
 };
 
 
 //newline
 class _nl : public _unary {
 public:
-    //constructor.
-    _nl(_expr *e) :
-        _unary(e)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        if (!m_expr->parse_non_term(con)) return false;
-        con.next_line();
-        return true;
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        if (!m_expr->parse_term(con)) return false;
-        con.next_line();
-        return true;
-    }
+        //constructor.
+        _nl(_expr* e) :
+                _unary(e)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                if (!m_expr->parse_non_term(con)) return false;
+                con.next_line();
+                return true;
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                if (!m_expr->parse_term(con)) return false;
+                con.next_line();
+                return true;
+        }
 };
 
 
 //base class for binary expressions
 class _binary : public _expr {
 public:
-    //constructor.
-    _binary(_expr *left, _expr *right) :
-        m_left(left), m_right(right)
-    {
-    }
-
-    //destructor.
-    virtual ~_binary() {
-        delete m_left;
-        delete m_right;
-    }
+        //constructor.
+        _binary(_expr* left, _expr* right) :
+                m_left(left), m_right(right)
+        {
+        }
+
+        //destructor.
+        virtual ~_binary() {
+                delete m_left;
+                delete m_right;
+        }
 
 protected:
-    //left and right expressions
-    _expr *m_left, *m_right;
+        //left and right expressions
+        _expr* m_left, *m_right;
 };
 
 
 //sequence
 class _seq : public _binary {
 public:
-    //constructor.
-    _seq(_expr *left, _expr *right) :
-        _binary(left, right)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        if (!m_left->parse_non_term(con)) return false;
-        return m_right->parse_non_term(con);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        if (!m_left->parse_term(con)) return false;
-        return m_right->parse_term(con);
-    }
+        //constructor.
+        _seq(_expr* left, _expr* right) :
+                _binary(left, right)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                if (!m_left->parse_non_term(con)) return false;
+                return m_right->parse_non_term(con);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                if (!m_left->parse_term(con)) return false;
+                return m_right->parse_term(con);
+        }
 };
 
 
 //choice
 class _choice : public _binary {
 public:
-    //constructor.
-    _choice(_expr *left, _expr *right) :
-        _binary(left, right)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        _state st(con);
-        if (m_left->parse_non_term(con)) return true;
-        con.restore(st);
-        return m_right->parse_non_term(con);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        _state st(con);
-        if (m_left->parse_term(con)) return true;
-        con.restore(st);
-        return m_right->parse_term(con);
-    }
+        //constructor.
+        _choice(_expr* left, _expr* right) :
+                _binary(left, right)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                _state st(con);
+                if (m_left->parse_non_term(con)) return true;
+                con.restore(st);
+                return m_right->parse_non_term(con);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                _state st(con);
+                if (m_left->parse_term(con)) return true;
+                con.restore(st);
+                return m_right->parse_term(con);
+        }
 };
 
 
 //reference to rule
 class _ref : public _expr {
 public:
-    //constructor.
-    _ref(rule &r) :
-        m_rule(r)
-    {
-    }
-
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        return con.parse_non_term(m_rule);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        return con.parse_term(m_rule);
-    }
+        //constructor.
+        _ref(rule& r) :
+                m_rule(r)
+        {
+        }
+
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                return con.parse_non_term(m_rule);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                return con.parse_term(m_rule);
+        }
 
 private:
-    //reference
-    rule &m_rule;
+        //reference
+        rule &m_rule;
 };
 
 
 //eof
 class _eof : public _expr {
 public:
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        return parse_term(con);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        return con.end();
-    }
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                return parse_term(con);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                return con.end();
+        }
 };
 
 
 //any
 class _any : public _expr {
 public:
-    //parse with whitespace
-    virtual bool parse_non_term(_context &con) const {
-        return parse_term(con);
-    }
-
-    //parse terminal
-    virtual bool parse_term(_context &con) const {
-        if (!con.end()) {
-            con.next_col();
-            return true;
-        }
-        con.set_error_pos();
-        return false;
-    }
+        //parse with whitespace
+        virtual bool parse_non_term(_context& con) const {
+                return parse_term(con);
+        }
+
+        //parse terminal
+        virtual bool parse_term(_context& con) const {
+                if (!con.end()) {
+                        con.next_col();
+                        return true;
+                }
+                con.set_error_pos();
+                return false;
+        }
 };
 
 
@@ -759,12 +760,12 @@ public:
 class _true : public _expr {
 public:
         //parse with whitespace
-        virtual bool parse_non_term(_context &) const {
+        virtual bool parse_non_term(_context&) const {
                 return true;
         }
 
         //parse terminal
-        virtual bool parse_term(_context &) const {
+        virtual bool parse_term(_context&) const {
                 return true;
         }
 };
@@ -774,600 +775,588 @@ public:
 class _false: public _expr {
 public:
         //parse with whitespace
-        virtual bool parse_non_term(_context &) const {
+        virtual bool parse_non_term(_context&) const {
                 return false;
         }
 
         //parse terminal
-        virtual bool parse_term(_context &) const {
+        virtual bool parse_term(_context&) const {
                 return false;
         }
 };
 
 //exception thrown when left recursion terminates successfully
 struct _lr_ok {
-    rule *m_rule;
-    _lr_ok(rule *r) : m_rule(r) {}
+        rule* m_rule;
+        _lr_ok(rule* r) : m_rule(r) {}
 };
 
 
 //constructor
-_state::_state(_context &con) :
-    m_pos(con.m_pos),
-    m_matches(con.m_matches.size())
+_state::_state(_context& con) :
+        m_pos(con.m_pos),
+        m_matches(con.m_matches.size())
 {
 }
 
 
 //parse non-term rule.
-bool _context::parse_non_term(rule &r) {
-    //save the state of the rule
-    rule::_state old_state = r.m_state;
-
-    //success/failure result
-    bool ok = false;
-
-    //compute the new position
-    size_t new_pos = m_pos.m_it - m_begin;
-
-    //check if we have left recursion
-    bool lr = new_pos == r.m_state.m_pos;
-
-    //update the rule's state
-    r.m_state.m_pos = new_pos;
-
-    //handle the mode of the rule
-    switch (r.m_state.m_mode) {
-        //normal parse
-        case rule::_PARSE:
-            if (lr) {
-                //first try to parse the rule by rejecting it, so alternative branches are examined
-                r.m_state.m_mode = rule::_REJECT;
-                ok = _parse_non_term(r);
-
-                //if the first try is successful, try accepting the rule,
-                //so other elements of the sequence are parsed
-                if (ok) {
-                    r.m_state.m_mode = rule::_ACCEPT;
-
-                    //loop until no more parsing can be done
-                    for(;;) {
-                        //store the correct state, in order to backtrack if the call fails
-                        _state st(*this);
-
-                        //update the rule position to the current position,
-                        //because at this state the rule is resolving the left recursion
-                        r.m_state.m_pos = m_pos.m_it - m_begin;
-
-                        //if parsing fails, restore the last good state and stop
-                        if (!_parse_non_term(r)) {
-                            restore(st);
-                            break;
-                        }
-                    }
-
-                    //since the left recursion was resolved successfully,
-                    //return via a non-local exit
-                    r.m_state = old_state;
-                    throw _lr_ok(r.this_ptr());
-                }
-            }
-            else {
-                try {
-                    ok = _parse_non_term(r);
-                }
-                catch (const _lr_ok &ex) {
-                    //since left recursions may be mutual, we must test which rule's left recursion
-                    //was ended successfully
-                    if (ex.m_rule == r.this_ptr()) {
-                        ok = true;
-                    }
-                    else {
-                        r.m_state = old_state;
-                        throw;
-                    }
-                }
-            }
-            break;
-
-        //reject the left recursive rule
-        case rule::_REJECT:
-            if (lr) {
-                ok = false;
-            }
-            else {
-                r.m_state.m_mode = rule::_PARSE;
-                ok = _parse_non_term(r);
-                r.m_state.m_mode = rule::_REJECT;
-            }
-            break;
-
-        //accept the left recursive rule
-        case rule::_ACCEPT:
-            if (lr) {
-                ok = true;
-            }
-            else {
-                r.m_state.m_mode = rule::_PARSE;
-                ok = _parse_non_term(r);
-                r.m_state.m_mode = rule::_ACCEPT;
-            }
-            break;
-    }
-
-    //restore the rule's state
-    r.m_state = old_state;
-
-    return ok;
+bool _context::parse_non_term(rule& r) {
+        //save the state of the rule
+        rule::_state old_state = r.m_state;
+
+        //success/failure result
+        bool ok = false;
+
+        //compute the new position
+        size_t new_pos = m_pos.m_it - m_begin;
+
+        //check if we have left recursion
+        bool lr = new_pos == r.m_state.m_pos;
+
+        //update the rule's state
+        r.m_state.m_pos = new_pos;
+
+        //handle the mode of the rule
+        switch (r.m_state.m_mode) {
+                //normal parse
+                case rule::_PARSE:
+                        if (lr) {
+                                //first try to parse the rule by rejecting it, so alternative branches are examined
+                                r.m_state.m_mode = rule::_REJECT;
+                                ok = _parse_non_term(r);
+
+                                //if the first try is successful, try accepting the rule,
+                                //so other elements of the sequence are parsed
+                                if (ok) {
+                                        r.m_state.m_mode = rule::_ACCEPT;
+
+                                        //loop until no more parsing can be done
+                                        for(;;) {
+                                                //store the correct state, in order to backtrack if the call fails
+                                                _state st(*this);
+
+                                                //update the rule position to the current position,
+                                                //because at this state the rule is resolving the left recursion
+                                                r.m_state.m_pos = m_pos.m_it - m_begin;
+
+                                                //if parsing fails, restore the last good state and stop
+                                                if (!_parse_non_term(r)) {
+                                                        restore(st);
+                                                        break;
+                                                }
+                                        }
+
+                                        //since the left recursion was resolved successfully,
+                                        //return via a non-local exit
+                                        r.m_state = old_state;
+                                        throw _lr_ok(r.this_ptr());
+                                }
+                        }
+                        else {
+                                try {
+                                        ok = _parse_non_term(r);
+                                }
+                                catch (const _lr_ok &ex) {
+                                        //since left recursions may be mutual, we must test which rule's left recursion
+                                        //was ended successfully
+                                        if (ex.m_rule == r.this_ptr()) {
+                                                ok = true;
+                                        }
+                                        else {
+                                                r.m_state = old_state;
+                                                throw;
+                                        }
+                                }
+                        }
+                        break;
+
+                //reject the left recursive rule
+                case rule::_REJECT:
+                        if (lr) {
+                                ok = false;
+                        }
+                        else {
+                                r.m_state.m_mode = rule::_PARSE;
+                                ok = _parse_non_term(r);
+                                r.m_state.m_mode = rule::_REJECT;
+                        }
+                        break;
+
+                //accept the left recursive rule
+                case rule::_ACCEPT:
+                        if (lr) {
+                                ok = true;
+                        }
+                        else {
+                                r.m_state.m_mode = rule::_PARSE;
+                                ok = _parse_non_term(r);
+                                r.m_state.m_mode = rule::_ACCEPT;
+                        }
+                        break;
+        }
+
+        //restore the rule's state
+        r.m_state = old_state;
+
+        return ok;
 }
 
 
 //parse term rule.
-bool _context::parse_term(rule &r) {
-    //save the state of the rule
-    rule::_state old_state = r.m_state;
-
-    //success/failure result
-    bool ok = false;
-
-    //compute the new position
-    size_t new_pos = m_pos.m_it - m_begin;
-
-    //check if we have left recursion
-    bool lr = new_pos == r.m_state.m_pos;
-
-    //update the rule's state
-    r.m_state.m_pos = new_pos;
-
-    //handle the mode of the rule
-    switch (r.m_state.m_mode) {
-        //normal parse
-        case rule::_PARSE:
-            if (lr) {
-                //first try to parse the rule by rejecting it, so alternative branches are examined
-                r.m_state.m_mode = rule::_REJECT;
-                ok = _parse_term(r);
-
-                //if the first try is successful, try accepting the rule,
-                //so other elements of the sequence are parsed
-                if (ok) {
-                    r.m_state.m_mode = rule::_ACCEPT;
-
-                    //loop until no more parsing can be done
-                    for(;;) {
-                        //store the correct state, in order to backtrack if the call fails
-                        _state st(*this);
-
-                        //update the rule position to the current position,
-                        //because at this state the rule is resolving the left recursion
-                        r.m_state.m_pos = m_pos.m_it - m_begin;
-
-                        //if parsing fails, restore the last good state and stop
-                        if (!_parse_term(r)) {
-                            restore(st);
-                            break;
-                        }
-                    }
-
-                    //since the left recursion was resolved successfully,
-                    //return via a non-local exit
-                    r.m_state = old_state;
-                    throw _lr_ok(r.this_ptr());
-                }
-            }
-            else {
-                try {
-                    ok = _parse_term(r);
-                }
-                catch (const _lr_ok &ex) {
-                    //since left recursions may be mutual, we must test which rule's left recursion
-                    //was ended successfully
-                    if (ex.m_rule == r.this_ptr()) {
-                        ok = true;
-                    }
-                    else {
-                        r.m_state = old_state;
-                        throw;
-                    }
-                }
-            }
-            break;
-
-        //reject the left recursive rule
-        case rule::_REJECT:
-            if (lr) {
-                ok = false;
-            }
-            else {
-                r.m_state.m_mode = rule::_PARSE;
-                ok = _parse_term(r);
-                r.m_state.m_mode = rule::_REJECT;
-            }
-            break;
-
-        //accept the left recursive rule
-        case rule::_ACCEPT:
-            if (lr) {
-                ok = true;
-            }
-            else {
-                r.m_state.m_mode = rule::_PARSE;
-                ok = _parse_term(r);
-                r.m_state.m_mode = rule::_ACCEPT;
-            }
-            break;
-    }
-
-    //restore the rule's state
-    r.m_state = old_state;
-
-    return ok;
+bool _context::parse_term(rule& r) {
+        //save the state of the rule
+        rule::_state old_state = r.m_state;
+
+        //success/failure result
+        bool ok = false;
+
+        //compute the new position
+        size_t new_pos = m_pos.m_it - m_begin;
+
+        //check if we have left recursion
+        bool lr = new_pos == r.m_state.m_pos;
+
+        //update the rule's state
+        r.m_state.m_pos = new_pos;
+
+        //handle the mode of the rule
+        switch (r.m_state.m_mode) {
+                //normal parse
+                case rule::_PARSE:
+                        if (lr) {
+                                //first try to parse the rule by rejecting it, so alternative branches are examined
+                                r.m_state.m_mode = rule::_REJECT;
+                                ok = _parse_term(r);
+
+                                //if the first try is successful, try accepting the rule,
+                                //so other elements of the sequence are parsed
+                                if (ok) {
+                                        r.m_state.m_mode = rule::_ACCEPT;
+
+                                        //loop until no more parsing can be done
+                                        for(;;) {
+                                                //store the correct state, in order to backtrack if the call fails
+                                                _state st(*this);
+
+                                                //update the rule position to the current position,
+                                                //because at this state the rule is resolving the left recursion
+                                                r.m_state.m_pos = m_pos.m_it - m_begin;
+
+                                                //if parsing fails, restore the last good state and stop
+                                                if (!_parse_term(r)) {
+                                                        restore(st);
+                                                        break;
+                                                }
+                                        }
+
+                                        //since the left recursion was resolved successfully,
+                                        //return via a non-local exit
+                                        r.m_state = old_state;
+                                        throw _lr_ok(r.this_ptr());
+                                }
+                        }
+                        else {
+                                try {
+                                        ok = _parse_term(r);
+                                }
+                                catch (const _lr_ok& ex) {
+                                        //since left recursions may be mutual, we must test which rule's left recursion
+                                        //was ended successfully
+                                        if (ex.m_rule == r.this_ptr()) {
+                                                ok = true;
+                                        }
+                                        else {
+                                                r.m_state = old_state;
+                                                throw;
+                                        }
+                                }
+                        }
+                        break;
+
+                //reject the left recursive rule
+                case rule::_REJECT:
+                        if (lr) {
+                                ok = false;
+                        }
+                        else {
+                                r.m_state.m_mode = rule::_PARSE;
+                                ok = _parse_term(r);
+                                r.m_state.m_mode = rule::_REJECT;
+                        }
+                        break;
+
+                //accept the left recursive rule
+                case rule::_ACCEPT:
+                        if (lr) {
+                                ok = true;
+                        }
+                        else {
+                                r.m_state.m_mode = rule::_PARSE;
+                                ok = _parse_term(r);
+                                r.m_state.m_mode = rule::_ACCEPT;
+                        }
+                        break;
+        }
+
+        //restore the rule's state
+        r.m_state = old_state;
+
+        return ok;
 }
 
 
 //parse non-term rule internal.
-bool _context::_parse_non_term(rule &r) {
-    bool ok = false;
-    if (_private::get_parse_proc(r)) {
-        pos b = m_pos;
-        ok = _private::get_expr(r)->parse_non_term(*this);
-        if (ok) {
-            m_matches.push_back(_match(r.this_ptr(), b, m_pos));
-        }
-    }
-    else {
-        ok = _private::get_expr(r)->parse_non_term(*this);
-    }
-    return ok;
+bool _context::_parse_non_term(rule& r) {
+        bool ok = false;
+        if (_private::get_parse_proc(r)) {
+                pos b = m_pos;
+                ok = _private::get_expr(r)->parse_non_term(*this);
+                if (ok) {
+                        m_matches.push_back(_match(r.this_ptr(), b, m_pos));
+                }
+        }
+        else {
+                ok = _private::get_expr(r)->parse_non_term(*this);
+        }
+        return ok;
 }
 
 
 //parse term rule internal.
-bool _context::_parse_term(rule &r) {
-    bool ok = false;
-    if (_private::get_parse_proc(r)) {
-        pos b = m_pos;
-        ok = _private::get_expr(r)->parse_term(*this);
-        if (ok) {
-            m_matches.push_back(_match(r.this_ptr(), b, m_pos));
-        }
-    }
-    else {
-        ok = _private::get_expr(r)->parse_term(*this);
-    }
-    return ok;
+bool _context::_parse_term(rule& r) {
+        bool ok = false;
+        if (_private::get_parse_proc(r)) {
+                pos b = m_pos;
+                ok = _private::get_expr(r)->parse_term(*this);
+                if (ok) {
+                        m_matches.push_back(_match(r.this_ptr(), b, m_pos));
+                }
+        }
+        else {
+                ok = _private::get_expr(r)->parse_term(*this);
+        }
+        return ok;
 }
 
 
 //get syntax error
-static error _syntax_error(_context &con) {
-    return error(con.m_error_pos, con.m_error_pos, ERROR_SYNTAX_ERROR);
+static error _syntax_error(_context& con) {
+        return error(con.m_error_pos, con.m_error_pos, ERROR_SYNTAX_ERROR);
 }
 
 
 //get eof error
-static error _eof_error(_context &con) {
-    return error(con.m_error_pos, con.m_error_pos, ERROR_INVALID_EOF);
+static error _eof_error(_context& con) {
+        return error(con.m_error_pos, con.m_error_pos, ERROR_INVALID_EOF);
 }
 
 
 /** constructor from input.
-    @param i input.
- */
-pos::pos(input &i) :
-    m_it(i.begin()),
-    m_line(1),
-    m_col(1)
+        @param i input.
+*/
+pos::pos(input& i) :
+        m_it(i.begin()),
+        m_line(1),
+        m_col(1)
 {
 }
 
 
 /** character terminal constructor.
-    @param c character.
- */
+        @param c character.
+*/
 expr::expr(char c) :
-    m_expr(new _char(c))
+        m_expr(new _char(c))
 {
 }
 
 
 /** null-terminated string terminal constructor.
-    @param s null-terminated string.
- */
-expr::expr(const char *s) :
-    m_expr(new _string(s))
+        @param s null-terminated string.
+*/
+expr::expr(const char* s) :
+        m_expr(new _string(s))
 {
 }
 
 
 /** rule reference constructor.
-    @param r rule.
- */
-expr::expr(rule &r) :
-    m_expr(new _ref(r))
+        @param r rule.
+*/
+expr::expr(rule& r) :
+        m_expr(new _ref(r))
 {
 }
 
 
 /** creates a zero-or-more loop out of this expression.
-    @return a zero-or-more loop expression.
- */
-expr expr::operator *() const {
-    return _private::construct_expr(new _loop0(m_expr));
+        @return a zero-or-more loop expression.
+*/
+expr expr::operator*() const {
+        return _private::construct_expr(new _loop0(m_expr));
 }
 
 
 /** creates a one-or-more loop out of this expression.
-    @return a one-or-more loop expression.
- */
-expr expr::operator +() const {
-    return _private::construct_expr(new _loop1(m_expr));
+        @return a one-or-more loop expression.
+*/
+expr expr::operator+() const {
+        return _private::construct_expr(new _loop1(m_expr));
 }
 
 
 /** creates an optional out of this expression.
-    @return an optional expression.
- */
-expr expr::operator -() const {
-    return _private::construct_expr(new _optional(m_expr));
+        @return an optional expression.
+*/
+expr expr::operator-() const {
+        return _private::construct_expr(new _optional(m_expr));
 }
 
 
 /** creates an AND-expression.
-    @return an AND-expression.
- */
-expr expr::operator &() const {
-    return _private::construct_expr((new _and(m_expr)));
+        @return an AND-expression.
+*/
+expr expr::operator&() const {
+        return _private::construct_expr((new _and(m_expr)));
 }
 
 
 /** creates a NOT-expression.
-    @return a NOT-expression.
- */
-expr expr::operator !() const {
-    return _private::construct_expr(new _not(m_expr));
+        @return a NOT-expression.
+*/
+expr expr::operator!() const {
+        return _private::construct_expr(new _not(m_expr));
 }
 
 
 /** constructor.
-    @param b begin position.
-    @param e end position.
- */
-input_range::input_range(const pos &b, const pos &e) :
+        @param b begin position.
+        @param e end position.
+*/
+input_range::input_range(const pos& b, const pos& e) :
 m_begin(b),
 m_end(e) {}
 
 
 /** constructor.
-    @param b begin position.
-    @param e end position.
-    @param t error type.
- */
-error::error(const pos &b, const pos &e, int t) :
+        @param b begin position.
+        @param e end position.
+        @param t error type.
+*/
+error::error(const pos& b, const pos& e, int t) :
 input_range(b, e),
 m_type(t) {}
 
 
 /** compare on begin position.
-    @param e the other error to compare this with.
-    @return true if this comes before the previous error, false otherwise.
- */
-bool error::operator < (const error &e) const {
-    return m_begin.m_it < e.m_begin.m_it;
+        @param e the other error to compare this with.
+        @return true if this comes before the previous error, false otherwise.
+*/
+bool error::operator<(const error& e) const {
+        return m_begin.m_it < e.m_begin.m_it;
 }
 
 rule::rule() :
-         m_expr(nullptr),
-         m_parse_proc(nullptr)
-{
-}
+m_expr(nullptr),
+m_parse_proc(nullptr) {}
 
 /** character terminal constructor.
-    @param c character.
- */
+        @param c character.
+*/
 rule::rule(char c) :
-    m_expr(new _char(c)),
-         m_parse_proc(nullptr)
-{
-}
-
+m_expr(new _char(c)),
+m_parse_proc(nullptr) {}
 
 /** null-terminated string terminal constructor.
-    @param s null-terminated string.
- */
-rule::rule(const char *s) :
-    m_expr(new _string(s)),
-         m_parse_proc(nullptr)
-{
-}
-
+        @param s null-terminated string.
+*/
+rule::rule(const char* s) :
+m_expr(new _string(s)),
+m_parse_proc(nullptr) {}
 
 /** constructor from expression.
-    @param e expression.
- */
-rule::rule(const expr &e) :
-    m_expr(_private::get_expr(e)),
-         m_parse_proc(nullptr)
-{
-}
+        @param e expression.
+*/
+rule::rule(const expr& e) :
+m_expr(_private::get_expr(e)),
+m_parse_proc(nullptr) {}
 
 
 /** constructor from rule.
-    @param r rule.
- */
-rule::rule(rule &r) :
-    m_expr(new _ref(r)),
-         m_parse_proc(nullptr)
-{
-}
+        @param r rule.
+*/
+rule::rule(rule& r) :
+m_expr(new _ref(r)),
+m_parse_proc(nullptr) {}
 
-rule& rule::operator = (rule & r) {
+rule& rule::operator=(rule& r) {
         m_expr = new _ref(r);
         return *this;
 }
 
-rule &rule::operator = (const expr & e) {
+rule &rule::operator=(const expr& e) {
         m_expr = _private::get_expr(e);
         return *this;
 }
 
 /** invalid constructor from rule (required by gcc).
-    @exception std::logic_error always thrown.
- */
-rule::rule(const rule &) {
-    throw std::logic_error("invalid operation");
+        @exception std::logic_error always thrown.
+*/
+rule::rule(const rule&) {
+        throw std::logic_error("invalid operation");
 }
 
 
 /** deletes the internal object that represents the expression.
- */
+*/
 rule::~rule() {
-    delete m_expr;
+        delete m_expr;
 }
 
 
 /** creates a zero-or-more loop out of this rule.
-    @return a zero-or-more loop rule.
- */
-expr rule::operator *() {
-    return _private::construct_expr(new _loop0(new _ref(*this)));
+        @return a zero-or-more loop rule.
+*/
+expr rule::operator*() {
+        return _private::construct_expr(new _loop0(new _ref(*this)));
 }
 
 
 /** creates a one-or-more loop out of this rule.
-    @return a one-or-more loop rule.
- */
-expr rule::operator +() {
-    return _private::construct_expr(new _loop1(new _ref(*this)));
+        @return a one-or-more loop rule.
+*/
+expr rule::operator+() {
+        return _private::construct_expr(new _loop1(new _ref(*this)));
 }
 
 
 /** creates an optional out of this rule.
-    @return an optional rule.
- */
-expr rule::operator -() {
-    return _private::construct_expr(new _optional(new _ref(*this)));
+        @return an optional rule.
+*/
+expr rule::operator-() {
+        return _private::construct_expr(new _optional(new _ref(*this)));
 }
 
 
 /** creates an AND-expression out of this rule.
-    @return an AND-expression out of this rule.
- */
-expr rule::operator &() {
-    return _private::construct_expr(new _and(new _ref(*this)));
+        @return an AND-expression out of this rule.
+*/
+expr rule::operator&() {
+        return _private::construct_expr(new _and(new _ref(*this)));
 }
 
 
 /** creates a NOT-expression out of this rule.
-    @return a NOT-expression out of this rule.
- */
-expr rule::operator !() {
-    return _private::construct_expr(new _not(new _ref(*this)));
+        @return a NOT-expression out of this rule.
+*/
+expr rule::operator!() {
+        return _private::construct_expr(new _not(new _ref(*this)));
 }
 
 
 /** sets the parse procedure.
-    @param p procedure.
- */
+        @param p procedure.
+*/
 void rule::set_parse_proc(parse_proc p) {
-    assert(p);
-    m_parse_proc = p;
+        assert(p);
+        m_parse_proc = p;
 }
 
 
 /** creates a sequence of expressions.
-    @param left left operand.
-    @param right right operand.
-    @return an expression which parses a sequence.
- */
-expr operator >> (const expr &left, const expr &right) {
-    return _private::construct_expr(
-        new _seq(_private::get_expr(left), _private::get_expr(right)));
+        @param left left operand.
+        @param right right operand.
+        @return an expression which parses a sequence.
+*/
+expr operator >> (const expr& left, const expr& right) {
+        return _private::construct_expr(
+                new _seq(_private::get_expr(left), _private::get_expr(right)));
 }
 
 
 /** creates a choice of expressions.
-    @param left left operand.
-    @param right right operand.
-    @return an expression which parses a choice.
- */
-expr operator | (const expr &left, const expr &right) {
-    return _private::construct_expr(
-        new _choice(_private::get_expr(left), _private::get_expr(right)));
+        @param left left operand.
+        @param right right operand.
+        @return an expression which parses a choice.
+*/
+expr operator | (const expr& left, const expr& right) {
+        return _private::construct_expr(
+                new _choice(_private::get_expr(left), _private::get_expr(right)));
 }
 
 
 /** converts a parser expression into a terminal.
-    @param e expression.
-    @return an expression which parses a terminal.
- */
-expr term(const expr &e) {
-    return _private::construct_expr(
-        new _term(_private::get_expr(e)));
+        @param e expression.
+        @return an expression which parses a terminal.
+*/
+expr term(const expr& e) {
+        return _private::construct_expr(
+                new _term(_private::get_expr(e)));
 }
 
 
 /** creates a set expression from a null-terminated string.
-    @param s null-terminated string with characters of the set.
-    @return an expression which parses a single character out of a set.
- */
-expr set(const char *s) {
-    return _private::construct_expr(new _set(s));
+        @param s null-terminated string with characters of the set.
+        @return an expression which parses a single character out of a set.
+*/
+expr set(const char* s) {
+        return _private::construct_expr(new _set(s));
 }
 
 
 /** creates a range expression.
-    @param min min character.
-    @param max max character.
-    @return an expression which parses a single character out of range.
- */
+        @param min min character.
+        @param max max character.
+        @return an expression which parses a single character out of range.
+*/
 expr range(int min, int max) {
-    return _private::construct_expr(new _set(min, max));
+        return _private::construct_expr(new _set(min, max));
 }
 
 
 /** creates an expression which increments the line counter
-    and resets the column counter when the given expression
-    is parsed successfully; used for newline characters.
-    @param e expression to wrap into a newline parser.
-    @return an expression that handles newlines.
- */
-expr nl(const expr &e) {
-    return _private::construct_expr(new _nl(_private::get_expr(e)));
+        and resets the column counter when the given expression
+        is parsed successfully; used for newline characters.
+        @param e expression to wrap into a newline parser.
+        @return an expression that handles newlines.
+*/
+expr nl(const expr& e) {
+        return _private::construct_expr(new _nl(_private::get_expr(e)));
 }
 
 
 /** creates an expression which tests for the end of input.
-    @return an expression that handles the end of input.
- */
+        @return an expression that handles the end of input.
+*/
 expr eof() {
-    return _private::construct_expr(new _eof());
+        return _private::construct_expr(new _eof());
 }
 
 
 /** creates a not expression.
-    @param e expression.
-    @return the appropriate expression.
- */
-expr not_(const expr &e) {
-    return !e;
+        @param e expression.
+        @return the appropriate expression.
+*/
+expr not_(const expr& e) {
+        return !e;
 }
 
 
 /** creates an and expression.
-    @param e expression.
-    @return the appropriate expression.
- */
-expr and_(const expr &e) {
-    return &e;
+        @param e expression.
+        @return the appropriate expression.
+*/
+expr and_(const expr& e) {
+        return &e;
 }
 
 
 /** creates an expression that parses any character.
-    @return the appropriate expression.
- */
+        @return the appropriate expression.
+*/
 expr any() {
-    return _private::construct_expr(new _any());
+        return _private::construct_expr(new _any());
 }
 
 
@@ -1387,44 +1376,44 @@ expr false_() {
 
 /** parse with target expression and let user handle result.
 */
-expr user(const expr &e, const user_handler& handler) {
+expr user(const expr& e, const user_handler& handler) {
         return _private::construct_expr(new _user(_private::get_expr(e), handler));
 }
 
 
 /** parses the given input.
-    The parse procedures of each rule parsed are executed
-    before this function returns, if parsing succeeds.
-    @param i input.
-    @param g root rule of grammar.
-    @param el list of errors.
-    @param d user data, passed to the parse procedures.
-    @return true on parsing success, false on failure.
- */
-bool parse(input &i, rule &g, error_list &el, void *d, void* ud) {
-    //prepare context
-    _context con(i, ud);
-
-    //parse grammar
-    if (!con.parse_non_term(g)) {
-        el.push_back(_syntax_error(con));
-        return false;
-    }
-
-    //if end is not reached, there was an error
-    if (!con.end()) {
-        if (con.m_error_pos.m_it < con.m_end) {
-            el.push_back(_syntax_error(con));
-        }
-        else {
-            el.push_back(_eof_error(con));
-        }
-        return false;
-    }
-
-    //success; execute the parse procedures
-    con.do_parse_procs(d);
-    return true;
+        The parse procedures of each rule parsed are executed
+        before this function returns, if parsing succeeds.
+        @param i input.
+        @param g root rule of grammar.
+        @param el list of errors.
+        @param d user data, passed to the parse procedures.
+        @return true on parsing success, false on failure.
+*/
+bool parse(input& i, rule& g, error_list& el, void* d, void* ud) {
+        //prepare context
+        _context con(i, ud);
+
+        //parse grammar
+        if (!con.parse_non_term(g)) {
+                el.push_back(_syntax_error(con));
+                return false;
+        }
+
+        //if end is not reached, there was an error
+        if (!con.end()) {
+                if (con.m_error_pos.m_it < con.m_end) {
+                        el.push_back(_syntax_error(con));
+                }
+                else {
+                        el.push_back(_eof_error(con));
+                }
+                return false;
+        }
+
+        //success; execute the parse procedures
+        con.do_parse_procs(d);
+        return true;
 }
 
 
diff --git a/src/MoonP/parser.hpp b/src/MoonP/parser.hpp
index b419e8c..01d1050 100644
--- a/src/MoonP/parser.hpp
+++ b/src/MoonP/parser.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
 
@@ -60,89 +61,89 @@ typedef std::function<bool(const item_t&)> user_handler;
 ///position into the input.
 class pos {
 public:
-    ///interator into the input.
-    input::iterator m_it;
+        ///interator into the input.
+        input::iterator m_it;
 
-    ///line.
-    int m_line;
+        ///line.
+        int m_line;
 
-    ///column.
-    int m_col;
+        ///column.
+        int m_col;
 
-    ///null constructor.
-    pos():m_line(0),m_col(0) {}
+        ///null constructor.
+        pos():m_line(0),m_col(0) {}
 
-    /** constructor from input.
-        @param i input.
-     */
-    pos(input &i);
+        /** constructor from input.
+                @param i input.
+        */
+        pos(input &i);
 };
 
 
 /** a grammar expression.
- */
+*/
 class expr {
 public:
-    /** character terminal constructor.
-        @param c character.
-     */
-    expr(char c);
-
-    /** null-terminated string terminal constructor.
-        @param s null-terminated string.
-     */
-    expr(const char *s);
-
-    /** rule reference constructor.
-        @param r rule.
-     */
-    expr(rule &r);
-
-    /** creates a zero-or-more loop out of this expression.
-        @return a zero-or-more loop expression.
-     */
-    expr operator *() const;
-
-    /** creates a one-or-more loop out of this expression.
-        @return a one-or-more loop expression.
-     */
-    expr operator +() const;
-
-    /** creates an optional out of this expression.
-        @return an optional expression.
-     */
-    expr operator -() const;
-
-    /** creates an AND-expression.
-        @return an AND-expression.
-     */
-    expr operator &() const;
-
-    /** creates a NOT-expression.
-        @return a NOT-expression.
-     */
-    expr operator !() const;
+        /** character terminal constructor.
+                @param c character.
+        */
+        expr(char c);
+
+        /** null-terminated string terminal constructor.
+                @param s null-terminated string.
+        */
+        expr(const char* s);
+
+        /** rule reference constructor.
+                @param r rule.
+        */
+        expr(rule& r);
+
+        /** creates a zero-or-more loop out of this expression.
+                @return a zero-or-more loop expression.
+        */
+        expr operator*() const;
+
+        /** creates a one-or-more loop out of this expression.
+                @return a one-or-more loop expression.
+        */
+        expr operator+() const;
+
+        /** creates an optional out of this expression.
+                @return an optional expression.
+        */
+        expr operator-() const;
+
+        /** creates an AND-expression.
+                @return an AND-expression.
+        */
+        expr operator&() const;
+
+        /** creates a NOT-expression.
+                @return a NOT-expression.
+        */
+        expr operator!() const;
 
 private:
-    //internal expression
-    _expr *m_expr;
+        //internal expression
+        _expr* m_expr;
 
-    //internal constructor from internal expression
-    expr(_expr *e) : m_expr(e) {}
+        //internal constructor from internal expression
+        expr(_expr* e) : m_expr(e) {}
 
-    //assignment not allowed
-    expr &operator = (expr &);
+        //assignment not allowed
+        expr& operator=(expr&);
 
-    friend class _private;
+        friend class _private;
 };
 
 
 /** type of procedure to invoke when a rule is successfully parsed.
-    @param b begin position of input.
-    @param e end position of input.
-    @param d pointer to user data.
- */
-typedef void (*parse_proc)(const pos &b, const pos &e, void *d);
+        @param b begin position of input.
+        @param e end position of input.
+        @param d pointer to user data.
+*/
+typedef void (*parse_proc)(const pos& b, const pos& e, void* d);
 
 
 ///input range.
@@ -150,54 +151,54 @@ class input_range {
 public:
         virtual ~input_range() {}
 
-    ///begin position.
-    pos m_begin;
+        ///begin position.
+        pos m_begin;
 
-    ///end position.
-    pos m_end;
+        ///end position.
+        pos m_end;
 
-    ///empty constructor.
-    input_range() {}
+        ///empty constructor.
+        input_range() {}
 
-    /** constructor.
-        @param b begin position.
-        @param e end position.
-     */
-    input_range(const pos &b, const pos &e);
+        /** constructor.
+                @param b begin position.
+                @param e end position.
+        */
+        input_range(const pos& b, const pos& e);
 };
 
 
 ///enum with error types.
 enum ERROR_TYPE {
-    ///syntax error
-    ERROR_SYNTAX_ERROR = 1,
+        ///syntax error
+        ERROR_SYNTAX_ERROR = 1,
 
-    ///invalid end of file
-    ERROR_INVALID_EOF,
+        ///invalid end of file
+        ERROR_INVALID_EOF,
 
-    ///first user error
-    ERROR_USER = 100
+        ///first user error
+        ERROR_USER = 100
 };
 
 
 ///error.
 class error : public input_range {
 public:
-    ///type
-    int m_type;
-
-    /** constructor.
-        @param b begin position.
-        @param e end position.
-        @param t type.
-     */
-    error(const pos &b, const pos &e, int t);
-
-    /** compare on begin position.
-        @param e the other error to compare this with.
-        @return true if this comes before the previous error, false otherwise.
-     */
-    bool operator < (const error &e) const;
+        ///type
+        int m_type;
+
+        /** constructor.
+                @param b begin position.
+                @param e end position.
+                @param t type.
+        */
+        error(const pos& b, const pos& e, int t);
+
+        /** compare on begin position.
+                @param e the other error to compare this with.
+                @return true if this comes before the previous error, false otherwise.
+        */
+        bool operator<(const error& e) const;
 };
 
 
@@ -206,189 +207,189 @@ typedef std::list<error> error_list;
 
 
 /** represents a rule.
- */
+*/
 class rule {
 public:
-    /** character terminal constructor.
-        @param c character.
-     */
+        /** character terminal constructor.
+                @param c character.
+        */
         rule();
-    rule(char c);
-
-    /** null-terminated string terminal constructor.
-        @param s null-terminated string.
-     */
-    rule(const char *s);
-
-    /** constructor from expression.
-        @param e expression.
-     */
-    rule(const expr &e);
-
-    /** constructor from rule.
-        @param r rule.
-     */
-    rule(rule &r);
-
-    /** invalid constructor from rule (required by gcc).
-        @param r rule.
-        @exception std::logic_error always thrown.
-     */
-    rule(const rule &r);
-
-    /** deletes the internal object that represents the expression.
-     */
-    ~rule();
-
-    /** creates a zero-or-more loop out of this rule.
-        @return a zero-or-more loop rule.
-     */
-    expr operator *();
-
-    /** creates a one-or-more loop out of this rule.
-        @return a one-or-more loop rule.
-     */
-    expr operator +();
-
-    /** creates an optional out of this rule.
-        @return an optional rule.
-     */
-    expr operator -();
-
-    /** creates an AND-expression out of this rule.
-        @return an AND-expression out of this rule.
-     */
-    expr operator &();
-
-    /** creates a NOT-expression out of this rule.
-        @return a NOT-expression out of this rule.
-     */
-    expr operator !();
-
-    /** sets the parse procedure.
-        @param p procedure.
-     */
-    void set_parse_proc(parse_proc p);
-
-    /** get the this ptr (since operator & is overloaded).
-        @return pointer to this.
-     */
-    rule *this_ptr() { return this; }
-
-    rule &operator = (rule &);
-
-    rule &operator = (const expr &);
+        rule(char c);
+
+        /** null-terminated string terminal constructor.
+                @param s null-terminated string.
+        */
+        rule(const char* s);
+
+        /** constructor from expression.
+                @param e expression.
+        */
+        rule(const expr& e);
+
+        /** constructor from rule.
+                @param r rule.
+        */
+        rule(rule& r);
+
+        /** invalid constructor from rule (required by gcc).
+                @param r rule.
+                @exception std::logic_error always thrown.
+        */
+        rule(const rule& r);
+
+        /** deletes the internal object that represents the expression.
+        */
+        ~rule();
+
+        /** creates a zero-or-more loop out of this rule.
+                @return a zero-or-more loop rule.
+        */
+        expr operator*();
+
+        /** creates a one-or-more loop out of this rule.
+                @return a one-or-more loop rule.
+        */
+        expr operator+();
+
+        /** creates an optional out of this rule.
+                @return an optional rule.
+        */
+        expr operator-();
+
+        /** creates an AND-expression out of this rule.
+                @return an AND-expression out of this rule.
+        */
+        expr operator&();
+
+        /** creates a NOT-expression out of this rule.
+                @return a NOT-expression out of this rule.
+        */
+        expr operator!();
+
+        /** sets the parse procedure.
+                @param p procedure.
+        */
+        void set_parse_proc(parse_proc p);
+
+        /** get the this ptr (since operator & is overloaded).
+                @return pointer to this.
+        */
+        rule* this_ptr() { return this; }
+
+        rule& operator=(rule&);
+
+        rule& operator=(const expr&);
 
 private:
-    //mode
-    enum _MODE {
-        _PARSE,
-        _REJECT,
-        _ACCEPT
-    };
+        //mode
+        enum _MODE {
+                _PARSE,
+                _REJECT,
+                _ACCEPT
+        };
 
-    //state
-    struct _state {
-        //position in source code, relative to start
-        size_t m_pos;
+        //state
+        struct _state {
+                //position in source code, relative to start
+                size_t m_pos;
 
-        //mode
-        _MODE m_mode;
+                //mode
+                _MODE m_mode;
 
-        //constructor
-        _state(size_t pos = -1, _MODE mode = _PARSE) :
-            m_pos(pos), m_mode(mode) {}
-    };
+                //constructor
+                _state(size_t pos = -1, _MODE mode = _PARSE) :
+                        m_pos(pos), m_mode(mode) {}
+        };
 
-    //internal expression
-    _expr *m_expr;
+        //internal expression
+        _expr* m_expr;
 
-    //associated parse procedure.
-    parse_proc m_parse_proc;
+        //associated parse procedure.
+        parse_proc m_parse_proc;
 
-    //state
-    _state m_state;
+        //state
+        _state m_state;
 
-    friend class _private;
-    friend class _context;
+        friend class _private;
+        friend class _context;
 };
 
 
 /** creates a sequence of expressions.
-    @param left left operand.
-    @param right right operand.
-    @return an expression which parses a sequence.
- */
-expr operator >> (const expr &left, const expr &right);
+        @param left left operand.
+        @param right right operand.
+        @return an expression which parses a sequence.
+*/
+expr operator>>(const expr& left, const expr& right);
 
 
 /** creates a choice of expressions.
-    @param left left operand.
-    @param right right operand.
-    @return an expression which parses a choice.
- */
-expr operator | (const expr &left, const expr &right);
+        @param left left operand.
+        @param right right operand.
+        @return an expression which parses a choice.
+*/
+expr operator|(const expr& left, const expr& right);
 
 
 /** converts a parser expression into a terminal.
-    @param e expression.
-    @return an expression which parses a terminal.
- */
-expr term(const expr &e);
+        @param e expression.
+        @return an expression which parses a terminal.
+*/
+expr term(const expr& e);
 
 
 /** creates a set expression from a null-terminated string.
-    @param s null-terminated string with characters of the set.
-    @return an expression which parses a single character out of a set.
- */
-expr set(const char *s);
+        @param s null-terminated string with characters of the set.
+        @return an expression which parses a single character out of a set.
+*/
+expr set(const char* s);
 
 
 /** creates a range expression.
-    @param min min character.
-    @param max max character.
-    @return an expression which parses a single character out of range.
- */
+        @param min min character.
+        @param max max character.
+        @return an expression which parses a single character out of range.
+*/
 expr range(int min, int max);
 
 
 /** creates an expression which increments the line counter
-    and resets the column counter when the given expression
-    is parsed successfully; used for newline characters.
-    @param e expression to wrap into a newline parser.
-    @return an expression that handles newlines.
- */
-expr nl(const expr &e);
+        and resets the column counter when the given expression
+        is parsed successfully; used for newline characters.
+        @param e expression to wrap into a newline parser.
+        @return an expression that handles newlines.
+*/
+expr nl(const expr& e);
 
 
 /** creates an expression which tests for the end of input.
-    @return an expression that handles the end of input.
- */
+        @return an expression that handles the end of input.
+*/
 expr eof();
 
 
 /** creates a not expression.
-    @param e expression.
-    @return the appropriate expression.
- */
-expr not_(const expr &e);
+        @param e expression.
+        @return the appropriate expression.
+*/
+expr not_(const expr& e);
 
 
 /** creates an and expression.
-    @param e expression.
-    @return the appropriate expression.
- */
-expr and_(const expr &e);
+        @param e expression.
+        @return the appropriate expression.
+*/
+expr and_(const expr& e);
 
 
 /** creates an expression that parses any character.
-    @return the appropriate expression.
- */
+        @return the appropriate expression.
+*/
 expr any();
 
 
 /** parsing succeeds without consuming any input.
- */
+*/
 expr true_();
 
 
@@ -399,34 +400,33 @@ expr false_();
 
 /** parse with target expression and let user handle result.
 */
-expr user(const expr &e, const user_handler& handler);
+expr user(const expr& e, const user_handler& handler);
 
 
 /** parses the given input.
-    The parse procedures of each rule parsed are executed
-    before this function returns, if parsing succeeds.
-    @param i input.
-    @param g root rule of grammar.
-    @param el list of errors.
-    @param d user data, passed to the parse procedures.
-    @return true on parsing success, false on failure.
- */
-bool parse(input &i, rule &g, error_list &el, void *d, void* ud);
+        The parse procedures of each rule parsed are executed
+        before this function returns, if parsing succeeds.
+        @param i input.
+        @param g root rule of grammar.
+        @param el list of errors.
+        @param d user data, passed to the parse procedures.
+        @return true on parsing success, false on failure.
+*/
+bool parse(input& i, rule& g, error_list& el, void* d, void* ud);
 
 
 /** output the specific input range to the specific stream.
-    @param stream stream.
-    @param ir input range.
-    @return the stream.
- */
-template <class T> T &operator << (T &stream, const input_range &ir) {
-    for(input::const_iterator it = ir.m_begin.m_it;
-        it != ir.m_end.m_it;
-        ++it)
-    {
-        stream << (typename T::char_type)*it;
-    }
-    return stream;
+        @param stream stream.
+        @param ir input range.
+        @return the stream.
+*/
+template <class T> T& operator<<(T& stream, const input_range& ir) {
+        for(input::const_iterator it = ir.m_begin.m_it;
+                it != ir.m_end.m_it;
+                ++it) {
+                stream << (typename T::char_type)*it;
+        }
+        return stream;
 }