From 4eff4ea07618de1a28c61b0136f64584f8a95887 Mon Sep 17 00:00:00 2001 From: blueloveTH Date: Mon, 27 Feb 2023 17:16:23 +0800 Subject: [PATCH] up --- src/main.cpp | 12 +++++------ src/pocketpy.h | 58 ++++++++++++++++++++++++++------------------------ 2 files changed, 35 insertions(+), 35 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index b85f1c92..5d143a69 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,19 +1,17 @@ #include #include "pocketpy.h" -using namespace pkpy; - #ifndef __EMSCRIPTEN__ int main(int argc, char** argv){ - VM* vm = pkpy_new_vm(true); - vm->bind_builtin_func<0>("input", [](VM* vm, Args& args){ + pkpy::VM* vm = pkpy_new_vm(true); + vm->bind_builtin_func<0>("input", [](pkpy::VM* vm, pkpy::Args& args){ static std::string line; std::getline(std::cin, line); return vm->PyStr(line); }); if(argc == 1){ - REPL* repl = pkpy_new_repl(vm); + pkpy::REPL* repl = pkpy_new_repl(vm); bool need_more_lines = false; while(true){ (*vm->_stdout) << (need_more_lines ? "... " : ">>> "); @@ -35,8 +33,8 @@ int main(int argc, char** argv){ return 1; } std::string src((std::istreambuf_iterator(file)), std::istreambuf_iterator()); - PyVarOrNull ret = nullptr; - ret = vm->exec(src.c_str(), filename, EXEC_MODE); + pkpy::PyVarOrNull ret = nullptr; + ret = vm->exec(src.c_str(), filename, pkpy::EXEC_MODE); pkpy_delete(vm); return ret != nullptr ? 0 : 1; } diff --git a/src/pocketpy.h b/src/pocketpy.h index d9431056..b5e58afd 100644 --- a/src/pocketpy.h +++ b/src/pocketpy.h @@ -807,6 +807,10 @@ void VM::post_init(){ this->_exec(code, this->builtins); } +} // namespace pkpy + +/*************************GLOBAL NAMESPACE*************************/ + class PkExportedBase{ public: virtual ~PkExportedBase() = default; @@ -852,8 +856,8 @@ extern "C" { __EXPORT /// Run a given source on a virtual machine. - void pkpy_vm_exec(VM* vm, const char* source){ - vm->exec(source, "main.py", EXEC_MODE); + void pkpy_vm_exec(pkpy::VM* vm, const char* source){ + vm->exec(source, "main.py", pkpy::EXEC_MODE); } __EXPORT @@ -861,11 +865,11 @@ extern "C" { /// /// Return `__repr__` of the result. /// If the variable is not found, return `nullptr`. - char* pkpy_vm_get_global(VM* vm, const char* name){ - PyVar* val = vm->_main->attr().try_get(name); + char* pkpy_vm_get_global(pkpy::VM* vm, const char* name){ + pkpy::PyVar* val = vm->_main->attr().try_get(name); if(val == nullptr) return nullptr; try{ - Str _repr = vm->PyStr_AS_C(vm->asRepr(*val)); + pkpy::Str _repr = vm->PyStr_AS_C(vm->asRepr(*val)); return strdup(_repr.c_str()); }catch(...){ return nullptr; @@ -877,11 +881,11 @@ extern "C" { /// /// Return `__repr__` of the result. /// If there is any error, return `nullptr`. - char* pkpy_vm_eval(VM* vm, const char* source){ - PyVarOrNull ret = vm->exec(source, "", EVAL_MODE); + char* pkpy_vm_eval(pkpy::VM* vm, const char* source){ + pkpy::PyVarOrNull ret = vm->exec(source, "", pkpy::EVAL_MODE); if(ret == nullptr) return nullptr; try{ - Str _repr = vm->PyStr_AS_C(vm->asRepr(ret)); + pkpy::Str _repr = vm->PyStr_AS_C(vm->asRepr(ret)); return strdup(_repr.c_str()); }catch(...){ return nullptr; @@ -890,26 +894,26 @@ extern "C" { __EXPORT /// Create a REPL, using the given virtual machine as the backend. - REPL* pkpy_new_repl(VM* vm){ - return PKPY_ALLOCATE(REPL, vm); + pkpy::REPL* pkpy_new_repl(pkpy::VM* vm){ + return PKPY_ALLOCATE(pkpy::REPL, vm); } __EXPORT /// Input a source line to an interactive console. Return true if need more lines. - bool pkpy_repl_input(REPL* r, const char* line){ + bool pkpy_repl_input(pkpy::REPL* r, const char* line){ return r->input(line); } __EXPORT /// Add a source module into a virtual machine. - void pkpy_vm_add_module(VM* vm, const char* name, const char* source){ + void pkpy_vm_add_module(pkpy::VM* vm, const char* name, const char* source){ vm->_lazy_modules[name] = source; } __EXPORT /// Create a virtual machine. - VM* pkpy_new_vm(bool use_stdio){ - return PKPY_ALLOCATE(VM, use_stdio); + pkpy::VM* pkpy_new_vm(bool use_stdio){ + return PKPY_ALLOCATE(pkpy::VM, use_stdio); } __EXPORT @@ -918,13 +922,13 @@ extern "C" { /// After this operation, both stream will be cleared. /// /// Return a json representing the result. - char* pkpy_vm_read_output(VM* vm){ + char* pkpy_vm_read_output(pkpy::VM* vm){ if(vm->use_stdio) return nullptr; - StrStream* s_out = (StrStream*)(vm->_stdout); - StrStream* s_err = (StrStream*)(vm->_stderr); - Str _stdout = s_out->str(); - Str _stderr = s_err->str(); - StrStream ss; + pkpy::StrStream* s_out = (pkpy::StrStream*)(vm->_stdout); + pkpy::StrStream* s_err = (pkpy::StrStream*)(vm->_stderr); + pkpy::Str _stdout = s_out->str(); + pkpy::Str _stderr = s_err->str(); + pkpy::StrStream ss; ss << '{' << "\"stdout\": " << _stdout.escape(false); ss << ", " << "\"stderr\": " << _stderr.escape(false) << '}'; s_out->str(""); s_err->str(""); @@ -955,19 +959,19 @@ extern "C" { __EXPORT /// Bind a function to a virtual machine. - char* pkpy_vm_bind(VM* vm, const char* mod, const char* name, int ret_code){ + char* pkpy_vm_bind(pkpy::VM* vm, const char* mod, const char* name, int ret_code){ if(!f_int || !f_float || !f_bool || !f_str || !f_None) return nullptr; static int kGlobalBindId = 0; for(int i=0; mod[i]; i++) if(mod[i] == ' ') return nullptr; for(int i=0; name[i]; i++) if(name[i] == ' ') return nullptr; std::string f_header = std::string(mod) + '.' + name + '#' + std::to_string(kGlobalBindId++); - PyVar obj = vm->_modules.contains(mod) ? vm->_modules[mod] : vm->new_module(mod); - vm->bind_func<-1>(obj, name, [ret_code, f_header](VM* vm, const Args& args){ - StrStream ss; + pkpy::PyVar obj = vm->_modules.contains(mod) ? vm->_modules[mod] : vm->new_module(mod); + vm->bind_func<-1>(obj, name, [ret_code, f_header](pkpy::VM* vm, const pkpy::Args& args){ + pkpy::StrStream ss; ss << f_header; for(int i=0; icall(args[i], __json__); + pkpy::PyVar x = vm->call(args[i], pkpy::__json__); ss << vm->PyStr_AS_C(x); } char* packet = strdup(ss.str().c_str()); @@ -988,6 +992,4 @@ extern "C" { }); return strdup(f_header.c_str()); } -} - -} // namespace pkpy \ No newline at end of file +} \ No newline at end of file