/home/renji/Data/projects/zenlang/sources/zbl/Ast.hpp

Go to the documentation of this file.

#pragma once

namespace Ast {
    struct Storage {
        enum T {
            Init,        
            Block,       
            ClosureRef,  
            ExternalRef, 
        };

        static z::string getString(const T& t);
    };

    class Node {
    protected:
        inline Node() {}
    public:
        virtual ~Node(){}
    };

    class ChildTypeSpec;
    class VariableDef;


    class TypeSpec : public Node {
    public:
        struct AccessType {
            enum T {
                Private,     
                Internal,    
                Protected,   
                Public,      
                Export,      
                Native,      
                Test,        
            };

            static inline bool isPublic(const T& t) { return ((t == Public) || (t == Protected) || (t == Export) || (t == Native)); }

            static z::string getString(const T& t);
        };

    public:
        typedef z::list<ChildTypeSpec*> ChildList;

        typedef z::dict<z::string, ChildTypeSpec*> ChildMap;

    protected:
        inline TypeSpec(const AccessType::T& accessType, const z::string& name) : _accessType(accessType), _name(name) {}

    public:
        inline bool isPublic() const { return AccessType::isPublic(_accessType); }

    public:
        inline const AccessType::T& getAccessType() const { return _accessType; }

        inline const z::string& getName() const { return _name; }

    public:
        inline void setAccessType(const AccessType::T& accessType) { _accessType = accessType; }

        inline void setName(const z::string& name) { _name = name; }

    public:
        template <typename T> inline T& addChild(T& child);

        template <typename T> inline T* hasChild(const z::string& name) const;

    public:
        inline const ChildList& getChildList() const {return _childList;}

    public:
        class Visitor;

        virtual void visit(Visitor& visitor) const = 0;

    public:
        virtual z::string getFullName(const z::string& sep) const = 0;

    public:
        virtual const Ast::VariableDef* hasMember(const z::string& name) const {unused(name); return 0;}

    private:
        AccessType::T _accessType;

        z::string _name;

    private:
        ChildList _childList;

        ChildMap _childMap;
    };


    class QualifiedType : public Node {
    public:
        typedef z::list<const QualifiedType*> List;

    public:
        inline QualifiedType(const bool& isConst, const TypeSpec& type, const bool& isRef) : _isConst(isConst), _type(type), _isRef(isRef) {}

    public:
        inline const bool& isConst() const {return _isConst;}

        inline const bool& isRef() const { return _isRef; }

        inline const TypeSpec& getTypeSpec() const { return _type; }

    private:
        bool _isConst;

        const TypeSpec& _type;

        bool _isRef;
    };

    // Abstract types

    class VariableDef : public Node {
    public:
        enum DefType {
            Param,    
            Closure,  
            Local,    
            Shared,   
        };

    public:
        typedef z::list<VariableDef*> List;

    public:
        inline VariableDef(const DefType& defType, const Ast::QualifiedType& type, const z::string& name) : _defType(defType), _type(type), _name(name) {}

    public:
        inline const DefType& getDefType() const {return _defType;}

        inline const Ast::QualifiedType& getType() const {return _type;}

        inline const z::string& getName() const {return _name;}

    private:
        const DefType _defType;

        const Ast::QualifiedType& _type;

        z::string _name;
    };


    class VariableDefListBase : public Node {
    public:
        typedef z::list<const VariableDef*> List;

    protected:
        inline VariableDefListBase() {}

    public:
        inline const List& getList() const {return _list;}

        inline const VariableDef& getFirst() const {return ref(_list.front());}

        inline const VariableDef& getLast() const {return ref(_list.last());}

        inline const Ast::VariableDef& addDef(const Ast::VariableDef& child) {
            _list.append(ptr(child));
            return child;
        }

    private:
        List _list;
    };


    class VariableRef : public VariableDefListBase {
    public:
        inline VariableRef(const Storage::T& storage) : _storage(storage) {}

    public:
        inline const Ast::QualifiedType& getType() const {return getFirst().getType();}

        inline const z::string& getName() const {return getFirst().getName();}

    public:
        inline void setStorage(const Storage::T& storage) {_storage = storage;}

        inline const Storage::T& getStorage() const {return _storage;}

    private:
        Storage::T _storage;
    };


    class VariableRefList : public Node {
    public:
        typedef z::list<const VariableRef*> List;

    public:
        inline VariableRefList() {}

    public:
        inline const List& getList() const {return _list;}

    public:
        inline const Ast::VariableRef& addRef(const Ast::VariableRef& vref) {
            _list.append(ptr(vref));
            return vref;
        }
    public:
        inline bool hasRef(const Ast::VariableRef& vref) const {
            for(List::iterator it(_list); !it.end(); ++it) {
                const VariableRef& vr = ref(*it);
                if(ptr(vr.getFirst()) == ptr(vref.getFirst()))
                    return true;
            }
            return false;
        }

    public:
        inline void appendList(const VariableRefList& src) {
            for(List::iterator it(src.getList()); !it.end(); ++it) {
                const Ast::VariableRef& vd = ref(*it);
                if(!hasRef(vd)) {
                    addRef(vd);
                }
            }
        }

    private:
        List _list;
    };


    class VariableDefMap : public VariableDefListBase {
    public:
        inline VariableDefMap() {}

    public:
        inline const Ast::VariableDef* hasDef(const z::string& name) const {
            DefMap::found f = _defMap.find(name);
            if(!f)
                return 0;
            const Ast::VariableDef* t = *f;
            return t;
        }

        inline const Ast::VariableDef& addDef(const Ast::VariableDef& child) {
            const z::string& name = child.getName();
            assert(hasDef(name) == 0);
            _defMap.insert(name, ptr(child));
            return VariableDefListBase::addDef(child);
        }

        inline void appendList(const VariableDefMap& src) {
            for(List::iterator it(src.getList()); !it.end(); ++it) {
                const Ast::VariableDef& vd = ref(*it);
                if(!hasDef(vd.getName())) {
                    addDef(vd);
                }
            }
        }

    private:
        typedef z::dict<z::string, const VariableDef*> DefMap;

        DefMap _defMap;
    };


    class Scope : public Node {
    public:
        enum Type {
            InParam,      
            Block,        
            Continuation, 
        };
    public:
        inline Scope(const Type& type) : /*ChildTypeSpec(AccessType::Private, ""),*/ _type(type) {}

    public:
        inline const Type& getType() const {return _type;}

        inline const Ast::VariableDef& addDef(const Ast::VariableDef& child) {return _defList.addDef(child);}

        inline const VariableDefMap& getDefList() const {return _defList;}

    private:
        const Type _type;

        VariableDefMap _defList;
    };

    class Expr;


    class ExprVariableDef : public VariableDef {
    protected:
        inline ExprVariableDef(const DefType& defType, const Ast::QualifiedType& type, const z::string& name, const Ast::Expr& expr) : VariableDef(defType, type, name), _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        const Ast::Expr& _expr;
    };

    class ParamVariableDef : public ExprVariableDef {
    public:
        inline ParamVariableDef(const Ast::QualifiedType& type, const z::string& name, const Ast::Expr& expr) : ExprVariableDef(Param, type, name, expr) {}
    };

    class StructMemberVariableDef : public ExprVariableDef {
    public:
        inline StructMemberVariableDef(const Ast::QualifiedType& type, const z::string& name, const Ast::Expr& expr) : ExprVariableDef(Local, type, name, expr) {}
    };

    class InitVariableDef : public ExprVariableDef {
    public:
        inline InitVariableDef(const DefType& defType, const Ast::QualifiedType& qtype, const z::string& name, const Ast::Expr& expr) : ExprVariableDef(defType, qtype, name, expr) {}
    };

    class SharedVariableDef : public ExprVariableDef {
    public:
        inline SharedVariableDef(const DefType& defType, const Ast::QualifiedType& qtype, const z::string& name, const Ast::Expr& expr) : ExprVariableDef(defType, qtype, name, expr) {}
    };


    class RootTypeSpec : public TypeSpec {
    protected:
        inline RootTypeSpec(const AccessType::T& accessType, const z::string& name) : TypeSpec(accessType, name) {}

    private:
        virtual z::string getFullName(const z::string& sep) const {unused(sep); return getName();}
    };


    class ChildTypeSpec : public TypeSpec {
    protected:
        inline ChildTypeSpec(const AccessType::T& accessType, const z::string& name) : TypeSpec(accessType, name), _parent(0) {}

        inline ChildTypeSpec(const AccessType::T& accessType, TypeSpec& parent, const z::string& name) : TypeSpec(accessType, name), _parent(ptr(parent)) {}

    public:
        inline void setParent(TypeSpec& parent) {
            assert(0 == _parent);
            _parent = ptr(parent);
        }

        inline TypeSpec* hasParent() const {return _parent;}

        inline TypeSpec& getParent() const {return ref(_parent);}

    public:
        virtual z::string getFullName(const z::string& sep) const {
            const z::string& name = getName();
            if(name.length() == 0)
                return getParent().getFullName(sep);
            if(hasParent()) {
                const z::string pname = getParent().getFullName(sep);
                if(pname.length() == 0)
                    return name;
                return pname + sep + name;
            }
            return "??" + sep + name;
        }
    private:
        TypeSpec* _parent;
    };


    class UserDefinedTypeSpec : public ChildTypeSpec {
    public:
        enum NativeType {
            ntNone,        
            ntIntrinsic,   
            ntSystem,      
            ntQuery,       
        };

    protected:
        inline UserDefinedTypeSpec(const AccessType::T& accessType, const z::string& name, const NativeType& ntype) : ChildTypeSpec(accessType, name), _ntype(ntype) {}

    public:
        inline const NativeType& getNativeType() const {return _ntype;}

    private:
        const NativeType _ntype;
    };

    class StructDefList;

    class StructDef : public UserDefinedTypeSpec {
    public:
        inline StructDef(const AccessType::T& accessType, const z::string& name, const NativeType& ntype)
            : UserDefinedTypeSpec(accessType, name, ntype), _defList(0), _subTypeList(0) {}
    public:
        inline void setDefList(const VariableDefMap& defList) {assert(0 == _defList); _defList = ptr(defList);}

        inline bool hasDefList() const {return (0 != _defList);}

        inline const VariableDefMap& getDefList() const {return ref(_defList);}

    public:
        inline void setSubTypeList(const StructDefList& subTypeList) {_subTypeList = ptr(subTypeList);}

        inline bool hasSubTypeList() const {return (0 != _subTypeList);}

        inline const StructDefList& getSubTypeList() const {return ref(_subTypeList);}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        virtual const Ast::VariableDef* hasMember(const z::string& name) const;

    private:
        const VariableDefMap* _defList;

        const StructDefList* _subTypeList;
    };

    class StructDefList : public Node {
    public:
        typedef z::list<const StructDef*> List;
    public:
        inline StructDefList() {}

    public:
        inline const List& getList() const {return _list;}

    public:
        inline const Ast::StructDef& addSubType(const Ast::StructDef& subType) {
            _list.append(ptr(subType));
            return subType;
        }

    public:
        inline const StructDef* hasSubType(const z::string& name) const {
            for(List::iterator it(_list); !it.end(); ++it) {
                const StructDef& sd = ref(*it);
                if(sd.getName() == name)
                    return ptr(sd);
            }
            return 0;
        }
    private:
        List _list;
    };

    class EnumMemberDef : public ChildTypeSpec {
    public:
        inline EnumMemberDef(const AccessType::T& accessType, const z::string& name, const bool& hasInit, const Ast::Expr& initExpr)
            : ChildTypeSpec(accessType, name), _hasInit(hasInit), _initExpr(initExpr) {}

    public:
        inline const bool& hasInitExpr() const {return _hasInit;}

        inline const Ast::Expr& getInitExpr() const {return _initExpr;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        const bool _hasInit;

        const Ast::Expr& _initExpr;
    };

    class EnumMemberDefList : public Node {
    public:
        typedef z::list<const EnumMemberDef*> List;

    public:
        inline EnumMemberDefList() {}

    public:
        inline const List& getList() const {return _list;}

        inline void addDef(const EnumMemberDef& def) {_list.append(ptr(def));}

    private:
        List _list;
    };

    class EnumDef : public UserDefinedTypeSpec {
    public:
        inline EnumDef(const AccessType::T& accessType, const z::string& name, const NativeType& ntype, const EnumMemberDefList& defList)
            : UserDefinedTypeSpec(accessType, name, ntype), _defList(defList) {}

    public:
        inline const EnumMemberDefList& getDefList() const {return _defList;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        const EnumMemberDefList& _defList;
    };

    class OutParam : public UserDefinedTypeSpec {
    public:
        inline OutParam(const AccessType::T& accessType, const z::string& name, const NativeType& ntype, const VariableDefMap& defList, const bool& isTuple)
            : UserDefinedTypeSpec(accessType, name, ntype), _defList(defList), _isTuple(isTuple) {}

    public:
        inline const VariableDefMap& getDefList() const {return _defList;}

        inline const bool& getIsTuple() const {return _isTuple;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

        virtual const Ast::VariableDef* hasMember(const z::string& name) const;

    private:
        const VariableDefMap& _defList;

        const bool _isTuple;
    };

    class SharedDef : public UserDefinedTypeSpec {
    public:
        inline SharedDef(const AccessType::T& accessType, const z::string& name, const NativeType& ntype, const VariableDefMap& defList)
            : UserDefinedTypeSpec(accessType, name, ntype), _defList(defList) {}

    public:
        inline const VariableDefMap& getDefList() const {return _defList;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

        virtual const Ast::VariableDef* hasMember(const z::string& name) const;

    private:
        const VariableDefMap& _defList;
    };

    class TypeDefTypeSpec : public UserDefinedTypeSpec {
    protected:
        inline TypeDefTypeSpec(const AccessType::T& accessType, const z::string& name, const NativeType& ntype) : UserDefinedTypeSpec(accessType, name, ntype) {}
    };

    class TypeDecl : public TypeDefTypeSpec {
    public:
        inline TypeDecl(const AccessType::T& accessType, const z::string& name, const NativeType& ntype) : TypeDefTypeSpec(accessType, name, ntype) {}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;
    };

    class TypeDef : public TypeDefTypeSpec {
    public:
        inline TypeDef(const AccessType::T& accessType, const z::string& name, const NativeType& ntype, const Ast::QualifiedType& type)
            : TypeDefTypeSpec(accessType, name, ntype), _type(type) {}

    public:
        inline const Ast::QualifiedType& getTargetType() const {return _type;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        const Ast::QualifiedType& _type;
    };

    class TemplateTypeSpec : public ChildTypeSpec {
    public:
        inline TemplateTypeSpec(const AccessType::T& accessType, const z::string& name) : ChildTypeSpec(accessType, name) {}
    };


    class OwnerTemplate : public TemplateTypeSpec {
    public:
        inline OwnerTemplate(const AccessType::T& accessType, const z::string& name, const Ast::QualifiedType& type) : TemplateTypeSpec(accessType, name), _type(type) {}

    public:
        inline const Ast::QualifiedType& getType() const {return _type;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        const Ast::QualifiedType& _type;
    };

    class ListTemplate : public TemplateTypeSpec {
    public:
        inline ListTemplate(const AccessType::T& accessType, const z::string& name, const Ast::QualifiedType& type) : TemplateTypeSpec(accessType, name), _type(type) {}

    public:
        inline const Ast::QualifiedType& getType() const {return _type;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        const Ast::QualifiedType& _type;
    };

    class DictTemplate : public TemplateTypeSpec {
    public:
        inline DictTemplate(const AccessType::T& accessType, const z::string& name, const Ast::QualifiedType& key, const Ast::QualifiedType& type)
            : TemplateTypeSpec(accessType, name), _key(key), _type(type) {}
    public:
        inline const Ast::QualifiedType& getKey() const {return _key;}

        inline const Ast::QualifiedType& getType() const {return _type;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        const Ast::QualifiedType& _key;

        const Ast::QualifiedType& _type;
    };

    class MethodTypeSpec : public UserDefinedTypeSpec {
    protected:
        inline MethodTypeSpec(const AccessType::T& accessType, const QualifiedType& out, const z::string& name, Ast::Scope& in, const NativeType& ntype)
            : UserDefinedTypeSpec(accessType, name, ntype), _out(out), _in(in), _isTuple(false) {}

    public:
        inline const QualifiedType& getOutType() const {return _out;}

        inline Scope& getInType() {return _in;}

        inline const Scope& getInType() const {return _in;}

    public:
        inline void setIsTuple(const bool& val) {_isTuple = val;}

        inline const bool& getIsTuple() const {return _isTuple;}

    private:
        const QualifiedType& _out;

        Scope& _in;

        bool _isTuple;
    };

    class ImplItem;

    class FunctionDef : public MethodTypeSpec {
    public:
        struct Modifier {
            enum T {
                None,     
                Routine,  
                Grammar,  
                Window,   
            };
        };

    public:
        inline FunctionDef(const AccessType::T& accessType, const QualifiedType& out, const z::string& name, Scope& in, const NativeType& ntype, const Ast::FunctionDef::Modifier::T& modifier)
            : MethodTypeSpec(accessType, out, name, in, ntype), _modifier(modifier), _impl(0) {}

    public:
        inline const Modifier::T& getModifier() const {return _modifier;}

        inline bool  hasImpl() const {return (0 != _impl);}

        inline const ImplItem& getImpl() const {return ref(_impl);}

        inline void setImpl(const ImplItem& impl) {assert(0 == _impl); _impl = ptr(impl);}

    public:
        inline void setGrammarName(const z::string& val) {_gname = val;} 

        inline const z::string& getGrammarName() const {return _gname;}   

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        const Ast::FunctionDef::Modifier::T _modifier;

        const ImplItem* _impl;

        z::string _gname;
    };

    class Namespace : public ChildTypeSpec {
    public:
        inline Namespace(const AccessType::T& accessType, TypeSpec& parent, const z::string& name) : ChildTypeSpec(accessType, parent, name) {}

    public:
        inline Namespace* hasNamespace(const z::string& name) {return TypeSpec::hasChild<Namespace>(name);}

        inline Namespace& addNamespace(Namespace& child) {return TypeSpec::addChild<Namespace>(child);}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;
    };

    class StructInitItem : public Node {
    public:
        inline StructInitItem(const VariableDef& mref, const Ast::Expr& expr) : _mref(mref), _expr(expr) {}

    public:
        inline const VariableDef& getMemberRef() const {return _mref;}

        inline const Expr& getExpr() const {return _expr;}
    private:
        const VariableDef& _mref;

        const Expr& _expr;
    };


    class StructInitList : public Node {
    public:
        typedef z::list<const StructInitItem*> List;
    public:
        inline StructInitList() {}

    public:
        inline void addItem(const StructInitItem& item) {_list.append(ptr(item));}

        inline const List& getList() const {return _list;}

    private:
        List _list;
    };

    class GrammarToken : public Node {
    public:
        inline GrammarToken(const z::string& name, const z::string& txt, const bool& isRex, const bool& isNot)
            : Node(), _name(name), _txt(txt), _isRex(isRex), _isNot(isNot) {}

    public:
        inline const z::string& getName() const {return _name;}

        inline const z::string& getText() const {return _txt;}

        inline const bool& isRex() const {return _isRex;}

        inline const bool& isNot() const {return _isNot;}

    private:
        const z::string _name;

        const z::string _txt;

        const bool _isRex;

        const bool _isNot;
    };

    class GrammarTokenList : public Node {
    public:
        typedef z::list<const GrammarToken*> List;

    public:
        inline GrammarTokenList() : Node() {}

    public:
        inline const List& getList() const {return _list;}

    public:
        inline void addToken(const GrammarToken& token) {_list.append(ptr(token));}

        inline bool isEmpty() {return _list.empty();}

        inline void clear() {return _list.clear();}

    private:
        List _list;
    };

    class GrammarMember : public Node {
    protected:
        inline GrammarMember() : Node() {}
    public:
        class Visitor;

        virtual void visit(GrammarMember::Visitor& visitor) const = 0;
    };

    class GrammarMemberId : public GrammarMember {
    public:
        inline GrammarMemberId(const z::string& txt) : GrammarMember(), _txt(txt) {}

    public:
        inline const z::string& getText() const {return _txt;}

    private:
        virtual void visit(GrammarMember::Visitor& visitor) const;

    private:
        const z::string _txt;
    };

    class GrammarMemberNameId : public GrammarMember {
    public:
        inline GrammarMemberNameId(const Ast::VariableDef& vdef, const z::string& txt)
            : GrammarMember(), _vdef(vdef), _txt(txt) {}

    public:
        inline const Ast::VariableDef& getDef() const {return _vdef;}

        inline const z::string& getText() const {return _txt;}

    private:
        virtual void visit(GrammarMember::Visitor& visitor) const;

    private:
        const Ast::VariableDef& _vdef;

        const z::string _txt;
    };

    class GrammarMemberList : public Node {
    public:
        typedef z::list<const GrammarMember*> List;

    public:
        inline GrammarMemberList() : Node() {}

    public:
        inline void addMember(const GrammarMember& member) {_list.append(ptr(member));}

        inline const List& getList() const {return _list;}

    private:
        List _list;
    };

    class FunctionBlock;

    class GrammarStatement : public Node {
    protected:
        inline GrammarStatement(const z::string& name, const Ast::FunctionDef& fdef, const Ast::FunctionBlock& fblock)
            : Node(), _name(name), _fdef(fdef), _fblock(fblock) {}

    public:
        inline const z::string& getName() const {return _name;}

        inline const FunctionDef& getFunctionDef() const {return _fdef;}

        inline const FunctionBlock& getBlock() const {return _fblock;}

    public:
        class Visitor;

        virtual void visit(GrammarStatement::Visitor& visitor) const = 0;

    private:
        const z::string _name;

        const Ast::FunctionDef& _fdef;

        const Ast::FunctionBlock& _fblock;
    };

    class GrammarRuleStatement : public GrammarStatement {
    public:
        inline GrammarRuleStatement(const z::string& name, const Ast::FunctionDef& fdef, const Ast::FunctionBlock& fblock, const Ast::GrammarMemberList& list)
            : GrammarStatement(name, fdef, fblock), _list(list) {}

    public:
        inline const Ast::GrammarMemberList& getList() const {return _list;}

    private:
        virtual void visit(GrammarStatement::Visitor& visitor) const;

    private:
        const Ast::GrammarMemberList& _list;
    };

    class GrammarLexer;

    class LexerStatement : public GrammarStatement {
    public:
        inline LexerStatement(const z::string& name, const Ast::FunctionDef& fdef, const Ast::FunctionBlock& fblock, GrammarLexer& lexer, const Ast::GrammarTokenList& list)
            : GrammarStatement(name, fdef, fblock), _lexer(lexer), _list(list) {}

    public:
        inline const GrammarLexer& getLexer() const {return _lexer;}

        inline const Ast::GrammarTokenList& getList() const {return _list;}

    private:
        virtual void visit(GrammarStatement::Visitor& visitor) const;

    private:
        const GrammarLexer& _lexer;

        const Ast::GrammarTokenList& _list;
    };

    class LexerStatementList : public Node {
    public:
        typedef z::list<LexerStatement*> List;

    public:
        inline LexerStatementList() : Node() {}

    public:
        inline const List& getList() const {return _list;}

    public:
        inline void addStatement(LexerStatement& statement) {_list.append(ptr(statement));}

    private:
        List _list;
    };

    class GrammarLexer : public Node {
    public:
        inline GrammarLexer(const z::string& name) : Node(), _name(name), _list(0) {}

    public:
        inline const z::string& getName() const {return _name;}

        inline void setList(const LexerStatementList& value) {_list = ptr(value);}

        inline const LexerStatementList& getList() const {return ref(_list);}

    private:
        const z::string _name;

        const LexerStatementList* _list;
    };

    class GrammarLexerList : public Node {
    public:
        typedef z::list<const GrammarLexer*> List;

    public:
        inline GrammarLexerList() : Node() {}

    public:
        inline const List& getList() const {return _list;}

        inline void addLexer(const GrammarLexer& lexer) {_list.append(ptr(lexer));}

    private:
        List _list;
    };

    class GrammarStatementList : public Node {
    public:
        typedef z::list<const GrammarStatement*> List;

    public:
        inline GrammarStatementList() : Node() {}

    public:
        inline const List& getList() const {return _list;}

    public:
        inline void addRuleStatement(GrammarStatement& statement) {_list.append(ptr(statement));}

    private:
        List _list;
    };

    class GrammarOptionValueList : public Node {
    public:
        inline GrammarOptionValueList() : Node() {}

    public:
        inline const z::stringlist& getList() const {return _list;}

        inline void addValue(const z::string& value) {_list.append(value);}

    private:
        z::stringlist _list;
    };

    class GrammarOption : public Node {
    public:
        inline GrammarOption(const z::string& name, const GrammarOptionValueList& list) : Node(), _name(name), _list(list) {}

    public:
        inline const z::string& getName() const {return _name;}

        inline const GrammarOptionValueList& getList() const {return _list;}

    private:
        const z::string _name;

        const GrammarOptionValueList& _list;
    };

    class GrammarOptionList : public Node {
    public:
        typedef z::list<const GrammarOption*> List;

    public:
        inline GrammarOptionList() : Node() {}

    public:
        inline const List& getList() const {return _list;}

        inline void addOption(GrammarOption& option) {_list.append(ptr(option));}

    private:
        List _list;
    };

    class FunctionImplItem;


    class ImplItem : public Node {
    protected:
        inline ImplItem(const int& idx, const Ast::FunctionDef& fdef) : _idx(idx), _fdef(fdef) {}

    public:
        inline const int& getIndex() const {return _idx;}

        inline const Ast::FunctionDef& getFunctionDef() const {return _fdef;}

    public:
        class Visitor;

        virtual void visit(Visitor& visitor) const = 0;

    public:
        virtual const Ast::FunctionImplItem& getFunctionImplItem() const = 0;

    private:
        const int _idx;

        const Ast::FunctionDef& _fdef;
    };

    // Container items
    class Expr;

    template <typename ItemT>
    class ListBase : public Node {
    public:
        typedef z::list<const ItemT*> List;

    public:
        inline ListBase() {}

    public:
        inline const List& getList() const {return _list;}

        inline void addItem(const ItemT& item) {_list.append(&item);}

    private:
        List _list;
    };

    class ListItem : public Node {
    public:
        inline ListItem(const Expr& expr) : _expr(expr) {}

    public:
        inline const Ast::Expr& getExpr() const {return _expr;}

    private:
        const Expr& _expr;
    };

    class ListList : public ListBase<ListItem> {
    public:
        inline ListList() : _type(0) {}

    public:
        inline const QualifiedType* hasType() const {return _type;}

        inline void setType(const QualifiedType* type) {_type = type;}

    private:
        const QualifiedType* _type;
    };

    class DictItem : public Node {
    public:
        inline DictItem(const Expr& key, const Expr& expr) : _key(key), _expr(expr) {}

    public:
        inline const Ast::Expr& getKey() const {return _key;}

        inline const Ast::Expr& getExpr() const {return _expr;}

    private:
        const Expr& _key;

        const Expr& _expr;
    };

    class DictList : public ListBase<DictItem> {
    public:
        inline DictList() : _key(0), _type(0) {}

    public:
        inline const QualifiedType* hasKey() const {return _key;}

        inline void setKeyType(const QualifiedType* key) {_key = key;}

        inline const QualifiedType* hasType() const {return _type;}

        inline void setValueType(const QualifiedType* type) {_type = type;}

    private:
        const QualifiedType* _key;

        const QualifiedType* _type;
    };

    // Expressions
    class Expr : public Node {
    public:
        inline Expr(const QualifiedType& type) : _type(type) {}

    public:
        class Visitor;

        virtual void visit(Visitor& visitor) const = 0;

    public:
        inline const QualifiedType& getType() const { return _type; }

    private:
        const QualifiedType& _type;
    };

    class ExprList : public Node {
    public:
        typedef z::list<const Expr*> List;

    public:
        inline const List& getList() const {return _list;}

        inline void addExpr(const Expr& expr) {_list.append(&expr);}

    private:
        List _list;
    };


    class InvokerType : public Node {
    protected:
        inline InvokerType(const FunctionDef& functionDef) : _functionDef(functionDef) {}

    public:
        inline const FunctionDef& getFunctionDef() const {return _functionDef;}

    public:
        class Visitor;

        virtual void visit(Visitor& visitor) const = 0;

    private:
        const FunctionDef& _functionDef;
    };

    class Invoker : public Node {
    public:
        inline Invoker(const InvokerType& invokerType, const ExprList& exprList) : _invokerType(invokerType), _exprList(exprList) {}

    public:
        inline const InvokerType& getInvokerType() const {return _invokerType;}

        inline const ExprList& getExprList() const {return _exprList;}

    private:
        const InvokerType& _invokerType;

        const ExprList& _exprList;
    };


    class FunctionCall : public InvokerType {
    public:
        inline FunctionCall(const FunctionDef& functionDef) : InvokerType(functionDef)  {}

    private:
        virtual void visit(Visitor& visitor) const;
    };


    class FunctorCall : public InvokerType {
    public:
        inline FunctorCall(const FunctionDef& functionDef, const Expr& expr) : InvokerType(functionDef), _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Expr& _expr;
    };


    class FunctionDefCall : public InvokerType {
    public:
        inline FunctionDefCall(const FunctionDef& functionDef, const ImplItem& item) : InvokerType(functionDef), _item(item)  {}

    public:
        inline const ImplItem& getImpl() const {return _item;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const ImplItem& _item;
    };


    class FunctionImplCall : public InvokerType {
    public:
        inline FunctionImplCall(const FunctionDef& functionDef, const ImplItem& item) : InvokerType(functionDef), _item(item)  {}

    public:
        inline const ImplItem& getImpl() const {return _item;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const ImplItem& _item;
    };

    // Expression concrete classes

    class TernaryOpExpr : public Expr {
    public:
        inline TernaryOpExpr(const QualifiedType& type, const Expr& lhs, const z::string& op1, const Expr& rhs1, const z::string& op2, const Expr& rhs2)
            : Expr(type), _lhs(lhs), _op1(op1), _rhs1(rhs1), _op2(op2), _rhs2(rhs2) {}

    public:
        inline const Expr& getLhs() const {return _lhs;}

        inline const z::string& getOp1() const {return _op1;}

        inline const Expr& getRhs1() const {return _rhs1;}

        inline const z::string& getOp2() const {return _op2;}

        inline const Expr& getRhs2() const {return _rhs2;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Expr& _lhs;

        const z::string _op1;

        const Expr& _rhs1;

        const z::string _op2;

        const Expr& _rhs2;
    };

    class BinaryExpr : public Expr {
    public:
        inline BinaryExpr(const QualifiedType& type, const Expr& lhs, const z::string& op, const Expr& rhs) : Expr(type), _lhs(lhs), _op(op), _rhs(rhs) {}

    public:
        inline const Expr& getLhs() const {return _lhs;}

        inline const z::string& getOp() const {return _op;}

        inline const Expr& getRhs() const {return _rhs;}

    private:
        const Expr& _lhs;

        const z::string _op;

        const Expr& _rhs;
    };

    class BinaryOpExpr : public BinaryExpr {
    public:
        inline BinaryOpExpr(const QualifiedType& type, const Expr& lhs, const z::string& op, const Expr& rhs) : BinaryExpr(type, lhs, op, rhs) {}
    private:
        virtual void visit(Visitor& visitor) const;

    };

    class UnaryOpExpr : public Expr {
    protected:
        inline UnaryOpExpr(const QualifiedType& type, const z::string& op, const Expr& expr) : Expr(type), _op(op), _expr(expr) {}

    public:
        inline const z::string& getOp() const {return _op;}

        inline const Expr& getExpr() const {return _expr;}

    private:
        const z::string _op;

        const Expr& _expr;
    };


    class PrefixOpExpr : public UnaryOpExpr {
    public:
        inline PrefixOpExpr(const QualifiedType& type, const z::string& op, const Expr& rhs) : UnaryOpExpr(type, op, rhs) {}

    private:
        virtual void visit(Visitor& visitor) const;
    };


    class PostfixOpExpr : public UnaryOpExpr {
    public:
        inline PostfixOpExpr(const QualifiedType& type, const Expr& lhs, const z::string& op) : UnaryOpExpr(type, op, lhs) {}

    private:
        virtual void visit(Visitor& visitor) const;
    };


    class OrderedExpr : public Expr {
    public:
        inline OrderedExpr(const QualifiedType& type, const Expr& expr) : Expr(type), _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Expr& _expr;
    };


    class IndexExpr : public Expr {
    public:
        inline IndexExpr(const QualifiedType& type, const Expr& expr, const Expr& idx) : Expr(type), _expr(expr), _idx(idx) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

        inline const Expr& getIndex() const {return _idx;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Expr& _expr;

        const Expr& _idx;
    };


    class Splice : public Node {
    public:
        inline Splice(const Expr& start, const Expr& stop, const Expr& step) : _start(start), _stop(stop), _step(step) {}

    public:
        inline const Expr& getStart() const {return _start;}

        inline const Expr& getStop() const {return _stop;}

        inline const Expr& getStep() const {return _step;}

    private:
        const Expr& _start;

        const Expr& _stop;

        const Expr& _step;
    };


    class SpliceExpr : public Expr {
    public:
        inline SpliceExpr(const QualifiedType& type, const Expr& lhs, const Splice& splice) : Expr(type), _lhs(lhs), _splice(splice) {}

    public:
        inline const Expr& getLhs() const {return _lhs;}

        inline const Splice& getSplice() const {return _splice;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Expr& _lhs;

        const Splice& _splice;
    };


    class StringFormatExpr : public Expr {
    public:
        inline StringFormatExpr(const QualifiedType& type, const Expr& format, const Ast::DictList& list) : Expr(type), _format(format), _list(list) {}

    public:
        inline const Expr& getFormat() const {return _format;}

        inline const Ast::DictList& getList() const {return _list;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Expr& _format;

        const Ast::DictList& _list;
    };


    class InstanceExpr : public Expr {
    public:
        inline InstanceExpr(const QualifiedType& type, const Ast::ExprList& list) : Expr(type), _list(list) {}

    public:
        inline const Ast::ExprList& getList() const {return _list;}

    private:
        const Ast::ExprList& _list;
    };


    class TypeDefExpr : public InstanceExpr {
    public:
        inline TypeDefExpr(const QualifiedType& type, const Ast::ExprList& list) : InstanceExpr(type, list) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class StructExpr : public InstanceExpr {
    public:
        inline StructExpr(const QualifiedType& type, const Ast::ExprList& list) : InstanceExpr(type, list) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class FunctionExpr : public InstanceExpr {
    public:
        inline FunctionExpr(const QualifiedType& type, const FunctionDef& function, const ExprList& list) : InstanceExpr(type, list), _function(function) {}

    public:
        inline const FunctionDef& getFunction() const {return _function;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const FunctionDef& _function;
    };


    class ListTemplateExpr : public InstanceExpr {
    public:
        inline ListTemplateExpr(const QualifiedType& type, const ExprList& list) : InstanceExpr(type, list) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class DictTemplateExpr : public InstanceExpr {
    public:
        inline DictTemplateExpr(const QualifiedType& type, const ExprList& list) : InstanceExpr(type, list) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class StructInitExpr : public Expr {
    public:
        inline StructInitExpr(const QualifiedType& type, const Ast::StructInitList& list) : Expr(type), _list(list) {}

    public:
        inline const Ast::StructInitList& getStructInitList() const {return _list;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Ast::StructInitList& _list;
    };


    class ListExpr : public Expr {
    public:
        inline ListExpr(const QualifiedType& type, const ListList& list) : Expr(type), _list(list) {}

    public:
        inline const ListList& getList() const {return _list;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const ListList& _list;
    };

    class DictExprBase : public Expr {
    protected:
        inline DictExprBase(const QualifiedType& type, const DictList& list) : Expr(type), _list(list) {}

    public:
        inline const DictList& getList() const {return _list;}

    private:
        const DictList& _list;
    };


    class DictExpr : public DictExprBase {
    public:
        inline DictExpr(const QualifiedType& type, const DictList& list) : DictExprBase(type, list) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class TreeExpr : public DictExprBase {
    public:
        inline TreeExpr(const QualifiedType& type, const DictList& list) : DictExprBase(type, list) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class QueryExpr : public Expr {
    public:
        inline QueryExpr(const QualifiedType& type, const Expr& expr) : Expr(type), _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Expr& _expr;
    };


    class QueryPartExpr : public Expr {
    public:
        inline QueryPartExpr(const QualifiedType& type, const Expr& keyExpr, const Expr& valExpr) : Expr(type), _keyExpr(keyExpr), _valExpr(valExpr) {}

    public:
        inline const Expr& getKeyExpr() const {return _keyExpr;}

        inline const Expr& getValExpr() const {return _valExpr;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    private:
        const Expr& _keyExpr;

        const Expr& _valExpr;
    };


    class QueryBinaryExpr : public BinaryExpr {
    public:
        inline QueryBinaryExpr(const QualifiedType& type, const Expr& lhs, const z::string& op, const Expr& rhs) : BinaryExpr(type, lhs, op, rhs) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class QueryValExpr : public Expr {
    public:
        inline QueryValExpr(const QualifiedType& type) : Expr(type) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class QueryConstantExpr : public Expr {
    public:
        inline QueryConstantExpr(const QualifiedType& type, const Expr& expr) : Expr(type), _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Expr& _expr;
    };


    class VariableRefExpr : public Expr {
    public:
        inline VariableRefExpr(const QualifiedType& type, const VariableRef& vref) : Expr(type), _vref(vref) {}

    public:
        inline const VariableRef& getRef() const {return _vref;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const VariableRef& _vref;
    };


    class EnumRefExpr : public Expr {
    public:
        inline EnumRefExpr(const QualifiedType& type, const Ast::EnumDef& enumDef, const z::string& id) : Expr(type), _enumDef(enumDef), _id(id) {}

    public:
        inline const EnumDef& getEnumDef() const {return _enumDef;}

        inline const z::string& getId() const {return _id;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const EnumDef& _enumDef;

        const z::string _id;
    };


    class InternalCallExpr : public Expr {
    public:
        inline InternalCallExpr(const QualifiedType& type, const z::string& name, const ExprList& list) : Expr(type), _name(name), _list(list) {}

    public:
        inline const z::string& getName() const {return _name;}

        inline const ExprList& getList() const {return _list;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const z::string _name;

        const ExprList& _list;
    };


    class InvokerCallExpr : public Expr {
    public:
        inline InvokerCallExpr(const QualifiedType& type, const Invoker& invoker) : Expr(type), _invoker(invoker) {}

    public:
        inline const Invoker& getInvoker() const {return _invoker;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Invoker& _invoker;
    };

    class ContinuationImplItem;


    class FunctionCallExpr : public Expr {
    public:
        inline FunctionCallExpr(const QualifiedType& type, const Ast::ContinuationImplItem& continuation) : Expr(type), _continuation(continuation) {}

    public:
        inline const Ast::ContinuationImplItem& getContinuation() const {return _continuation;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Ast::ContinuationImplItem& _continuation;
    };


    class FunctionImplExpr : public Expr {
    public:
        inline FunctionImplExpr(const QualifiedType& type, const Ast::FunctionImplItem& item) : Expr(type), _item(item) {}

    public:
        inline const Ast::FunctionImplItem& getItem() const {return _item;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Ast::FunctionImplItem& _item;
    };


    class FunctionDefImplExpr : public Expr {
    public:
        inline FunctionDefImplExpr(const QualifiedType& type, const Ast::ImplItem& item) : Expr(type), _item(item) {}

    public:
        inline const Ast::ImplItem& getItem() const {return _item;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Ast::ImplItem& _item;
    };


    class AnyExpr : public Expr {
    public:
        inline AnyExpr(const QualifiedType& type, const Expr& expr) : Expr(type), _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Expr& _expr;
    };


    class CastExpr : public Expr {
    public:
        inline CastExpr(const QualifiedType& type, const Expr& expr) : Expr(type), _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Expr::Visitor& visitor) const;

    private:
        const Expr& _expr;
    };

    class ConstantExpr: public Expr {
    public:
        inline ConstantExpr(const QualifiedType& type, const z::string& value) : Expr(type), _value(value) {}

    public:
        inline const z::string& getValue() const {return _value;}

    private:
        const z::string _value;
    };


    class NumericConstantExpr : public ConstantExpr {
    public:
        inline NumericConstantExpr(const QualifiedType& type, const z::string& value) : ConstantExpr(type, value) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class BooleanConstantExpr : public ConstantExpr {
    public:
        inline BooleanConstantExpr(const QualifiedType& type, const z::string& value) : ConstantExpr(type, value) {}

    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class CharConstantExpr : public ConstantExpr {
    public:
        inline CharConstantExpr(const QualifiedType& type, const z::string& value) : ConstantExpr(type, value) {}
    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };


    class StringConstantExpr : public ConstantExpr {
    public:
        inline StringConstantExpr(const QualifiedType& type, const z::string& value) : ConstantExpr(type, value) {}
    private:
        virtual void visit(Expr::Visitor& visitor) const;
    };

    // Closures
    class Closure : public Node {
    public:
        typedef z::list<const Closure*> List;
    public:
        enum Type {
            None,   
            Link,   
            Join,   
        };

    protected:
        inline Closure(const VariableRefList& xRefList) : _type(None), _xRefList(xRefList) {}
    public:
        inline void setType(const Type& type) {_type = type;}

        inline bool isJoin() const {return (Join == _type);}

        inline const VariableRefList& getXRefList() const {return _xRefList;}

    public:
        class Visitor;

        virtual void visit(Visitor& visitor) const = 0;
    private:
        Type _type;

        const VariableRefList _xRefList;
    };


    class FunctionCallClosure : public Closure {
    public:
        inline FunctionCallClosure(const VariableRefList& xRefList, const Ast::VariableDef& vdef, const Ast::Invoker& invoker)
            : Closure(xRefList), _vdef(vdef), _invoker(invoker) {}

    public:
        inline const VariableDef& getDef() const {return _vdef;}

        inline const Invoker& getInvoker() const {return _invoker;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Ast::VariableDef& _vdef;

        const Ast::Invoker& _invoker;
    };


    class InitClosure : public Closure {
    protected:
        inline InitClosure(const VariableRefList& xRefList) : Closure(xRefList) {}

    public:
        virtual const Ast::QualifiedType& getOutType() const = 0;
    };


    class RunClosure : public InitClosure {
    public:
        inline RunClosure(const VariableRefList& xRefList, const Ast::QualifiedType& qtype) : InitClosure(xRefList), _qtype(qtype) {}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        virtual const Ast::QualifiedType& getOutType() const {return _qtype;}

    private:
        const Ast::QualifiedType& _qtype;
    };


    class ExitClosure : public InitClosure {
    public:
        inline ExitClosure(const VariableRefList& xRefList, const Ast::QualifiedType& qtype) : InitClosure(xRefList), _qtype(qtype) {}
    private:
        virtual void visit(Visitor& visitor) const;

    private:
        virtual const Ast::QualifiedType& getOutType() const {return _qtype;}

    private:
        const Ast::QualifiedType& _qtype;
    };


    class CallClosure : public InitClosure {
    public:
        inline CallClosure(const VariableRefList& xRefList, const Ast::VariableDef& vdef, const Ast::Invoker& invoker)
            : InitClosure(xRefList), _vdef(vdef), _invoker(invoker) {}

    public:
        inline const VariableDef& getDef() const {return _vdef;}

        inline const Invoker& getInvoker() const {return _invoker;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        virtual const Ast::QualifiedType& getOutType() const {return _invoker.getInvokerType().getFunctionDef().getOutType();}

    private:
        const Ast::VariableDef& _vdef;

        const Ast::Invoker& _invoker;
    };


    class LoopClosure : public Closure {
    public:
        inline LoopClosure(const VariableRefList& xRefList, const Ast::Expr& expr) : Closure(xRefList), _expr(expr) {}

    public:
        inline const Ast::Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Ast::Expr& _expr;
    };


    class SharedClosure : public Closure {
    public:
        inline SharedClosure(const VariableRefList& xRefList, const Ast::VariableDef& vdef, const Ast::SharedDef& sharedList)
            : Closure(xRefList), _vdef(vdef), _sharedList(sharedList) {}

    public:
        inline const VariableDef& getDef() const {return _vdef;}

        inline const Ast::SharedDef& getSharedList() const {return _sharedList;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Ast::VariableDef& _vdef;

        const Ast::SharedDef& _sharedList;
    };


    class ReturnClosure : public Closure {
    public:
        inline ReturnClosure(const VariableRefList& xRefList, const Ast::ExprList& list) : Closure(xRefList), _list(list) {}

    public:
        inline const ExprList& getList() const {return _list;}

    private:
        virtual void visit(Visitor& visitor) const;

    private:
        const Ast::ExprList& _list;
    };


    class ClosureList : public Node {
    public:
        inline const Closure::List& getClosureList() const {return _list;}

        inline void addClosure(const Closure& closure) { _list.append(ptr(closure));}

    public:
        void visitClosureList(Closure::Visitor& visitor) const;

    private:
        Closure::List _list;
    };

    // Statements

    class Statement : public Node {
    protected:
        inline Statement(){}

    public:
        class Visitor;

        virtual void visit(Visitor& visitor) const = 0;
    };


    class StatementList : public Node {
    public:
        typedef z::list<Statement*> List;

    public:
        explicit inline StatementList() {}

    public:
        inline void addStatement(Statement& statement) {_list.append(ptr(statement));}

        inline const List& getList() const {return _list;}

    private:
        List _list;
    };


    class StatementBlock : public Statement {
    public:
        explicit inline StatementBlock(const StatementList& list) : Statement(), _list(list) {}

    public:
        inline const StatementList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const StatementList& _list;
    };


    class ExprStatement : public Statement {
    public:
        inline ExprStatement(const Ast::Expr& expr) : _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::Expr& _expr;
    };


    class DefineVarStatement : public Statement {
    public:
        inline DefineVarStatement(const InitVariableDef& vdef) : _vdef(vdef) {}

    public:
        inline const InitVariableDef& getDef() const {return _vdef;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const InitVariableDef& _vdef;
    };


    class LogStatement : public Statement {
    public:
        inline LogStatement(const z::string& name, const Ast::ExprList& list) : _name(name), _list(list) {}

    public:
        inline const z::string& getName() const {return _name;}

        inline const ExprList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const z::string _name;

        const Ast::ExprList& _list;
    };


    class IfStatement : public Statement {
    protected:
        inline IfStatement(const Ast::Expr& cond, const Ast::StatementList& tlist) : _cond(cond), _tlist(tlist) {}

    public:
        inline const Ast::Expr& getCond() const {return _cond;}

        inline const Ast::StatementList& getTList() const {return _tlist;}

    private:
        const Ast::Expr& _cond;

        const Ast::StatementList& _tlist;
    };


    class IfThenStatement : public IfStatement {
    public:
        inline IfThenStatement(const Ast::Expr& cond, const Ast::StatementList& tlist) : IfStatement(cond, tlist) {}
    private:
        virtual void visit(Statement::Visitor& visitor) const;
    };


    class IfElseStatement : public IfStatement {
    public:
        inline IfElseStatement(const Ast::Expr& cond, const Ast::StatementList& tlist, const Ast::StatementList& flist) : IfStatement(cond, tlist), _flist(flist) {}

    public:
        inline const Ast::StatementList& getFList() const {return _flist;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::StatementList& _flist;
    };


    class SwitchLabel : public Node {
    protected:
        inline SwitchLabel(const Ast::StatementList& list) : _list(list) {}

    public:
        inline const Ast::StatementList& getList() const {return _list;}

    private:
        const Ast::StatementList& _list;
    };


    class CaseLabel : public SwitchLabel {
    public:
        inline CaseLabel(const Ast::Expr& expr, const Ast::StatementList& list) : SwitchLabel(list), _expr(expr) {}

    public:
        inline const Ast::Expr& getExpr() const {return _expr;}

    private:
        const Ast::Expr& _expr;
    };


    class DefaultLabel : public SwitchLabel {
    public:
        inline DefaultLabel(const Ast::StatementList& list) : SwitchLabel(list) {}
    };


    class SwitchLabelList : public Node {
    public:
        typedef z::list<CaseLabel*> List;
    public:
        inline SwitchLabelList() : _defaultLabel(0) {}

    public:
        inline void addCase(CaseLabel& label) {_list.append(ptr(label));}

        inline void addDefault(DefaultLabel& label) {assert(_defaultLabel == 0); _defaultLabel = ptr(label);}

        inline const List& getList() const {return _list;}

        inline bool hasDefault() const {return (_defaultLabel != 0);}

        inline const DefaultLabel& getDefault() const {return ref(_defaultLabel);}

    private:
        List _list;

        DefaultLabel* _defaultLabel;
    };


    class SelectStatement : public Statement {
    public:
        inline SelectStatement(const Ast::SwitchLabelList& list) : _list(list) {}

    public:
        inline const Ast::SwitchLabelList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::SwitchLabelList& _list;
    };


    class SwitchStatement : public Statement {
    public:
        inline SwitchStatement(const Ast::Expr& expr, const Ast::SwitchLabelList& list) : _expr(expr), _list(list) {}

    public:
        inline const Ast::Expr& getExpr() const {return _expr;}

        inline const Ast::SwitchLabelList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::Expr& _expr;

        const Ast::SwitchLabelList& _list;
    };


    class TypeSpecStatement : public Statement {
    public:
        inline TypeSpecStatement(const Ast::TypeSpec& typeSpec) : _typeSpec(typeSpec) {}

    public:
        inline const Ast::TypeSpec& getTypeSpec() const {return _typeSpec;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::TypeSpec& _typeSpec;
    };


    class BreakStatement : public Statement {
    public:
        inline BreakStatement() {}

    private:
        virtual void visit(Statement::Visitor& visitor) const;
    };


    class ContinueStatement : public Statement {
    public:
        inline ContinueStatement() {}

    private:
        virtual void visit(Statement::Visitor& visitor) const;
    };


    class EmptyStatement : public Statement {
    public:
        inline EmptyStatement() {}

    private:
        virtual void visit(Statement::Visitor& visitor) const;
    };


    class ForStatement : public Statement {
    public:
        inline ForStatement(const Ast::InitVariableDef& init, const Ast::Expr& cond, const Ast::Expr& incx, const Ast::StatementList& list)
            : _init(init), _cond(cond), _incx(incx), _list(list) {}

    public:
        inline const Ast::InitVariableDef& getInit() const {return _init;}

        inline const Ast::Expr& getCond() const {return _cond;}

        inline const Ast::Expr& getIncx() const {return _incx;}

        inline const Ast::StatementList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::InitVariableDef& _init;

        const Ast::Expr& _cond;

        const Ast::Expr& _incx;

        const Ast::StatementList& _list;
    };


    class ForeachStatement : public Statement {
    public:
        inline ForeachStatement(const Ast::InitVariableDef& init, const Ast::StatementList& list) : _init(init), _list(list) {}

    public:
        inline const Ast::InitVariableDef& getInit() const {return _init;}

        inline const Ast::StatementList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::InitVariableDef& _init;

        const Ast::StatementList& _list;
    };


    class WhileStatement : public Statement {
    public:
        inline WhileStatement(const Ast::Expr& cond, const Ast::StatementList& list) : _cond(cond), _list(list) {}

    public:
        inline const Ast::Expr& getCond() const {return _cond;}

        inline const Ast::StatementList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::Expr& _cond;

        const Ast::StatementList& _list;
    };


    class DoWhileStatement : public Statement {
    public:
        inline DoWhileStatement(const Ast::Expr& cond, const Ast::StatementList& list) : _cond(cond), _list(list) {}

    public:
        inline const Ast::Expr& getCond() const {return _cond;}

        inline const Ast::StatementList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::Expr& _cond;

        const Ast::StatementList& _list;
    };


    class RoutineReturnStatement : public Statement {
    public:
        inline RoutineReturnStatement(const Expr& expr) : _expr(expr) {}

    public:
        inline const Expr& getExpr() const {return _expr;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Expr& _expr;
    };


    class FunctionReturnStatement : public Statement {
    public:
        inline FunctionReturnStatement(Ast::FunctionDef& fdef, const ExprList& list) : _fdef(fdef), _list(list) {}

    public:
        inline const Ast::FunctionDef& getFunctionDef() const {return _fdef;}

        inline const ExprList& getList() const {return _list;}

    private:
        virtual void visit(Statement::Visitor& visitor) const;

    private:
        const Ast::FunctionDef& _fdef;

        const ExprList& _list;
    };

    // Blocks

    class BlockBase : public Node {
    public:
        explicit inline BlockBase(const VariableRefList& refList) : _xRefList(refList) {}

    public:
        inline const VariableRefList& getXRefList() const {return _xRefList;}

    private:
        const VariableRefList _xRefList;
    };


    class RoutineBlock : public BlockBase {
    public:
        explicit inline RoutineBlock(const VariableRefList& refList, const StatementBlock& block) : BlockBase(refList), _block(block) {}

    public:
        inline const StatementBlock& getStatementBlock() const {return _block;}

    private:
        const StatementBlock& _block;
    };


    class FunctionBlock : public BlockBase {
    public:
        explicit inline FunctionBlock(const VariableRefList& refList, const StatementBlock& block) : BlockBase(refList), _block(block) {}

    public:
        inline const StatementBlock& getStatementBlock() const {return _block;}

    private:
        const StatementBlock& _block;
    };


    class GrammarBlock : public BlockBase {
    public:
        inline GrammarBlock(const VariableRefList& refList, const GrammarOptionList& optList, const GrammarStatementList& list, const GrammarLexerList& lexList)
            : BlockBase(refList), _optList(optList), _list(list), _lexList(lexList) {}

    public:
        inline const GrammarOptionList& getOptList() const {return _optList;}

        inline const GrammarStatementList& getList() const {return _list;}

        inline const GrammarLexerList& getLexList() const {return _lexList;}

    private:
        const Ast::GrammarOptionList& _optList;

        const Ast::GrammarStatementList& _list;

        const Ast::GrammarLexerList& _lexList;
    };


    class WindowBlock : public BlockBase {
    public:
        inline WindowBlock(const VariableRefList& refList, const Ast::FunctionBlock& functionBlock) : BlockBase(refList), _functionBlock(functionBlock) {}

    public:
        inline const FunctionBlock& getFunctionBlock() const {return _functionBlock;}

    private:
        const Ast::FunctionBlock& _functionBlock;
    };

    // Implementation Items

    class ContinuationImplItem : public ImplItem {
    public:
        inline ContinuationImplItem(const int& idx, const FunctionDef& fdef, const Ast::ClosureList& closureList, const ReturnClosure& retnClosure)
            : ImplItem(idx, fdef), _closureList(closureList), _retnClosure(retnClosure) {}

    public:
        inline z::string getUniqueName(const z::string& sep) const {
            return z::string::creator("_cont_%{n}%{s}%{i}")
                .arg(z::any("n"), z::any(getFunctionDef().getName()))
                .arg(z::any("s"), z::any(sep))
                .arg(z::any("i"), z::any(getIndex())).value();
        }

    public:
        inline const Ast::ClosureList& getClosureList() const {return _closureList;}

        inline const Ast::ReturnClosure& getReturnClosure() const {return _retnClosure;}

        inline const VariableRefList& getXRefList() const {return _xRefList;}

        inline void setXRefList(const VariableRefList& xRefList) {_xRefList.appendList(xRefList);}

    private:
        inline const InitClosure* getInitClosureP() const {
            assert(_closureList.getClosureList().size() > 0);
            const Closure* c = _closureList.getClosureList().at(0);
            const InitClosure* rv = dcast<const InitClosure>(c, "Closure is not an InitClosure");
            return rv;
        }

    public:
        inline const InitClosure& getInitClosure() const {
            const InitClosure* c = getInitClosureP();
            assert(c);
            return ref(c);
        }

    public:
        inline const Invoker* hasRoutineCall() const {
            const InitClosure* i = getInitClosureP();
            assert(i);
            const CallClosure* c = dynamic_cast<const CallClosure*>(i); // not using dcast because 0 is a valid value
            if(!c)
                return 0;

            const Invoker& invoker = ref(c).getInvoker();
            if(invoker.getInvokerType().getFunctionDef().getModifier() != Ast::FunctionDef::Modifier::Routine)
                return 0;

            return ptr(invoker);
        }

    public:
        void visitClosureList(Closure::Visitor& visitor) const;

    public:
        virtual const Ast::FunctionImplItem& getFunctionImplItem() const {throw z::exception(z::string::creator("Internal error").value());}

    private:
        virtual void visit(ImplItem::Visitor& visitor) const;

    private:
        VariableRefList _xRefList;

        const Ast::ClosureList& _closureList;

        const ReturnClosure& _retnClosure;
    };


    class RoutineImplItem : public ImplItem {
    public:
        inline RoutineImplItem(const int& idx, const Ast::FunctionDef& fdef, const Ast::RoutineBlock& block) : ImplItem(idx, fdef), _block(block) {}

    public:
        inline z::string getUniqueName(const z::string& sep) const {
            unused(sep);
            return z::string::creator("%{n}")
                .arg(z::any("n"), z::any(getFunctionDef().getName()))
                .value();
        }

        inline const Ast::RoutineBlock& getBlock() const {return _block;}

    private:
        virtual void visit(ImplItem::Visitor& visitor) const;

        virtual const Ast::FunctionImplItem& getFunctionImplItem() const {throw z::exception(z::string::creator("Internal error").value());}

    private:
        const Ast::RoutineBlock& _block;
    };


    class FunctionImplItem : public ImplItem {
    public:
        inline FunctionImplItem(const int& idx, const Ast::FunctionDef& fdef, const Ast::FunctionBlock& block) : ImplItem(idx, fdef), _block(block) {}

    public:
        inline z::string getUniqueName(const z::string& sep) const {
            return z::string::creator("_fun_%{n}%{s}%{i}")
                .arg(z::any("n"), z::any(getFunctionDef().getName()))
                .arg(z::any("s"), z::any(sep))
                .arg(z::any("i"), z::any(getIndex())).value();
        }

    public:
        inline const Ast::FunctionBlock& getBlock() const {return _block;}

    private:
        virtual void visit(ImplItem::Visitor& visitor) const;

        virtual const Ast::FunctionImplItem& getFunctionImplItem() const {return ref(this);}

    private:
        const Ast::FunctionBlock& _block;
    };


    class GrammarImplItem : public ImplItem {
    public:
        inline GrammarImplItem(const int& idx, const Ast::FunctionDef& fdef, const Ast::GrammarBlock& block) : ImplItem(idx, fdef), _block(block) {}

    public:
        inline z::string getUniqueName(const z::string& sep) const {
            return z::string::creator("_gra_%{n}%{s}%{i}")
                .arg(z::any("n"), z::any(getFunctionDef().getName()))
                .arg(z::any("s"), z::any(sep))
                .arg(z::any("i"), z::any(getIndex())).value();
        }

        inline const Ast::GrammarBlock& getBlock() const {return _block;}

    private:
        virtual void visit(ImplItem::Visitor& visitor) const;

        virtual const Ast::FunctionImplItem& getFunctionImplItem() const {throw z::exception(z::string::creator("Internal error").value());}

    private:
        const Ast::GrammarBlock& _block;
    };


    class WindowImplItem : public ImplItem {
    public:
        inline WindowImplItem(const int& idx, const Ast::FunctionDef& fdef, const Ast::WindowBlock& block) : ImplItem(idx, fdef), _block(block) {}

    public:
        inline z::string getUniqueName(const z::string& sep) const {
            return z::string::creator("_win_%{n}%{s}%{i}")
                .arg(z::any("n"), z::any(getFunctionDef().getName()))
                .arg(z::any("s"), z::any(sep))
                .arg(z::any("i"), z::any(getIndex())).value();
        }

        inline const Ast::WindowBlock& getBlock() const {return _block;}

    private:
        virtual void visit(ImplItem::Visitor& visitor) const;

        virtual const Ast::FunctionImplItem& getFunctionImplItem() const {throw z::exception(z::string::creator("Internal error").value());}

    private:
        const Ast::WindowBlock& _block;
    };


    class ImportStatement : public Node {
    public:
        enum Type {
            itImport,   
            itInclude,  
            itNative,   
        };

    public:
        inline ImportStatement() : _type(itInclude) {}

    public:
        inline void addPart(const z::string& part) {_name.append(part);}

        inline const z::stringlist& getName() const {return _name;}

    public:
        inline ImportStatement& setType(const Type& type) {_type = type; return ref(this);}

        inline const Type& getType() const {return _type;}

    private:
        z::stringlist _name;

        Type _type;
    };

    // Represents a compilation unit. Owner for all nodes.

    class Unit : public RootTypeSpec {
    public:
        typedef z::list<const Ast::ImportStatement*> ImportList;

        typedef z::list<const Ast::ImplItem*> ImplList;

    public:
        inline Unit(const AccessType::T& accessType)
            : RootTypeSpec(accessType, ""),
              _importNS(Ast::TypeSpec::AccessType::Public, ref(this), ""),
              _rootNS(Ast::TypeSpec::AccessType::Public, ref(this), ""),
              _mainContinuation(0),
              _projectDef(0) // if unit represents project file
        {}

    public:
        inline void setProjectDef(const Ast::StructInitExpr& expr) {_projectDef = ptr(expr);}

        inline const Ast::StructInitExpr& getProjectDef() {return ref(_projectDef);}

    public:
        inline void setMainContinuation(const Ast::ContinuationImplItem& continuation) {_mainContinuation = ptr(continuation);}

        inline bool hasMainContinuation() const {return (_mainContinuation != 0);}

        inline const Ast::ContinuationImplItem& getMainContinuation() const {return ref(_mainContinuation);}

    public:
        inline void setFilename(const z::string& filename) {_filename = filename;}

        inline const z::string& getFilename() const {return _filename;}

        inline Ast::ImportStatement& addImport(Ast::ImportStatement& stmt)  {_importList.append(ptr(stmt)); return stmt;}

        inline void addUnitNS(const z::string& name) {_unitNS.append(name);}

        inline void addItem(const ImplItem& item) {_implList.append(ptr(item));}

        template<typename T>
        inline T& addNode(T* node) {_nodeList.append(Ptr(node)); return ref(node);}

    public:
        inline Namespace& getRootNS() {return _rootNS;}

        inline const Namespace& getRootNS() const {return _rootNS;}

    public:
        inline Namespace& getImportNS() {return _importNS;}

        inline const Namespace& getImportNS() const {return _importNS;}

    public:
        inline const z::stringlist& getUnitNS() const {return _unitNS;}

        inline const ImportList& getImportList() const {return _importList;}

    public:
        inline const ImplList& getImplList() const {return _implList;}

    private:
        virtual void visit(TypeSpec::Visitor& visitor) const;

    private:
        z::string _filename;

        ImportList _importList;

    private:
        Ast::Namespace _importNS;

        Namespace _rootNS;

        z::stringlist _unitNS;

    private:
        ImplList _implList;

    private:
        typedef z::sharedptr<Node> Ptr;

        z::list<Ptr> _nodeList;

    private:
        const Ast::ContinuationImplItem* _mainContinuation;

    private:
        const Ast::StructInitExpr* _projectDef;
    };

    class TypeSpec::Visitor {
    public:
        inline Visitor(){}

        virtual ~Visitor(){}

    public:
        virtual void visit(const Ast::Unit& type) = 0;

        virtual void visit(const Ast::Namespace& type) = 0;

        virtual void visit(const Ast::StructDef& type) = 0;

        virtual void visit(const Ast::EnumDef& type) = 0;

        virtual void visit(const Ast::EnumMemberDef& type) = 0;

        virtual void visit(const Ast::OutParam& type) = 0;

        virtual void visit(const Ast::SharedDef& type) = 0;

        virtual void visit(const Ast::TypeDecl& type) = 0;

        virtual void visit(const Ast::TypeDef& type) = 0;

        virtual void visit(const Ast::OwnerTemplate& type) = 0;

        virtual void visit(const Ast::ListTemplate& type) = 0;

        virtual void visit(const Ast::DictTemplate& type) = 0;

        virtual void visit(const Ast::FunctionDef& type) = 0;
    };

    class InvokerType::Visitor {
    public:
        inline Visitor(){}

        virtual ~Visitor(){}

    public:
        virtual void visit(const Ast::FunctionCall& call) = 0;

        virtual void visit(const Ast::FunctorCall& call) = 0;

        virtual void visit(const Ast::FunctionDefCall& call) = 0;

        virtual void visit(const Ast::FunctionImplCall& call) = 0;
    };

    class Expr::Visitor {
    public:
        inline Visitor(){}

        virtual ~Visitor(){}

    public:
        virtual void visit(const Ast::TernaryOpExpr& expr) = 0;

        virtual void visit(const Ast::BinaryOpExpr&  expr) = 0;

        virtual void visit(const Ast::PrefixOpExpr&  expr) = 0;

        virtual void visit(const Ast::PostfixOpExpr& expr) = 0;

        virtual void visit(const Ast::OrderedExpr&  expr) = 0;

        virtual void visit(const Ast::IndexExpr& expr) = 0;

        virtual void visit(const Ast::ListExpr& expr) = 0;

        virtual void visit(const Ast::DictExpr& expr) = 0;

        virtual void visit(const Ast::TreeExpr& expr) = 0;

        virtual void visit(const Ast::QueryExpr& expr) = 0;

        virtual void visit(const Ast::QueryPartExpr& expr) = 0;

        virtual void visit(const Ast::QueryBinaryExpr& expr) = 0;

        virtual void visit(const Ast::QueryValExpr& expr) = 0;

        virtual void visit(const Ast::QueryConstantExpr& expr) = 0;

        virtual void visit(const Ast::StringFormatExpr& expr) = 0;

        virtual void visit(const Ast::TypeDefExpr& expr) = 0;

        virtual void visit(const Ast::StructExpr& expr) = 0;

        virtual void visit(const Ast::StructInitExpr& expr) = 0;

        virtual void visit(const Ast::FunctionExpr& expr) = 0;

        virtual void visit(const Ast::ListTemplateExpr& expr) = 0;

        virtual void visit(const Ast::DictTemplateExpr& expr) = 0;

        virtual void visit(const Ast::VariableRefExpr& expr) = 0;

        virtual void visit(const Ast::EnumRefExpr& expr) = 0;

        virtual void visit(const Ast::InternalCallExpr& expr) = 0;

        virtual void visit(const Ast::InvokerCallExpr& expr) = 0;

        virtual void visit(const Ast::FunctionCallExpr& expr) = 0;

        virtual void visit(const Ast::FunctionImplExpr& expr) = 0;

        virtual void visit(const Ast::FunctionDefImplExpr& expr) = 0;

        virtual void visit(const Ast::AnyExpr& expr) = 0;

        virtual void visit(const Ast::CastExpr& expr) = 0;

        virtual void visit(const Ast::NumericConstantExpr& expr) = 0;

        virtual void visit(const Ast::BooleanConstantExpr& expr) = 0;

        virtual void visit(const Ast::CharConstantExpr& expr) = 0;

        virtual void visit(const Ast::StringConstantExpr& expr) = 0;
    };

    class Closure::Visitor {
    public:
        inline Visitor(){}

        virtual ~Visitor(){}

    public:
        virtual void visit(const Ast::RunClosure& closure) = 0;

        virtual void visit(const Ast::ExitClosure& closure) = 0;

        virtual void visit(const Ast::LoopClosure& closure) = 0;

        virtual void visit(const Ast::SharedClosure& closure) = 0;

        virtual void visit(const Ast::CallClosure& closure) = 0;

        virtual void visit(const Ast::FunctionCallClosure& closure) = 0;

        virtual void visit(const Ast::ReturnClosure& closure) = 0;
    };

    class ImplItem::Visitor {
    public:
        inline Visitor(){}

        virtual ~Visitor(){}

    public:
        virtual void visit(const Ast::ContinuationImplItem& item) = 0;

        virtual void visit(const Ast::RoutineImplItem& item) = 0;

        virtual void visit(const Ast::FunctionImplItem& item) = 0;

        virtual void visit(const Ast::GrammarImplItem& item) = 0;

        virtual void visit(const Ast::WindowImplItem& item) = 0;
    };

    class GrammarMember::Visitor {
    public:
        inline Visitor(){}

        virtual ~Visitor(){}

    public:
        virtual void visit(const Ast::GrammarMemberId& member) = 0;

        virtual void visit(const Ast::GrammarMemberNameId& member) = 0;
    };

    class GrammarStatement::Visitor {
    public:
        inline Visitor(){}

        virtual ~Visitor(){}

    public:
        virtual void visit(const Ast::GrammarRuleStatement& stmt) = 0;

        virtual void visit(const Ast::LexerStatement& stmt) = 0;
    };

    class Statement::Visitor {
    public:
        inline Visitor(){}

        virtual ~Visitor(){}

    public:
        virtual void visit(const Ast::StatementBlock& stmt) = 0;

        virtual void visit(const Ast::ExprStatement& stmt) = 0;

        virtual void visit(const Ast::TypeSpecStatement& stmt) = 0;

        virtual void visit(const Ast::BreakStatement& stmt) = 0;

        virtual void visit(const Ast::ContinueStatement& stmt) = 0;

        virtual void visit(const Ast::EmptyStatement& stmt) = 0;

        virtual void visit(const Ast::IfThenStatement& stmt) = 0;

        virtual void visit(const Ast::IfElseStatement& stmt) = 0;

        virtual void visit(const Ast::ForStatement& stmt) = 0;

        virtual void visit(const Ast::ForeachStatement& stmt) = 0;

        virtual void visit(const Ast::SelectStatement& stmt) = 0;

        virtual void visit(const Ast::SwitchStatement& stmt) = 0;

        virtual void visit(const Ast::WhileStatement& stmt) = 0;

        virtual void visit(const Ast::DoWhileStatement& stmt) = 0;

        virtual void visit(const Ast::DefineVarStatement& stmt) = 0;

        virtual void visit(const Ast::LogStatement& stmt) = 0;

        virtual void visit(const Ast::RoutineReturnStatement& stmt) = 0;

        virtual void visit(const Ast::FunctionReturnStatement& stmt) = 0;
    };
}

// Inline method implementations that has dependencies.
template <typename T>
inline T& Ast::TypeSpec::addChild(T& child) {
    _childList.append(ptr(child));
    if(!child.hasParent())
        child.setParent(ref(this));
    const z::string& name = child.getName();
    _childMap.insert(name, ptr(child));
    return child;
}

template <typename T>
inline T* Ast::TypeSpec::hasChild(const z::string& name) const {
    ChildMap::found f = _childMap.find(name);
    if(!f)
        return 0;
    T* t = dynamic_cast<T*>(*f); // not using dcast because 0 is a valid value
    return t;
}