From 669bf8b9b1336b0e8a87cfe5f857c6d88c980922 Mon Sep 17 00:00:00 2001 From: Kolten Pearson Date: Mon, 1 May 2023 20:35:38 -0600 Subject: [PATCH] adjusted things so that we minimize the number of changes necessary to the main pocketpy library --- c_bindings/pocketpy_c.cpp | 302 ++++++++++++++++++-------------------- c_bindings/pocketpy_c.h | 60 ++++---- c_bindings/test.c | 23 +-- run_c_binding_test.sh | 2 +- src/frame.h | 3 +- src/obj.h | 4 +- src/vm.h | 3 +- 7 files changed, 190 insertions(+), 207 deletions(-) diff --git a/c_bindings/pocketpy_c.cpp b/c_bindings/pocketpy_c.cpp index 50d0d4a6..8f213238 100644 --- a/c_bindings/pocketpy_c.cpp +++ b/c_bindings/pocketpy_c.cpp @@ -3,6 +3,8 @@ using namespace pkpy; +#define PKPY_STACK_SIZE 32 + #define SAFEGUARD_OPEN try { \ #define SAFEGUARD_CLOSE \ @@ -20,27 +22,32 @@ using namespace pkpy; #define ERRHANDLER_OPEN SAFEGUARD_OPEN \ try { \ - if (vm->c_data.top() == nullptr) \ + if (w->c_data->size() > 0 && w->c_data->top() == nullptr) \ return false; \ #define ERRHANDLER_CLOSE \ } catch( Exception e ) { \ - vm->c_data.push(VAR(e)); \ - vm->c_data.push(NULL); \ + w->c_data->push(py_var(w->vm, e)); \ + w->c_data->push(NULL); \ return false; \ } \ SAFEGUARD_CLOSE \ +struct pkpy_vm_wrapper { + VM* vm; + ValueStackImpl* c_data; +}; + //for now I will unpack a tuple automatically, we may not want to handle //it this way, not sure //it is more lua like, but maybe not python like -static void unpack_return(VM* vm, PyObject* ret) { - if (is_type(ret, vm->tp_tuple)) { - Tuple& t = CAST(Tuple&, ret); +static void unpack_return(struct pkpy_vm_wrapper* w, PyObject* ret) { + if (is_type(ret, w->vm->tp_tuple)) { + Tuple& t = py_cast(w->vm, ret); for (int i = 0; i < t.size(); i++) - vm->c_data.push(t[i]); - } else if (ret == vm->None) { + w->c_data->push(t[i]); + } else if (ret == w->vm->None) { //do nothing here //having to pop the stack after every call that returns none is annoying //lua does not do this @@ -49,66 +56,67 @@ static void unpack_return(VM* vm, PyObject* ret) { //if this becomes a problem we can change it // //you can still check if it returned none by comparing stack size before - //and after if you have too + //and after if you have to } else - vm->c_data.push(ret); + w->c_data->push(ret); } -bool pkpy_clear_error(pkpy_vm vm_handle, char** message) { - VM* vm = (VM*) vm_handle; +bool pkpy_clear_error(struct pkpy_vm_wrapper* w, char** message) { SAFEGUARD_OPEN - if (vm->c_data.top() != nullptr) + if (w->c_data->size() == 0 || w->c_data->top() != nullptr) return false; - vm->c_data.pop(); - Exception& e = CAST(Exception&, vm->c_data.top()); + w->c_data->pop(); + Exception& e = py_cast(w->vm, w->c_data->top()); if (message != nullptr) *message = e.summary().c_str_dup(); else std::cerr << "ERROR: " << e.summary() << "\n"; - vm->c_data.clear(); - vm->callstack.clear(); - vm->s_data.clear(); + w->c_data->clear(); + w->vm->callstack.clear(); + w->vm->s_data.clear(); return true; SAFEGUARD_CLOSE } -pkpy_vm pkpy_vm_create(bool use_stdio, bool enable_os) { - VM* vm = new VM(use_stdio, enable_os); +struct pkpy_vm_wrapper* pkpy_vm_create(bool use_stdio, bool enable_os) { + struct pkpy_vm_wrapper* w = (struct pkpy_vm_wrapper*) malloc(sizeof(*w)); + w->vm = new VM(use_stdio, enable_os); + w->c_data = new ValueStackImpl(); - return (pkpy_vm) vm; + return w; } -bool pkpy_vm_run(pkpy_vm vm_handle, const char* source) { - VM* vm = (VM*) vm_handle; +bool pkpy_vm_run(struct pkpy_vm_wrapper* w, const char* source) { ERRHANDLER_OPEN - CodeObject_ code = vm->compile(source, "", EXEC_MODE); - PyObject* result = vm->_exec(code, vm->_main); - unpack_return(vm, result); + CodeObject_ code = w->vm->compile(source, "", EXEC_MODE); + PyObject* result = w->vm->_exec(code, w->vm->_main); + unpack_return(w, result); return true; ERRHANDLER_CLOSE } -void pkpy_vm_destroy(pkpy_vm vm_handle) { - VM* vm = (VM*) vm_handle; - delete vm; +void pkpy_vm_destroy(struct pkpy_vm_wrapper* w) { + delete w->vm; + delete w->c_data; + free(w); } -static void propagate_if_errored(VM* vm) { +static void propagate_if_errored(struct pkpy_vm_wrapper* w) { try { - if (vm->c_data.top() != nullptr) + if (w->c_data->size() == 0 || w->c_data->top() != nullptr) return; - vm->c_data.pop(); - Exception& e = CAST(Exception&, vm->c_data.top()); - vm->c_data.pop(); + w->c_data->pop(); + Exception& e = py_cast(w->vm, w->c_data->top()); + w->c_data->pop(); throw e; } catch(Exception& e) { @@ -122,40 +130,41 @@ static void propagate_if_errored(VM* vm) { PyObject* c_function_wrapper(VM* vm, ArgsView args) { - LuaStyleFuncC f = CAST(NativeFunc&, args[-2])._lua_f; + LuaStyleFuncC f = py_cast(vm, args[-2])._lua_f; //setup c stack - int stored = vm->c_data.store(); + + struct pkpy_vm_wrapper w; + + ValueStackImpl c_stack = ValueStackImpl(); + w.vm = vm; + w.c_data = &c_stack; for (int i = 0; i < args.size(); i++) - vm->c_data.push(args[i]); + w.c_data->push(args[i]); - int retc = f(vm); + int retc = f(&w); - PyObject* ret = vm->None; - propagate_if_errored(vm); + PyObject* ret = w.vm->None; + propagate_if_errored(&w); if (retc == 1) - ret = vm->c_data.top(); + ret = w.c_data->top(); else if (retc > 1) { Tuple t = Tuple(retc); for (int i = 0; i < retc; i++) { - int stack_index = (vm->c_data.size() - retc) + i; - t[i] = vm->c_data.get(stack_index); + int stack_index = (w.c_data->size() - retc) + i; + t[i] = w.c_data->begin()[stack_index]; } - ret = VAR(t); + ret = py_var(w.vm, t); } - vm->c_data.clear(); - vm->c_data.restore(stored); - return ret; } -bool pkpy_push_function(pkpy_vm vm_handle, pkpy_function f) { - VM* vm = (VM*) vm_handle; +bool pkpy_push_function(struct pkpy_vm_wrapper* w, pkpy_function f) { ERRHANDLER_OPEN //TODO right now we just treat all c bound functions a varargs functions @@ -163,69 +172,58 @@ bool pkpy_push_function(pkpy_vm vm_handle, pkpy_function f) { NativeFunc nf = NativeFunc(c_function_wrapper, -1, 0); nf._lua_f = (LuaStyleFuncC) f; - vm->c_data.push(VAR(nf)); + w->c_data->push(py_var(w->vm, nf)); return true; ERRHANDLER_CLOSE } -bool pkpy_push_int(pkpy_vm vm_handle, int value) { - VM* vm = (VM*) vm_handle; +bool pkpy_push_int(struct pkpy_vm_wrapper* w, int value) { ERRHANDLER_OPEN - vm->c_data.push(VAR(value)); + w->c_data->push(py_var(w->vm, value)); return true; ERRHANDLER_CLOSE } -bool pkpy_push_float(pkpy_vm vm_handle, double value) { - VM* vm = (VM*) vm_handle; - +bool pkpy_push_float(struct pkpy_vm_wrapper* w, double value) { ERRHANDLER_OPEN - vm->c_data.push(VAR(value)); + w->c_data->push(py_var(w->vm, value)); return true; ERRHANDLER_CLOSE } -bool pkpy_push_bool(pkpy_vm vm_handle, bool value) { - VM* vm = (VM*) vm_handle; - +bool pkpy_push_bool(struct pkpy_vm_wrapper* w, bool value) { ERRHANDLER_OPEN - vm->c_data.push(VAR(value)); + w->c_data->push(py_var(w->vm, value)); return true; ERRHANDLER_CLOSE } -bool pkpy_push_string(pkpy_vm vm_handle, const char* value) { - VM* vm = (VM*) vm_handle; - +bool pkpy_push_string(struct pkpy_vm_wrapper* w, const char* value) { ERRHANDLER_OPEN - vm->c_data.push(VAR(value)); + w->c_data->push(py_var(w->vm, value)); return true; ERRHANDLER_CLOSE } -bool pkpy_push_stringn(pkpy_vm vm_handle, const char* value, int length) { - VM* vm = (VM*) vm_handle; - +bool pkpy_push_stringn(struct pkpy_vm_wrapper* w, const char* value, int length) { ERRHANDLER_OPEN Str s = Str(value, length); - vm->c_data.push(VAR(s)); + w->c_data->push(py_var(w->vm, s)); return true; ERRHANDLER_CLOSE } -bool pkpy_push_none(pkpy_vm vm_handle) { - VM* vm = (VM*) vm_handle; - +bool pkpy_push_none(struct pkpy_vm_wrapper* w) { ERRHANDLER_OPEN - vm->c_data.push(vm->None); + w->c_data->push(w->vm->None); return true; ERRHANDLER_CLOSE @@ -233,83 +231,77 @@ bool pkpy_push_none(pkpy_vm vm_handle) { -bool pkpy_set_global(pkpy_vm vm_handle, const char* name) { - VM* vm = (VM*) vm_handle; - +bool pkpy_set_global(struct pkpy_vm_wrapper* w, const char* name) { ERRHANDLER_OPEN - vm->_main->attr().set(name, vm->c_data.top()); + w->vm->_main->attr().set(name, w->c_data->top()); - vm->c_data.pop(); + w->c_data->pop(); return true; ERRHANDLER_CLOSE } //get global will also get bulitins -bool pkpy_get_global(pkpy_vm vm_handle, const char* name) { - VM* vm = (VM*) vm_handle; - +bool pkpy_get_global(struct pkpy_vm_wrapper* w, const char* name) { ERRHANDLER_OPEN - PyObject* o = vm->_main->attr().try_get(name); + PyObject* o = w->vm->_main->attr().try_get(name); if (o == nullptr) { - o = vm->builtins->attr().try_get(name); + o = w->vm->builtins->attr().try_get(name); if (o == nullptr) throw Exception("AttributeError", "could not find requested global"); } - vm->c_data.push(o); + w->c_data->push(o); return true; ERRHANDLER_CLOSE } -bool pkpy_call(pkpy_vm vm_handle, int argc) { - VM* vm = (VM*) vm_handle; +bool pkpy_call(struct pkpy_vm_wrapper* w, int argc) { ERRHANDLER_OPEN - int callable_index = vm->c_data.size() - argc - 1; + int callable_index = w->c_data->size() - argc - 1; - PyObject* callable = vm->c_data.get(callable_index); + PyObject* callable = w->c_data->begin()[callable_index]; - vm->s_data.push(callable); - vm->s_data.push(PY_NULL); + w->vm->s_data.push(callable); + w->vm->s_data.push(PY_NULL); for (int i = 0; i < argc; i++) - vm->s_data.push(vm->c_data.get(callable_index + i + 1)); + w->vm->s_data.push(w->c_data->begin()[callable_index + i + 1]); - PyObject* o = vm->vectorcall(argc); + PyObject* o = w->vm->vectorcall(argc); - vm->c_data.shrink(argc + 1); + w->c_data->shrink(argc + 1); - unpack_return(vm, o); + unpack_return(w, o); return true; ERRHANDLER_CLOSE } -bool pkpy_call_method(pkpy_vm vm_handle, const char* name, int argc) { - VM* vm = (VM*) vm_handle; +bool pkpy_call_method(struct pkpy_vm_wrapper* w, const char* name, int argc) { ERRHANDLER_OPEN - int self_index = vm->c_data.size() - argc - 1; - PyObject* self = vm->c_data.get(self_index); + int self_index = w->c_data->size() - argc - 1; + PyObject* self = w->c_data->begin()[self_index]; - PyObject* callable = vm->get_unbound_method(self, name, &self); + PyObject* callable = w->vm->get_unbound_method(self, name, &self); - vm->s_data.push(callable); - vm->s_data.push(self); + w->vm->s_data.push(callable); + w->vm->s_data.push(self); for (int i = 0; i < argc; i++) - vm->s_data.push(vm->c_data.get(self_index + i + 1)); + w->vm->s_data.push(w->c_data->begin()[self_index + i + 1]); - PyObject* o = vm->vectorcall(argc); + PyObject* o = w->vm->vectorcall(argc); - vm->c_data.shrink(argc + 1); + w->c_data->shrink(argc + 1); - unpack_return(vm, o); + unpack_return(w, o); return true; ERRHANDLER_CLOSE @@ -323,57 +315,53 @@ static int lua_to_cstack_index(int index, int size) { return index; } -bool pkpy_to_int(pkpy_vm vm_handle, int index, int* ret) { - VM* vm = (VM*) vm_handle; +bool pkpy_to_int(struct pkpy_vm_wrapper* w, int index, int* ret) { ERRHANDLER_OPEN - index = lua_to_cstack_index(index, vm->c_data.size()); + index = lua_to_cstack_index(index, w->c_data->size()); - PyObject* o = vm->c_data.get(index); + PyObject* o = w->c_data->begin()[index]; if (ret != nullptr) - *ret = py_cast(vm, o); + *ret = py_cast(w->vm, o); return true; ERRHANDLER_CLOSE } -bool pkpy_to_float(pkpy_vm vm_handle, int index, double* ret) { - VM* vm = (VM*) vm_handle; +bool pkpy_to_float(struct pkpy_vm_wrapper* w, int index, double* ret) { ERRHANDLER_OPEN - index = lua_to_cstack_index(index, vm->c_data.size()); + index = lua_to_cstack_index(index, w->c_data->size()); - PyObject* o = vm->c_data.get(index); + PyObject* o = w->c_data->begin()[index]; if (ret != nullptr) - *ret = py_cast(vm, o); + *ret = py_cast(w->vm, o); return true; ERRHANDLER_CLOSE } -bool pkpy_to_bool(pkpy_vm vm_handle, int index, bool* ret) { - VM* vm = (VM*) vm_handle; +bool pkpy_to_bool(struct pkpy_vm_wrapper* w, int index, bool* ret) { ERRHANDLER_OPEN - index = lua_to_cstack_index(index, vm->c_data.size()); + index = lua_to_cstack_index(index, w->c_data->size()); - PyObject* o = vm->c_data.get(index); + PyObject* o = w->c_data->begin()[index]; if (ret != nullptr) - *ret = py_cast(vm, o); + *ret = py_cast(w->vm, o); return true; ERRHANDLER_CLOSE } -bool pkpy_to_string(pkpy_vm vm_handle, int index, char** ret) { - VM* vm = (VM*) vm_handle; +bool pkpy_to_string(struct pkpy_vm_wrapper* w, int index, char** ret) { ERRHANDLER_OPEN - index = lua_to_cstack_index(index, vm->c_data.size()); + index = lua_to_cstack_index(index, w->c_data->size()); - PyObject* o = vm->c_data.get(index); + PyObject* o = w->c_data->begin()[index]; if (ret != nullptr) { - Str& s = CAST(Str&, o); + Str& s = py_cast(w->vm, o); *ret = s.c_str_dup(); } @@ -381,54 +369,46 @@ bool pkpy_to_string(pkpy_vm vm_handle, int index, char** ret) { ERRHANDLER_CLOSE } -bool pkpy_is_int(pkpy_vm vm_handle, int index) { - VM* vm = (VM*) vm_handle; +bool pkpy_is_int(struct pkpy_vm_wrapper* w, int index) { + index = lua_to_cstack_index(index, w->c_data->size()); + PyObject* o = w->c_data->begin()[index]; - index = lua_to_cstack_index(index, vm->c_data.size()); - PyObject* o = vm->c_data.get(index); - - return is_type(o, vm->tp_int); + return is_type(o, w->vm->tp_int); } -bool pkpy_is_float(pkpy_vm vm_handle, int index) { - VM* vm = (VM*) vm_handle; +bool pkpy_is_float(struct pkpy_vm_wrapper* w, int index) { + index = lua_to_cstack_index(index, w->c_data->size()); + PyObject* o = w->c_data->begin()[index]; - index = lua_to_cstack_index(index, vm->c_data.size()); - PyObject* o = vm->c_data.get(index); - - return is_type(o, vm->tp_float); + return is_type(o, w->vm->tp_float); } -bool pkpy_is_bool(pkpy_vm vm_handle, int index) { - VM* vm = (VM*) vm_handle; +bool pkpy_is_bool(struct pkpy_vm_wrapper* w, int index) { + index = lua_to_cstack_index(index, w->c_data->size()); + PyObject* o = w->c_data->begin()[index]; - index = lua_to_cstack_index(index, vm->c_data.size()); - PyObject* o = vm->c_data.get(index); - - return is_type(o, vm->tp_bool); + return is_type(o, w->vm->tp_bool); } -bool pkpy_is_string(pkpy_vm vm_handle, int index) { - VM* vm = (VM*) vm_handle; +bool pkpy_is_string(struct pkpy_vm_wrapper* w, int index) { + index = lua_to_cstack_index(index, w->c_data->size()); + PyObject* o = w->c_data->begin()[index]; - index = lua_to_cstack_index(index, vm->c_data.size()); - PyObject* o = vm->c_data.get(index); - - return is_type(o, vm->tp_str); + return is_type(o, w->vm->tp_str); } -bool pkpy_is_none(pkpy_vm vm_handle, int index) { - VM* vm = (VM*) vm_handle; +bool pkpy_is_none(struct pkpy_vm_wrapper* w, int index) { + index = lua_to_cstack_index(index, w->c_data->size()); + PyObject* o = w->c_data->begin()[index]; - index = lua_to_cstack_index(index, vm->c_data.size()); - PyObject* o = vm->c_data.get(index); - - return o == vm->None; + return o == w->vm->None; } -bool pkpy_check_stack(pkpy_vm vm_handle, int free) { - VM* vm = (VM*) vm_handle; - return free <= vm->c_data.remaining(); +bool pkpy_check_stack(struct pkpy_vm_wrapper* w, int free) { + return free + w->c_data->size() <= PKPY_STACK_SIZE; } -int pkpy_stack_size(pkpy_vm vm_handle) { - VM* vm = (VM*) vm_handle; - return vm->c_data.size(); +int pkpy_stack_size(struct pkpy_vm_wrapper* w) { + return w->c_data->size(); } +bool pkpy_pop(struct pkpy_vm_wrapper* w, int n) { + w->c_data->shrink(n); + return true; +} diff --git a/c_bindings/pocketpy_c.h b/c_bindings/pocketpy_c.h index d64af7c2..b1fda0fb 100644 --- a/c_bindings/pocketpy_c.h +++ b/c_bindings/pocketpy_c.h @@ -8,8 +8,7 @@ extern "C" { #include #include -typedef struct pkpy_vm_handle* pkpy_vm; -typedef struct pkpy_repl_hande* pkpy_repl; +typedef struct pkpy_vm_wrapper pkpy_vm; //we we take a lot of inspiration from the lua api for these bindings //the key difference being most methods return a bool, @@ -21,62 +20,65 @@ typedef struct pkpy_repl_hande* pkpy_repl; //it will provide a string summary of the error in the message parameter (if it is not NULL) //NOTE : you need to free the message that is passed back after you are done using it //or else pass in null as message, and it will just print the message to stderr -bool pkpy_clear_error(pkpy_vm, char** message); +bool pkpy_clear_error(pkpy_vm*, char** message); -pkpy_vm pkpy_vm_create(bool use_stdio, bool enable_os); -bool pkpy_vm_run(pkpy_vm, const char* source); -void pkpy_vm_destroy(pkpy_vm); +pkpy_vm* pkpy_vm_create(bool use_stdio, bool enable_os); +bool pkpy_vm_run(pkpy_vm*, const char* source); +void pkpy_vm_destroy(pkpy_vm*); -typedef int (*pkpy_function)(pkpy_vm); +typedef int (*pkpy_function)(pkpy_vm*); -bool pkpy_push_function(pkpy_vm, pkpy_function); -bool pkpy_push_int(pkpy_vm, int); -bool pkpy_push_float(pkpy_vm, double); -bool pkpy_push_bool(pkpy_vm, bool); -bool pkpy_push_string(pkpy_vm, const char*); -bool pkpy_push_stringn(pkpy_vm, const char*, int length); -bool pkpy_push_none(pkpy_vm); +bool pkpy_pop(pkpy_vm*, int n); -bool pkpy_set_global(pkpy_vm, const char* name); -bool pkpy_get_global(pkpy_vm, const char* name); +bool pkpy_push_function(pkpy_vm*, pkpy_function); +bool pkpy_push_int(pkpy_vm*, int); +bool pkpy_push_float(pkpy_vm*, double); +bool pkpy_push_bool(pkpy_vm*, bool); +bool pkpy_push_string(pkpy_vm*, const char*); +bool pkpy_push_stringn(pkpy_vm*, const char*, int length); +bool pkpy_push_none(pkpy_vm*); + +bool pkpy_set_global(pkpy_vm*, const char* name); +bool pkpy_get_global(pkpy_vm*, const char* name); //first push callable you want to call //then push the arguments to send //argc is the number of arguments that was pushed (not counting the callable) -bool pkpy_call(pkpy_vm, int argc); +bool pkpy_call(pkpy_vm*, int argc); //first push the object the method belongs to (self) //then push the the argments //argc is the number of arguments that was pushed (not counting the callable or self) //name is the name of the method to call on the object -bool pkpy_call_method(pkpy_vm, const char* name, int argc); +bool pkpy_call_method(pkpy_vm*, const char* name, int argc); //we will break with the lua api here //lua uses 1 as the index to the first pushed element for all of these functions //but we will start counting at zero to match python //we will allow negative numbers to count backwards from the top -bool pkpy_to_int(pkpy_vm, int index, int* ret); -bool pkpy_to_float(pkpy_vm, int index, double* ret); -bool pkpy_to_bool(pkpy_vm, int index, bool* ret); +bool pkpy_to_int(pkpy_vm*, int index, int* ret); +bool pkpy_to_float(pkpy_vm*, int index, double* ret); +bool pkpy_to_bool(pkpy_vm*, int index, bool* ret); //you have to free ret after you are done using it -bool pkpy_to_string(pkpy_vm, int index, char** ret); +bool pkpy_to_string(pkpy_vm*, int index, char** ret); //these do not follow the same error semantics as above, their return values //just say whether the check succeeded or not, or else return the value asked for -bool pkpy_is_int(pkpy_vm, int index); -bool pkpy_is_float(pkpy_vm, int index); -bool pkpy_is_bool(pkpy_vm, int index); -bool pkpy_is_string(pkpy_vm, int index); -bool pkpy_is_none(pkpy_vm, int index); +bool pkpy_is_int(pkpy_vm*, int index); +bool pkpy_is_float(pkpy_vm*, int index); +bool pkpy_is_bool(pkpy_vm*, int index); +bool pkpy_is_string(pkpy_vm*, int index); +bool pkpy_is_none(pkpy_vm*, int index); //will return true if at least free empty slots remain on the stack -bool pkpy_check_stack(pkpy_vm, int free); +bool pkpy_check_stack(pkpy_vm*, int free); //returns the number of elements on the stack -int pkpy_stack_size(pkpy_vm); +int pkpy_stack_size(pkpy_vm*); + #ifdef __cplusplus } diff --git a/c_bindings/test.c b/c_bindings/test.c index 8aa8cd76..e18bbb8e 100644 --- a/c_bindings/test.c +++ b/c_bindings/test.c @@ -4,7 +4,7 @@ //tests the c bindings for pocketpy -void check_impl(pkpy_vm vm, bool result, int lineno) { +void check_impl(pkpy_vm* vm, bool result, int lineno) { if (!result) { printf("ERROR: failed where it should have succeed at line %i\n", lineno); char* message; @@ -19,7 +19,7 @@ void check_impl(pkpy_vm vm, bool result, int lineno) { } } -void fail_impl(pkpy_vm vm, bool result, int lineno) { +void fail_impl(pkpy_vm* vm, bool result, int lineno) { if (result) { printf("ERROR: succeeded where it should have failed line %i\n", lineno); exit(1); @@ -33,7 +33,7 @@ void fail_impl(pkpy_vm vm, bool result, int lineno) { } } -void error_impl(pkpy_vm vm, bool result, int lineno) { +void error_impl(pkpy_vm* vm, bool result, int lineno) { if (result) { printf("ERROR: succeeded where it should have failed line %i\n", lineno); exit(1); @@ -54,28 +54,28 @@ void error_impl(pkpy_vm vm, bool result, int lineno) { #define fail(r) fail_impl(vm, (r), __LINE__) #define error(r) error_impl(vm, (r), __LINE__) -int test_binding(pkpy_vm vm) { +int test_binding(pkpy_vm* vm) { pkpy_push_int(vm, 12); return 1; } -int test_multiple_return(pkpy_vm vm) { +int test_multiple_return(pkpy_vm* vm) { pkpy_push_int(vm, 12); pkpy_push_int(vm, 13); return 2; } -int test_return_none(pkpy_vm vm) { +int test_return_none(pkpy_vm* vm) { return 0; } -int test_error_propagate(pkpy_vm vm) { +int test_error_propagate(pkpy_vm* vm) { pkpy_get_global(vm, "does not exist"); return 1; } -pkpy_vm vm; +pkpy_vm* vm; void cleanup(void) { pkpy_vm_destroy(vm); @@ -163,8 +163,8 @@ int main(int argc, char** argv) { int stack_size = pkpy_stack_size(vm); printf("stack size %i\n", stack_size); check(pkpy_check_stack(vm, 10)); - check(pkpy_check_stack(vm, 251)); - fail(pkpy_check_stack(vm, 252)); + check(pkpy_check_stack(vm, 27)); + fail(pkpy_check_stack(vm, 28)); check(pkpy_is_int(vm, 0)); check(pkpy_is_float(vm, 1)); check(pkpy_is_bool(vm, 2)); @@ -258,5 +258,8 @@ int main(int argc, char** argv) { check(pkpy_call(vm, 0)); check(pkpy_stack_size(vm) == 2); + check(pkpy_pop(vm, 2)); + check(pkpy_stack_size(vm) == 0); + return 0; } diff --git a/run_c_binding_test.sh b/run_c_binding_test.sh index c98603d8..33018288 100644 --- a/run_c_binding_test.sh +++ b/run_c_binding_test.sh @@ -18,7 +18,7 @@ echo "checking results (they should be identical)" diff -q -s binding_test_scratch c_bindings/test_answers.txt echo "cleaning up" -rm pocketpy_c.o +#rm pocketpy_c.o rm test.o rm binding_test_scratch diff --git a/src/frame.h b/src/frame.h index e3705b66..c5f0164a 100644 --- a/src/frame.h +++ b/src/frame.h @@ -190,5 +190,4 @@ struct Frame { } }; -}; // namespace pkpy - +}; // namespace pkpy \ No newline at end of file diff --git a/src/obj.h b/src/obj.h index a504b597..fbc67778 100644 --- a/src/obj.h +++ b/src/obj.h @@ -12,7 +12,7 @@ struct Function; class VM; typedef PyObject* (*NativeFuncC)(VM*, ArgsView); -typedef int (*LuaStyleFuncC)(VM*); +typedef int (*LuaStyleFuncC)(void*); struct NativeFunc { NativeFuncC f; @@ -370,4 +370,4 @@ struct Py_ final: PyObject { }; -} // namespace pkpy \ No newline at end of file +} // namespace pkpy diff --git a/src/vm.h b/src/vm.h index 97951a18..3d6db7eb 100644 --- a/src/vm.h +++ b/src/vm.h @@ -78,7 +78,6 @@ class VM { public: ManagedHeap heap; ValueStack s_data; - CVirtualStack c_data; stack< Frame > callstack; std::vector _all_types; @@ -1204,4 +1203,4 @@ inline Str obj_type_name(VM *vm, Type type){ #undef PY_VAR_INT #undef PY_VAR_FLOAT -} // namespace pkpy +} // namespace pkpy \ No newline at end of file