runtime.h

Go to the documentation of this file.

#pragma once
#ifndef INCLUDED_RUNTIME_CPP_
#define INCLUDED_RUNTIME_CPP_
 
#include <sys/time.h>
#include <ffi.h>
#include <dlfcn.h>
#include <cstring>
 
#include "nlc-rt.h"
 
#include "term.h"
#include "diag.h"
#include "module.h"
#include "context.h"
 
 
using namespace newlang;
 
ObjPtr CreateTensor(torch::Tensor tensor);
void ConvertStringToTensor(const std::string &from, torch::Tensor &to, ObjType type);
 
namespace newlang {
 
#ifdef __GNUC__
    extern "C" int nlc_prinft_sub_(char const *format, ...) __attribute__ ((format(printf, 1, 2)));
#else
    EXTERN_C int nlc_prinft_sub_(char const *format, ...);
#endif    
 
    int RunMain(const int arg, const char** argv, const char** penv);
 
    std::string GetFileExt(const char * str);
    std::string AddDefaultFileExt(const char * str, const char *ext_default);
    std::string ReplaceFileExt(const char * str, const char *ext_old, const char *ext_new);
    std::string ReadFile(const char *fileName);
 
    std::string GetDoc(std::string name);
 
    std::string MakeConstructorName(std::string name);
 
    std::string MakeLocalName(std::string name);
 
    /*
     * Последовательность работы к кодом:
     * 1. Лексер (последовательность токенов) - использовать только для отладки макросов
     * 2. Парсер - AST раскрытие макросов и чтение файлов модулей (или их загрузка с созданим иерархии имен объектов). 
     * 
     * 3. Выполнение интерпретатора - пошаговое выполнение AST (реальное создание объектов и выполнение операторов)
     * 
     * 4. Генерация кода - обход AST для генерации промежуточного код на языке LLVM-IR
     * 5. Оптимиация кода для NewLang (согласно типам данных и взаимодействия в нативными функциями)
     * 6. Оптимиация кода для LLVM-IR
     * 7. Сохрнение промежуточного кода в файл модуля.
     * 8. Компиляция промежуточного кода в машинный код (или выполнение в режиме интерпретатора)
     * 
     * 
     * В Runtime хранятся глобальные объекты, память под которые выделяется во время компиляции программы
     * В Context хрантся локальны объекты, память под которые выделяется только во ремя выполнения
     * Объект Context создается для основонго потока, а так же по одному объекту для каждого потока программы.
     * 
     * 
     https://ps-group.github.io/compilers/llvm_ir_translator
     * В интерпретаторе был использован паттерн “Интерпретатор”, 
     * т.е. каждый узел AST имел метод, который принимал контекст выполнения и выполнял рекурсивное 
     * вычисление узла с учётом текущего контекста выполнения:
     * 
     * // Вычисление выражения возвращает результат в виде CValue
     * class IExpressionAst
     * {
     * public:
     *     virtual ~IExpressionAst() = default;
     *     virtual CValue Evaluate(CInterpreterContext& context) const = 0;
     * };
     * 
     * // Выполнение инструкции результата не возвращает
     * class IStatementAst
     * {
     * public:
     *     virtual ~IStatementAst() = default;
     *     virtual void Execute(CInterpreterContext& context) const = 0;
     * };
     * 
     * // Вычисление функции требует список аргументов и возвращает результат в виде CValue
     * class IFunctionAst
     * {
     * public:
     *     virtual ~IFunctionAst() = default;
     *     virtual CValue Call(CInterpreterContext& context, std::vector<CValue> const& arguments) const = 0;
     *     virtual unsigned GetNameId() const = 0;
     * };
     * 
     * Такой паттерн подходит для интерпретатора, где входные данные поступают вместе с исходным кодом программы 
     * и могут быть сразу использованы для вычисления. 
     * 
     * Процессы внутри компилятора выглядят сложнее:
     * -    сначала должна произойти проверка типов и других семантических правил путём обхода AST
     * -    затем путём ещё одного обхода AST нужно сгенерировать промежуточный код на языке LLVM-IR
     * -    уже после генерации промежуточного кода он может быть превращён в машинный 
     * (это тема следующих статей) и использован для обработки входных данных
     * 
     * Для множественной обработки AST лучше подходит паттерн “Посетитель”, который позволяет абстрагироваться от узлов AST. 
     * Для реализации паттерна достаточно создать у каждого узла дерева метод, например void Accept(IVisitor&), 
     * который будет вызывать правильную перегрузку метода IVisitor::Visit, соответствующую типу текущего узла, 
     * и рекурсивно вызывать Accept для дочерних узлов:
     * 
     * Генерация кода выражений
     * 
     * Для генерации кода выражений мы реализуем интерфейс IExpressionVisitor
     * class CExpressionCodeGenerator : protected IExpressionVisitor
     * {
     * public:
     *     CExpressionCodeGenerator(llvm::IRBuilder<>& builder, CFrontendContext& context);
     * 
     *     // Can throw std::exception.
     *     llvm::Value* Codegen(IExpressionAST& ast);
     * protected:
     *     void Visit(CBinaryExpressionAST& expr) override;
     *     void Visit(CUnaryExpressionAST& expr) override;
     *     void Visit(CLiteralAST& expr) override;
     *     void Visit(CCallAST& expr) override;
     *     void Visit(CVariableRefAST& expr) override;
     * private:
     *     // Стек используется для временного хранения
     *     // по мере рекурсивного обхода дерева выражения.
     *     std::vector<llvm::Value*> m_values;
     *     CFrontendContext& m_context;
     *     llvm::IRBuilder<>& m_builder;
     * };
     * 
     * 
     */
 
    struct FileModule {
        std::string name;
        std::string include;
        std::string source;
        std::string bytecode;
    };
 
    /*
     * 
     * 
     * 
     */
 
    struct Func {
    };
 
    /*
     * 
     * 
     * 
     */
 
#ifdef BUILD_DEBUG
    typedef std::shared_timed_mutex Lock;
#ifndef DEADLOCK_TIMEOUT
#define DEADLOCK_TIMEOUT std::chrono::seconds(5)
#endif
#else
    typedef std::shared_mutex Lock;
#ifdef DEADLOCK_TIMEOUT
#error The release build does not support DEADLOCK TIMEOUT, as it uses a lock without a time limit, which is faster!
#endif
#endif
 
    typedef std::unique_lock< Lock > WriteLock;
    typedef std::shared_lock< Lock > ReadLock;
 
 
#define SCOPE_LOCK_DEADLOCK_MESSAGE(THIS)       LOG_RUNTIME("Deadlock timeout!") 
 
#define SCOPE_LOCK_READ_NAME(THIS, VARNAME)     ReadLock VARNAME(*THIS, std::defer_lock);\
                                                if (!VARNAME.try_lock_for(DEADLOCK_TIMEOUT)) \
                                                    SCOPE_LOCK_DEADLOCK_MESSAGE(THIS)
 
#define SCOPE_LOCK_WRITE_NAME(THIS, VARNAME)    WriteLock VARNAME(*THIS, std::defer_lock);\
                                                if (!VARNAME.try_lock_for(DEADLOCK_TIMEOUT)) \
                                                    SCOPE_LOCK_DEADLOCK_MESSAGE(THIS)
 
#define SCOPE_LOCK_READ(THIS)  SCOPE_LOCK_READ_NAME(THIS, r_lock)
#define SCOPE_LOCK_WRITE(THIS) SCOPE_LOCK_WRITE_NAME(THIS, w_lock)
 
    /*
     * 
     * 
     */
    class RunTime : public GlobalObjects, public std::enable_shared_from_this<RunTime>, protected Lock {
    private:
 
        //        void ReadFunction() {
        //            ReadLock rr_lock(*this, std::defer_lock);
        //            if (!rr_lock.try_lock_for(DEADLOCK_TIMEOUT)) {
        //                LOG_RUNTIME("Deadlock timeout!");
        //            }
        //            //Do reader stuff
        //            SCOPE_LOCK_READ(this);
        //        }
        //
        //        void WriteFunction() {
        //            WriteLock ww_lock(*this, std::defer_lock);
        //            if (!ww_lock.try_lock_for(DEADLOCK_TIMEOUT)) {
        //            }
        //
        //            SCOPE_LOCK_WRITE(this);
        //        }
 
 
 
    public:
 
        //        bool MakeFullNames(TermPtr ast);
 
 
        void GlobalNameBuildinRegister();
        bool RegisterSystemFunc(const char *source);
        //        bool RegisterBuildin(BuildinPtr module);
        //        bool RegisterModule(ModulePtr module);
 
        virtual void Clear();
 
        //        bool RegisterNativeObj(TermPtr term);
 
        bool RegisterBuildinFunc(std::string proto, void * func);
        //        bool RegisterSystemBuildin(const char *text);
        //        bool RegisterSystemObj(ObjPtr obj);
        //        std::vector<ObjPtr> m_sys_obj;
 
        static ObjPtr CreateNative(const char *proto, const char *module = nullptr, bool lazzy = false, const char *mangle_name = nullptr);
        static ObjPtr CreateNative(TermPtr proto, const char *module = nullptr, bool lazzy = false, const char *mangle_name = nullptr);
        static ObjPtr CreateNative(TermPtr proto, void *addr);
        ObjPtr CreateFunction(TermPtr proto, TermPtr block);
        ObjPtr CreateFunction(TermPtr proto, void *addr);
 
 
        static std::string Escape(const std::string_view str);
        /*
         * class A {
        public:
          static std::shared_ptr<A> create();
        private:
          A() = default;
          friend struct make_shared_enabler;
        };
 
        struct make_shared_enabler : A {
          template<typename... Args>
          make_shared_enabler(Args&&... args)
            : A(std::forward<Args>(args)...) {
          }
        };
 
        static std::shared_ptr<A> A::create() {
          return std::make_shared<make_shared_enabler>();
        }
 
         */
        RunTime(const StringArray &args = {});
 
        virtual ~RunTime();
 
 
 
 
        typedef ffi_status ffi_prep_cif_type(ffi_cif *cif, ffi_abi abi, unsigned int nargs, ffi_type *rtype, ffi_type **atypes);
        typedef ffi_status ffi_prep_cif_var_type(ffi_cif *cif, ffi_abi abi, unsigned int nfixedargs, unsigned int ntotalargs, ffi_type *rtype, ffi_type **atypes);
        typedef void ffi_call_type(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue);
 
        static std::string ffi_file;
        static void * m_ffi_handle;
        static ffi_type * m_ffi_type_void;
        static ffi_type * m_ffi_type_uint8;
        static ffi_type * m_ffi_type_sint8;
        static ffi_type * m_ffi_type_uint16;
        static ffi_type * m_ffi_type_sint16;
        static ffi_type * m_ffi_type_uint32;
        static ffi_type * m_ffi_type_sint32;
        static ffi_type * m_ffi_type_uint64;
        static ffi_type * m_ffi_type_sint64;
        static ffi_type * m_ffi_type_float;
        static ffi_type * m_ffi_type_double;
        static ffi_type * m_ffi_type_pointer;
 
        static ffi_prep_cif_type *m_ffi_prep_cif;
        static ffi_prep_cif_var_type * m_ffi_prep_cif_var;
        static ffi_call_type * m_ffi_call;
 
        static ObjType m_wide_char_type;
        static ffi_type * m_wide_char_type_ffi;
        static ObjType m_integer_type;
 
        void InitInternal(const StringArray args);
        static RuntimePtr Init(StringArray args);
        static RuntimePtr Init(int argc = 0, const char** argv = nullptr, const char** penv = nullptr);
        //        static RuntimePtr Init(std::vector<const char *> args, bool ignore_error = true);
 
        static std::string NativeNameMangling(const Term *term, RunTime *rt);
        static std::string NativeNameMangling(std::string_view name);
 
        //        static void * GetDirectAddressFromLibrary(void *handle, std::string_view name);
 
 
        //        ModulePtr CheckLoadModule(TermPtr &term);
        bool LoadModuleFromFile(const char *name_str, bool init);
 
        ObjPtr OpLoadModule(TermPtr term);
        ObjPtr ObjFromModule(ModulePtr module, TermPtr term);
 
        bool UnLoadModule(const char *name_str, bool deinit);
        ObjPtr ExecModule(const char *module, const char *output, bool cached, Context * ctx);
 
        //        bool CreateModule(const TermPtr &ast, const std::string_view source, const std::string_view module_name, const std::string_view filename, llvm::Module *bc = nullptr);
 
        static bool ModuleSave(const FileModule &data, const std::string_view filename, const std::string_view module_name = "");
        static bool ModuleRead(FileModule &data, const std::string_view filename, const std::string_view modulename = "");
 
 
        //        static void * GetNativeAddr(const char * name, void *module = nullptr);
 
        static std::string GetLastErrorMessage();
 
        //        static ModulePtr CreateNameHierarchy(Term ast, RuntimePtr rt);
 
        bool RegisterBuildinType(ObjType type, std::vector<std::string> parents);
 
        static ObjType BaseTypeFromString(RunTime * rt, const std::string_view text, bool *has_error = nullptr);
        ObjPtr GetTypeFromString(const std::string_view type, bool *has_error = nullptr);
 
        static bool pred_compare(const std::string &find, const std::string &str) {
            size_t pos = 0;
            while (pos < find.size() && pos < str.size()) {
                if (find[pos] != str[pos]) {
 
                    return false;
                }
                pos++;
            }
            return find.empty() || (pos && find.size() == pos);
        }
 
        std::vector<std::wstring> SelectPredict(std::wstring wstart, size_t overage_count = 0) {
 
            return SelectPredict(utf8_encode(wstart), overage_count);
        }
        std::vector<std::wstring> SelectPredict(std::string start, size_t overage_count = 0);
 
        //        ObjPtr Eval(const TermPtr &term, Runner *runner = nullptr);
 
        void CreateArgs_(ObjPtr &args, const TermPtr &term, Context *runner = nullptr);
        ObjPtr CreateDict(const TermPtr &term, Context *runner = nullptr);
        ObjPtr CreateTensor(const TermPtr &term, Context *runner = nullptr);
 
 
 
 
        //        LLVMBuilderRef m_llvm_builder;
 
        //        ModulePtr m_buildin_obj;
        //        ModulePtr m_main_module;
 
        TermPtr m_main;
        StringArray m_module_loader;
 
//        std::map<std::string, VariablePairPtr> m_buildin_pair;
 
        std::string m_work_dir;
        std::string m_exec_dir;
        std::string m_cache_dir;
        std::string m_temp_dir;
        std::string m_user_dir;
        std::vector<std::string> m_search_dir;
        bool m_assert_enable;
        bool m_load_dsl;
        bool m_embed_source;
        bool m_import_module;
        bool m_import_native;
        bool m_eval_enable;
        bool m_load_runtime;
        bool m_link_rt;
        bool m_link_jit;
        int m_typedef_limit;
        //        ObjPtr m_cmd_args;
        //        ObjPtr m_main_args;
        //        MacroPtr m_macro;
    public:
        DiagPtr m_diag;
 
        TermPtr m_main_ast;
        //        RunnerPtr m_main_runner;
 
        static bool ExpandFileName(std::string &filename);
 
        int RunMain();
        bool CompileCppSource(const std::string_view source, std::string &out, std::vector<std::string> opts = {});
 
 
        TermPtr ParseBuildin(const std::string_view src);
        //        ParserPtr GetParser();
 
        static void * GetNativeAddress(void * handle, const std::string_view name);
 
        static StringArray MakeMainArgs(int argc, const char** argv, const char** penv) {
            StringArray result;
            for (int i = 0; i < argc; i++) {
                result.push_back(std::string(argv[i]));
            }
            return result;
        }
 
        static ObjPtr MakeObjArgs(int argc, const char** argv) {
            ObjPtr result = Obj::CreateDict();
            for (int i = 0; i < argc; i++) {
                result->push_back(Obj::CreateString(argv[i]));
            }
            return result;
        }
 
        static std::vector<std::string> SplitChar(std::string_view str, const std::string_view delimiter) {
            std::vector<std::string> result;
            while (!str.empty()) {
                size_t pos = str.find_first_of(delimiter.begin());
                if (pos == 0) {
                    pos = str.find_first_not_of(delimiter.begin());
                    if (pos == std::string::npos) {
                        break;
                    }
                    str.remove_prefix(pos);
                } else {
                    if (pos == std::string::npos) {
                        result.push_back(std::string(str.begin(), str.end()));
                        break;
                    }
                    result.push_back(std::string(str.begin(), str.begin() + pos));
                    str.remove_prefix(pos);
                }
            }
            return result;
        }
 
        static std::vector<std::string> SplitString(const std::string_view str, const std::string_view delim) {
 
            std::vector<std::string> result;
            std::string s(str);
 
            size_t pos;
            s.erase(0, s.find_first_not_of(delim.begin()));
            while (!s.empty()) {
                pos = s.find(delim.begin());
                if (pos == std::string::npos) {
                    result.push_back(s);
                    break;
                } else {
                    result.push_back(s.substr(0, pos));
                    s.erase(0, pos);
                }
                s.erase(0, s.find_first_not_of(delim.begin()));
            }
            return result;
        }
 
    protected:
 
        bool ParseArgs(StringArray args) {
 
            std::vector<std::string> load;
 
            for (int i = 0; i < args.size(); i++) {
 
                //                m_cmd_args->push_back(Obj::CreateString(args[i]));
 
                if (args[i].find("--nlc-search=") == 0) {
                    std::string list;
                    list = args[i].substr(strlen("--nlc-search="));
                    m_search_dir = SplitString(list.c_str(), ";");
                } else if (args[i].find("--nlc-cache-dir=") == 0) {
                    m_cache_dir = args[i].substr(strlen("--nlc-cache-dir="));
                } else if (args[i].find("--nlc-temp-dir=") == 0) {
                    m_temp_dir = args[i].substr(strlen("--nlc-temp-dir="));
                } else if (args[i].find("--nlc-user-dir=") == 0) {
                    m_user_dir = args[i].substr(strlen("--nlc-user-dir="));
                } else if (args[i].compare("--nlc-no-link-rt") == 0) {
                    m_link_rt = false;
                    m_link_jit = false;
                } else if (args[i].compare("--nlc-no-link-jit") == 0) {
                    m_link_jit = false;
                } else if (args[i].compare("--nlc-no-runtime") == 0) {
                    m_load_runtime = false;
                } else if (args[i].compare("--nlc-no-dsl") == 0) {
                    m_load_dsl = false;
                    //                } else if (args[i].compare("--nlc-main-arg=") == 0 || strcmp(arg_test, "--nlc-main-args=") == 0) {
                    //
                    //                    std::string temp(arg_test);
                    //                    std::string call("(");
                    //
                    //                    call += temp.substr(temp.find("=") + 1);
                    //                    call += ",)";
                    //                    m_main_args = EvalStatic(MakeAst(call, true), false);
 
                } else if (args[i].compare("--nlc-embed-source") == 0) {
                    LOG_RUNTIME("Flag '--nlc-embed-source' not implemented!");
                    m_embed_source = true;
                } else if (args[i].compare("--nlc-no-embed-source") == 0) {
                    m_embed_source = false;
                } else if (args[i].compare("--nlc-no-import-module") == 0) {
                    m_import_module = false;
                } else if (args[i].compare("--nlc-no-import-native") == 0) {
                    m_import_native = false;
                } else if (args[i].compare("--nlc-no-eval-enable") == 0) {
                    m_eval_enable = false;
                } else if (args[i].compare("--nlc-no-assert") == 0) {
                    m_assert_enable = false;
                } else if (args[i].find("--nlc-error-limit=") == 0) {
                    std::string value(args[i]);
                    m_diag->m_error_limit = parseInteger(value.substr(strlen("--nlc-error-limit=")).c_str());
                    //                } else if (args[i].compare("--nlc-load=") == arg_test) {
                    //                    load.push_back(std::string(arg_test).substr(strlen("--nlc-load=")));
                } else {
                    LOG_RUNTIME("System argument '%s' not recognized!", args[i].c_str());
                }
            }
 
 
            //            llvm::SmallString<1024> path;
            //            auto error = llvm::sys::fs::current_path(path);
            //            if (error) {
            //                LOG_RUNTIME("%s", error.message().c_str());
            //            }
            //            m_work_dir = path.c_str();
            //            // LOG_DEBUG("work_dir: %s", m_work_dir.c_str());
            //
            //            path = llvm::sys::fs::getMainExecutable(nullptr, nullptr);
            //            // LOG_DEBUG("%s", path.c_str());
            //
            //            llvm::sys::path::remove_filename(path);
            //            m_exec_dir = path.c_str();
            //            // LOG_DEBUG("exec_dir: %s", m_exec_dir.c_str());
 
            m_search_dir.push_back(m_work_dir);
            m_search_dir.push_back(m_exec_dir);
 
            for (auto &elem : load) {
 
            }
 
            return true;
        }
 
        //SCOPE(private) :
    public:
        RunTime(const RunTime&) = delete;
        const RunTime& operator=(const RunTime&) = delete;
 
    };
 
    /*
     * 
     * 
     *      
     */
    ObjType typeFromString(TermPtr &term, RunTime *rt, bool *has_error);
}
 
 
#endif //INCLUDED_RUNTIME_CPP_