context.h

Go to the documentation of this file.

#pragma once
#ifndef INCLUDED_NEWLANG_CONTEXT_
#define INCLUDED_NEWLANG_CONTEXT_
 
#include "term.h"
 
namespace newlang {
 
    struct VariableScope {
        TermID id;
        std::string ns;
        std::map<std::string, VariablePair> vars;
    };
 
    class LatterType : public std::variant<VariablePair, VariablePair *> {
    public:
 
        LatterType(VariablePair *pair = nullptr) : std::variant<VariablePair, VariablePair *>(pair) {
        }
 
        explicit LatterType(const VariablePair pair) : std::variant<VariablePair, VariablePair *>(pair) {
        }
 
        explicit LatterType(VariablePair &pair) : std::variant<VariablePair, VariablePair *>(&pair) {
        }
 
        template <typename D>
        static LatterType Create(TermPtr term, D d) {
            return LatterType(VariablePair(term, d));
        }
 
        inline VariablePair & GetVariablePair(bool editable = false) {
            if (std::holds_alternative<VariablePair>(*this)) {
                return std::get<VariablePair>(*this);
            } else if (std::get<VariablePair *>(*this)) {
                return *std::get<VariablePair *>(*this);
            }
            if (editable) {
                LOG_RUNTIME("GetVariablePair!!!!");
            }
            return const_cast<VariablePair &> (getNonePair());
        }
 
        inline operator bool() {
            return std::holds_alternative<VariablePair>(*this) || std::get<VariablePair *>(*this);
        }
 
//        inline LatterType & operator=(const LatterType &var) = default;
//        inline LatterType & operator=(const LatterType &var)
//        inline LatterType & operator=(const LatterType &var) {
//            static_cast<std::variant<VariablePair, VariablePair *>>(*this) = const_cast<LatterType>(var).GetVariablePair();
//            return *this;
//        }
 
        inline LatterType & operator=(const VariablePair var) {
            static_cast<std::variant<VariablePair, VariablePair *>>(*this) = static_cast<VariablePair>(var);
            return *this;
        }
 
//        inline LatterType & operator=(LatterType && var) {
//            static_cast<std::variant<VariablePair, VariablePair *>>(*this) = var;
//            return *this;
//        }
 
//        inline ObjPtr asObject(bool edit) {
//            return Variable::Object(const_cast<Variable *> (&this->GetVariablePair(edit).var));
//        }
 
    };
 
 
    typedef std::vector< LatterType > VariablePairList;
 
    class Context : public std::vector<VariableScope>, public std::enable_shared_from_this<Context> {
        friend class CtxPush;
 
    public:
        RunTime *m_runtime;
        LatterType m_latter;
 
        //        VariableType m_latter;
        // std::map<std::string, GlobalName *> m_cache;
        // В нем также содержится кеш имен для используемых статических объектов (функции и статические переменные),
        // чтобы не блокировать RunTime для чтения при каждом поиске глобального объекта.
 
        //        Module &m_static;
 
        Context(RunTime *rt);
 
        virtual ~Context() {
        }
 
        static LatterType Execute(Module &module, TermPtr ast, Context * runner);
        static LatterType EvalTerm(TermPtr term, Context *runner, bool rvalue = true);
        static LatterType Eval(TermPtr ast, Context * runner);
 
        static std::unique_ptr<Sync> CreateSync(const TermPtr &term);
 
        VariablePair * FindLocalVar(const TermPtr &term) {
            if (!isInternalName(term->m_normalized)) {
                LOG_RUNTIME("'%s' is not an internal name!", term->m_text.c_str());
            }
            return FindLocalVar(term->m_normalized);
        }
        VariablePair * FindLocalVar(const std::string_view name);
 
        VariablePair * FindObject(const std::string_view int_name);
        //        TermPtr FindInternalName(const std::string_view int_name);
 
 
        static std::string StringFormat(std::string_view format, Obj & args);
        static std::string StringPrintf(std::string_view format, Obj & args);
 
        static ObjPtr Call(Context *runner, Obj &obj, TermPtr & term);
        static ObjPtr Call(Context *runner, Obj &obj, Obj & args);
 
        std::string Dump(size_t num = 0);
 
    protected:
 
        void PushScope(const TermID id, const std::string_view &name) {
            std::string ns;
            if (!name.empty()) {
                ns = name;
                if (ns.rfind("::") != ns.size() - 2) {
                    ns += "::";
                }
            }
            push_back({id, ns,
                {}});
        }
 
        void PopScope() {
            ASSERT(size());
            pop_back();
        }
 
        bool CheckTargetScope(const std::string_view &name) {
            auto iter = rbegin();
            while (iter != rend()) {
                if (iter->ns.compare(name.begin()) == 0) {
                    return iter == rbegin(); // Выход из цикла только если блок текущий (поиск начат с него)
                }
                iter++;
            }
            LOG_RUNTIME("Named block '%s' not found!", name.begin());
        }
 
        static bool HasReThrow(TermPtr &block, Context &stack, Obj &obj);
 
        std::string MakeNamespace(int skip, bool is_global) {
            std::string result;
            auto iter = rbegin();
            if (skip > 0) {
                iter += skip;
            }
            int count = 0;
            while (iter != rend()) {
                if (result.find("::") == 0) {
                    break;
                }
                if (skip < 0 && count == -skip) {
                    break;
                }
                if (!iter->ns.empty() && (!is_global || !isdigit(iter->ns[0]))) {
                    // The namespace is always padded with ::
                    result.insert(0, iter->ns);
                }
                iter++;
                count++;
            }
            return result;
        }
 
        static RunTime * GetRT_(Context * runner) {
            return runner ? runner->m_runtime : nullptr;
        }
 
        ObjPtr CreateNative_(TermPtr &proto, const char *module, bool lazzy, const char *mangle_name);
        static ObjPtr CallNative_(Context *runner, Obj & obj, Obj *args = nullptr);
 
 
        static ObjPtr CreateArgs_(TermPtr &term, Context * runner);
        static ObjPtr CreateDict(TermPtr &term, Context * runner);
        static ObjPtr CreateRange(TermPtr &term, Context * runner);
        static ObjPtr CreateTensor(TermPtr &term, Context * runner);
 
        static ObjPtr SetIndexValue(TermPtr &term, ObjPtr value, Context * runner);
        static ObjPtr SetFieldValue(TermPtr &term, ObjPtr value, Context * runner);
        static ObjPtr GetIndexValue(TermPtr &term, ObjPtr &value, Context * runner);
        static ObjPtr GetFieldValue(TermPtr &term, ObjPtr &value, Context * runner);
 
 
        /* 
         * a, b, c :=  value
         * a() :=  {  }     func
         * 
         * a, b, c :=  ... dict     
         * a, b :=  b, a    swap
         * 
         * a() :=  {  }     func
         * && a() :=  {  }  async func     val :=  *a();  **( val := *a()){   },[...] {  };   -> val :=  await  a() ??????????????????????
         * a() :=  %() {  } coro  co_yeld, co_return,  co_wait  ????????????????
         */
        LatterType EvalCreate_(TermPtr & op);
 
        LatterType EvalCreateAsValue_(TermPtr & op);
        LatterType EvalCreateAsFunc_(TermPtr & op);
        LatterType EvalCreateAsEllipsis_(TermPtr & op);
        LatterType EvalCreateAsFilling_(TermPtr & op);
 
        void EvalLeftVars_(VariablePairList &vars, const TermPtrConst &op);
        //        ObjPtr AssignVars_(ArrayTermType &vars, const TermPtr &r_term, bool is_pure);
 
 
 
        ObjPtr EvalIterator_(TermPtr & term);
        ObjPtr EvalInterrupt_(TermPtr & term);
 
        ObjPtr EvalOp_(TermPtr & op);
 
        static ObjPtr EvalOpMath_(TermPtr &op, Context * runner);
        static ObjPtr EvalOpLogical_(TermPtr &op, Context * runner);
        static ObjPtr EvalOpCompare_(TermPtr &op, Context * runner);
        static ObjPtr EvalOpBitwise_(TermPtr &op, Context * runner);
        static ObjPtr EvalRange_(TermPtr &op, Context * runner);
 
        ObjPtr EvalTake_(TermPtr & op);
        LatterType EvalWhile_(TermPtr & op);
        LatterType EvalDoWhile_(TermPtr & op);
 
        static ObjPtr EvalFollow_(TermPtr & op, Context * runner);
 
 
        LatterType EvalTryBlock_(TermPtr &block);
        ObjPtr EvalEval_(TermPtr & op);
 
    };
 
    class CtxPush {
    public:
        Context &m_ctx;
 
        CtxPush(Context &ctx, const TermID id, const TermPtr & ns) : m_ctx(ctx) {
            m_ctx.PushScope(id, ns ? ns->m_text : "");
        }
 
        ~CtxPush() {
            m_ctx.PopScope();
        }
    };
 
}
#endif //INCLUDED_NEWLANG_CONTEXT_