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

#pragma once

#include "Ast.hpp"

namespace zbl {
    class ParseContext;

    class RefCollector {
    private:
        struct StackItem {
            inline StackItem(const Ast::Scope::Type& type) : _type(type) {}

            Ast::Scope::Type _type;

            Ast::VariableDefMap _map;
        };

        typedef z::stack<StackItem*> DefStack;

    public:
        inline RefCollector(ParseContext& pctx, const Ast::Storage::T& storage) : _pctx(pctx), _storage(storage) {}

        inline ~RefCollector() {assert(_defStack.size() == 0);}

    private:
        inline RefCollector(const RefCollector& src) : _pctx(src._pctx), _storage(src._storage) {}

    public:
        void getInvokerRefList(const Ast::Invoker& invoker);

        void getImplItemRefList(const Ast::ImplItem& item);

        void getExprRefList(const Ast::Expr& expr);

        void getExprListRefList(const Ast::ExprList& list);

        void getSharedDefRefList(const Ast::SharedDef& sdef);

        void getStatementListRefList(const Ast::FunctionDef& fdef, const Ast::StatementList& list);

    public:
        inline const Ast::VariableRefList& getRefList() const {return _refList;}

    private:
        inline z::string printStack() const {
            z::string str;
            z::stringstream ss(str);
            for(DefStack::iterator it(_defStack); !it.end(); ++it) {
                const StackItem& si = ref(*it);
                ss << ((long)ptr(si._map)) << "{ ";
                for(Ast::VariableDefMap::List::iterator it2(si._map.getList()); !it2.end(); ++it2) {
                    const Ast::VariableDef& vd = ref(*it2);
                    ss << "{@name:" << vd.getName() << ", @ptr:" << ((long)ptr(vd)) << "}";
                }
                ss << " }";
            }
            return str;
        }
    private:
        inline StackItem& pushDefItem(const Ast::Scope::Type& type) {
            _defStack.push(new StackItem(type));
            return ref(_defStack.top());
        }

        inline void popDefItem(StackItem& item) {
            if(_defStack.top() != ptr(item)) {
                throw z::exception(z::string::creator("Internal error: DefStackItem mismatch").value());
            }
            StackItem* t = _defStack.top();
            _defStack.pop();
            delete t;
        }

    public:
        inline void addDef(const Ast::VariableDef& def) {
            ref(_defStack.top())._map.addDef(def);
        }

    public:
        inline bool hasDefItem(const Ast::VariableDef& vdef) {
            zbl::RefCollector::DefStack::iterator it(_defStack);
            it.toBack();
            while(!it.begin()) {
                const StackItem& si = ref(--it);
                const Ast::VariableDefMap& vdl = si._map;
                const Ast::VariableDefMap::List& list = vdl.getList();
                for(Ast::VariableDefMap::List::iterator it1(list); !it1.end(); ++it1) {
                    const Ast::VariableDef* vd = *it1;
                    if(vd == ptr(vdef)) {
                        return true;
                    }
                }
            }
            return false;
        }

    public:
        inline void setStorage(const Ast::VariableRef& vref, const Ast::Storage::T& storage) {
            // set the xref storage type.
            Ast::VariableRef& mref = const_cast<Ast::VariableRef&>(vref); // TODO: eliminate need to make mutable.
            mref.setStorage(storage);
        }

    public:
        inline bool addRef(const Ast::VariableRef& vref) {
            // is vref declared in any immediate scopes?
            if(hasDefItem(vref.getFirst())) {
                return false;
            }

            // If not, it is an xref. Is the xref already present in the xref list?
            if(!_refList.hasRef(vref)) {
                // if not, add it.
                _refList.addRef(vref);
            }
            return true;
        }

        inline void addRefWithStorage(const Ast::VariableRef& vref) {
            if(!addRef(vref)) {
                return;
            }

            // set storage type
            setStorage(vref, _storage);
        }

        inline void addRefList(const Ast::VariableRefList& xRefList) {
            for(Ast::VariableRefList::List::iterator it(xRefList.getList()); !it.end(); ++it) {
                const Ast::VariableRef& vref = ref(*it);
                // it is an external reference of the current continuation
                addRef(vref);
            }
        }

    public:
        struct DefStackItem {
            inline DefStackItem(RefCollector& ctx, const Ast::Scope::Type& type) : _ctx(ctx), _stackItem(0) {
                _stackItem = ptr(_ctx.pushDefItem(type));
            }

            inline ~DefStackItem() {
                _ctx.popDefItem(ref(_stackItem));
            }

            inline void addDef(const Ast::VariableDef& def) {
                _ctx.addDef(def);
            }

            inline bool hasRef(const Ast::VariableRef& vref) const {
                return ref(_stackItem)._map.hasDef(vref.getFirst().getName());
            }

        private:
            RefCollector& _ctx;

            StackItem* _stackItem;
        };
    private:
        ParseContext& _pctx;

        const Ast::Storage::T _storage;

        Ast::VariableRefList _refList;

        DefStack _defStack;
    };
}