cleanup and light refactor (with some renames)

build_c.sh

@@ -1,12 +0,0 @@
-python3 preprocess.py
-
-echo "compiling c++ lib"
-clang++ -c -o pocketpy_c.o c_bindings/pocketpy_c.cpp -Wfatal-errors --std=c++17 -O2 -Wall -Wno-sign-compare -Wno-unused-variable -fno-rtti -stdlib=libc++ -I src/ -fsanitize=address -g
-echo "compiling c executable" 
-clang -c -o main.o c_bindings/main.c -Wfatal-errors -O2 -Wall -Wno-sign-compare -Wno-unused-variable -I src/ -fsanitize=address -g
-echo "linking"
-clang++ -o pocketpy_c main.o pocketpy_c.o -stdlib=libc++ -fsanitize=address -g
-echo "cleaning up"
-rm pocketpy_c.o
-rm main.o
-

c_bindings/pocketpy_c.cpp

@@ -78,13 +78,13 @@ bool pkpy_clear_error(pkpy_vm vm_handle, char** message) {
     SAFEGUARD_CLOSE
 }
 
-pkpy_vm pkpy_new_vm(bool use_stdio, bool enable_os) {
+pkpy_vm pkpy_vm_create(bool use_stdio, bool enable_os) {
     VM* vm = new VM(use_stdio, enable_os);
 
     return (pkpy_vm) vm;
 }
 
-bool pkpy_vm_exec(pkpy_vm vm_handle, const char* source) {
+bool pkpy_vm_run(pkpy_vm vm_handle, const char* source) {
     VM* vm = (VM*) vm_handle;
     ERRHANDLER_OPEN
 
@@ -96,27 +96,11 @@ bool pkpy_vm_exec(pkpy_vm vm_handle, const char* source) {
     ERRHANDLER_CLOSE
 }
 
-void pkpy_delete_vm(pkpy_vm vm_handle) {
+void pkpy_vm_destroy(pkpy_vm vm_handle) {
     VM* vm = (VM*) vm_handle;
     delete vm;
 }
 
-pkpy_repl pkpy_new_repl(pkpy_vm vm_handle) {
-    VM* vm = (VM*) vm_handle;
-    REPL* repl = new REPL(vm);
-    return (pkpy_repl) repl;
-}
-
-bool pkpy_repl_input(pkpy_repl repl_handle, const char* line) {
-    REPL* repl = (REPL*) repl_handle;
-    return repl->input(line);
-}
-
-void pkpy_delete_repl(pkpy_repl repl_handle) {
-    REPL* repl = (REPL*) repl_handle;
-    delete repl;
-}
-
 static void propagate_if_errored(VM* vm) {
     try {
         if (vm->c_data.top() != nullptr) 

c_bindings/pocketpy_c.h

@@ -23,17 +23,9 @@ typedef struct pkpy_repl_hande* pkpy_repl;
 //or else pass in null as message, and it will just print the message to stderr
 bool pkpy_clear_error(pkpy_vm, char** message);
 
-
+pkpy_vm pkpy_vm_create(bool use_stdio, bool enable_os);
-pkpy_vm pkpy_new_vm(bool use_stdio, bool enable_os);
+bool pkpy_vm_run(pkpy_vm, const char* source);
-bool pkpy_vm_exec(pkpy_vm, const char* source);
+void pkpy_vm_destroy(pkpy_vm);
-void pkpy_delete_vm(pkpy_vm);
-
-pkpy_repl pkpy_new_repl(pkpy_vm);
-//the repl does its own error management, so this method doesn't follow the ame
-//error semantics, it is just a thin wrapper around the REPL classes input method
-bool pkpy_repl_input(pkpy_repl, const char* line);
-void pkpy_delete_repl(pkpy_repl);
-
 
 typedef int (*pkpy_function)(pkpy_vm); 
 

c_bindings/test.c

@@ -78,16 +78,16 @@ int test_error_propagate(pkpy_vm vm) {
 pkpy_vm vm;
 
 void cleanup(void) {
-    pkpy_delete_vm(vm);
+    pkpy_vm_destroy(vm);
 }
 
 int main(int argc, char** argv) {
 
-    vm = pkpy_new_vm(true, true);
+    vm = pkpy_vm_create(true, true);
     atexit(cleanup);
 
-    //test exec
+    //test run
-    check(pkpy_vm_exec(vm, "print('hello world!')"));
+    check(pkpy_vm_run(vm, "print('hello world!')"));
 
     error(pkpy_get_global(vm, "nonexistatn"));
 
@@ -95,7 +95,7 @@ int main(int argc, char** argv) {
     int r_int;
     check(pkpy_push_int(vm, 11));
     check(pkpy_set_global(vm, "eleven"));
-    check(pkpy_vm_exec(vm, "print(eleven)"));
+    check(pkpy_vm_run(vm, "print(eleven)"));
     check(pkpy_get_global(vm, "eleven"));
     check(pkpy_is_int(vm, -1));
     check(pkpy_to_int(vm, -1, &r_int));
@@ -109,7 +109,7 @@ int main(int argc, char** argv) {
     double r_float;
     check(pkpy_push_float(vm, 11.11));
     check(pkpy_set_global(vm, "elevenf"));
-    check(pkpy_vm_exec(vm, "print(elevenf)"));
+    check(pkpy_vm_run(vm, "print(elevenf)"));
     check(pkpy_get_global(vm, "elevenf"));
     check(pkpy_is_float(vm, -1));
     check(pkpy_to_float(vm, -1, &r_float));
@@ -123,7 +123,7 @@ int main(int argc, char** argv) {
     bool r_bool;
     check(pkpy_push_bool(vm, false));
     check(pkpy_set_global(vm, "false_test"));
-    check(pkpy_vm_exec(vm, "print(false_test)"));
+    check(pkpy_vm_run(vm, "print(false_test)"));
     check(pkpy_get_global(vm, "false_test"));
     check(pkpy_is_bool(vm, -1));
     check(pkpy_to_bool(vm, -1, &r_bool));
@@ -137,7 +137,7 @@ int main(int argc, char** argv) {
     char* r_string;
     check(pkpy_push_string(vm, "hello!"));
     check(pkpy_set_global(vm, "hello1"));
-    check(pkpy_vm_exec(vm, "print(hello1)"));
+    check(pkpy_vm_run(vm, "print(hello1)"));
     check(pkpy_push_stringn(vm, "hello!", 5));
     check(pkpy_is_string(vm, -1));
     check(pkpy_to_string(vm, -1, &r_string));
@@ -151,7 +151,7 @@ int main(int argc, char** argv) {
     printf("\ntesting None methods\n");
     check(pkpy_push_none(vm));
     check(pkpy_set_global(vm, "none"));
-    check(pkpy_vm_exec(vm, "print(none)"));
+    check(pkpy_vm_run(vm, "print(none)"));
     check(pkpy_get_global(vm, "none"));
     check(pkpy_is_none(vm, -1));
     fail(pkpy_is_int(vm, -1));
@@ -177,15 +177,15 @@ int main(int argc, char** argv) {
     check(pkpy_is_none(vm, -1));
     
     printf("\ntesting error catching\n");
-    error(pkpy_vm_exec(vm, "let's make sure syntax errors get caught"));
+    error(pkpy_vm_run(vm, "let's make sure syntax errors get caught"));
     check(pkpy_stack_size(vm) == 0); //stack should be cleared after error is resolved
 
     printf("\ntesting calls\n");
 
-    check(pkpy_vm_exec(vm, "def x(x, y) : return x - y"));
+    check(pkpy_vm_run(vm, "def x(x, y) : return x - y"));
-    check(pkpy_vm_exec(vm, "def vararg_x(*x) : return sum(x)"));
+    check(pkpy_vm_run(vm, "def vararg_x(*x) : return sum(x)"));
-    check(pkpy_vm_exec(vm, "def keyword_x(x=1, y=1) : return x+y"));
+    check(pkpy_vm_run(vm, "def keyword_x(x=1, y=1) : return x+y"));
-    check(pkpy_vm_exec(vm, "def retmany_x() : return 1, 2, 3"));
+    check(pkpy_vm_run(vm, "def retmany_x() : return 1, 2, 3"));
 
     check(pkpy_get_global(vm, "x"));
     check(pkpy_push_int(vm, 2));
@@ -231,28 +231,28 @@ int main(int argc, char** argv) {
     check(pkpy_get_global(vm, "x"));
     error(pkpy_call(vm, 0));
 
-    check(pkpy_vm_exec(vm, "l = []"));
+    check(pkpy_vm_run(vm, "l = []"));
 
     check(pkpy_get_global(vm, "l"));
     check(pkpy_push_string(vm, "hello"));
     check(pkpy_call_method(vm, "append", 1));
-    check(pkpy_vm_exec(vm, "print(l)"));
+    check(pkpy_vm_run(vm, "print(l)"));
 
 
     printf("\ntesting pushing functions\n");
 
     check(pkpy_push_function(vm, test_binding));
     check(pkpy_set_global(vm, "test_binding"));
-    check(pkpy_vm_exec(vm, "print(test_binding())"));
+    check(pkpy_vm_run(vm, "print(test_binding())"));
 
     check(pkpy_push_function(vm, test_multiple_return));
     check(pkpy_set_global(vm, "test_multiple_return"));
-    check(pkpy_vm_exec(vm, "test_multiple_return()"));
+    check(pkpy_vm_run(vm, "test_multiple_return()"));
     check(pkpy_stack_size(vm) == 2);
 
     check(pkpy_push_function(vm, test_error_propagate));
     check(pkpy_set_global(vm, "test_error_propagate"));
-    error(pkpy_vm_exec(vm, "test_error_propagate()"));
+    error(pkpy_vm_run(vm, "test_error_propagate()"));
 
     check(pkpy_get_global(vm, "test_multiple_return"));
     check(pkpy_call(vm, 0));

run_c_binding_test.sh

@@ -15,7 +15,7 @@ clang++ -o c_binding_test test.o pocketpy_c.o -stdlib=libc++ -fsanitize=address
 echo "running, no weird output should show up"
 ./c_binding_test > binding_test_scratch
 echo "checking results (they should be identical)"
-diff -s binding_test_scratch c_bindings/test_answers.txt
+diff -q -s  binding_test_scratch c_bindings/test_answers.txt
 
 echo "cleaning up"
 rm pocketpy_c.o

src/error.h

@@ -102,3 +102,4 @@ public:
 };
 
 }   // namespace pkpy
+

src/frame.h

@@ -219,3 +219,4 @@ struct Frame {
 };
 
 }; // namespace pkpy
+

src/main.cpp

@@ -6,21 +6,21 @@
 #ifndef __EMSCRIPTEN__
 
 int main(int argc, char** argv){
-    pkpy::VM* vm = new pkpy::VM();
+    pkpy::VM* vm = pkpy_new_vm();
     vm->bind_builtin_func<0>("input", [](pkpy::VM* vm, pkpy::ArgsView args){
         return VAR(pkpy::getline());
     });
     if(argc == 1){
-        pkpy::REPL* repl = new pkpy::REPL(vm);
+        pkpy::REPL* repl = pkpy_new_repl(vm);
         bool need_more_lines = false;
         while(true){
             (*vm->_stdout) << (need_more_lines ? "... " : ">>> ");
             bool eof = false;
             std::string line = pkpy::getline(&eof);
             if(eof) break;
-            need_more_lines = repl->input(line.c_str());
+            need_more_lines = pkpy_repl_input(repl, line.c_str());
         }
-        delete vm;
+        pkpy_delete(vm);
         return 0;
     }
     
@@ -47,7 +47,7 @@ int main(int argc, char** argv){
 
         pkpy::PyObject* ret = nullptr;
         ret = vm->exec(src.c_str(), argv_1, pkpy::EXEC_MODE);
-        delete vm;
+        pkpy_delete(vm);
         return ret != nullptr ? 0 : 1;
     }
 
@@ -57,3 +57,4 @@ __HELP:
 }
 
 #endif
+

src/pocketpy.h

@@ -977,7 +977,6 @@ inline void VM::post_init(){
 }   // namespace pkpy
 
 /*************************GLOBAL NAMESPACE*************************/
-/*
 static std::map<void*, void(*)(void*)> _pk_deleter_map;
 
 extern "C" {
@@ -1050,4 +1049,5 @@ extern "C" {
         return strdup(json.c_str());
     }
 
-}*/
+}
+

src/str.h

@@ -435,3 +435,4 @@ const StrName __or__ = StrName::get("__or__");
 const StrName __xor__ = StrName::get("__xor__");
 
 } // namespace pkpy
+

src/vm.h

@@ -1205,3 +1205,4 @@ inline Str obj_type_name(VM *vm, Type type){
 #undef PY_VAR_FLOAT
 
 }   // namespace pkpy
+