Zxc200611/pocketpy
1
0
Fork 0
mirror of https://github.com/pocketpy/pocketpy synced 2025-10-23 21:10:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
blueloveTH 2023-07-15 12:22:53 +08:00
parent 8f5f3f43c2
commit fd2996eb87
5 changed files with 120 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
c_bindings/test.c
View File

@ -71,34 +71,30 @@ int test_return_none(pkpy_vm* vm) {
} }
int test_error_propagate(pkpy_vm* vm) { int test_error_propagate(pkpy_vm* vm) {
pkpy_error(vm, "NameError", "catch me"); pkpy_error(vm, "NameError", pkpy_string("catch me"));
return 1; return 1;
} }
int test_nested_error(pkpy_vm* vm) { int test_nested_error(pkpy_vm* vm) {
pkpy_get_global(vm, "error_from_python"); pkpy_getglobal(vm, pkpy_name("error_from_python"));
pkpy_call(vm, 0); pkpy_push_null(vm);
pkpy_vectorcall(vm, 0);
return 0; return 0;
} }
pkpy_vm* vm;
int main(int argc, char** argv) { int main(int argc, char** argv) {
pkpy_vm* vm = pkpy_new_vm(true);
vm = pkpy_vm_create(true, true); check(pkpy_exec(vm, "print('hello world!')"));
error(pkpy_getglobal(vm, pkpy_name("nonexistatn")));
//test run
check(pkpy_vm_run(vm, "print('hello world!')"));
error(pkpy_get_global(vm, "nonexistatn"));
printf("\ntesting int methods\n"); printf("\ntesting int methods\n");
int r_int; int r_int;
check(pkpy_push_int(vm, 11)); check(pkpy_push_int(vm, 11));
check(pkpy_set_global(vm, "eleven")); pkpy_CName m_eleven = pkpy_name("eleven");
check(pkpy_vm_run(vm, "print(eleven)")); check(pkpy_setglobal(vm, m_eleven));
check(pkpy_get_global(vm, "eleven")); check(pkpy_exec(vm, "print(eleven)"));
check(pkpy_getglobal(vm, m_eleven));
check(pkpy_is_int(vm, -1)); check(pkpy_is_int(vm, -1));
check(pkpy_to_int(vm, -1, &r_int)); check(pkpy_to_int(vm, -1, &r_int));
printf("%i\n", r_int); printf("%i\n", r_int);
@ -109,11 +105,12 @@ int main(int argc, char** argv) {
fail(pkpy_is_voidp(vm, -1)); fail(pkpy_is_voidp(vm, -1));
printf("\ntesting float methods\n"); printf("\ntesting float methods\n");
double r_float; float r_float;
check(pkpy_push_float(vm, 11.11)); check(pkpy_push_float(vm, 11.11));
check(pkpy_set_global(vm, "elevenf")); pkpy_CName m_elevenf = pkpy_name("elevenf");
check(pkpy_vm_run(vm, "print(elevenf)")); check(pkpy_setglobal(vm, m_elevenf));
check(pkpy_get_global(vm, "elevenf")); check(pkpy_exec(vm, "print(elevenf)"));
check(pkpy_getglobal(vm, m_elevenf));
check(pkpy_is_float(vm, -1)); check(pkpy_is_float(vm, -1));
check(pkpy_to_float(vm, -1, &r_float)); check(pkpy_to_float(vm, -1, &r_float));
printf("%f\n", r_float); printf("%f\n", r_float);
@ -126,9 +123,10 @@ int main(int argc, char** argv) {
printf("\ntesting bool methods\n"); printf("\ntesting bool methods\n");
bool r_bool; bool r_bool;
check(pkpy_push_bool(vm, false)); check(pkpy_push_bool(vm, false));
check(pkpy_set_global(vm, "false_test")); pkpy_CName m_false_test = pkpy_name("false_test");
check(pkpy_vm_run(vm, "print(false_test)")); check(pkpy_setglobal(vm, m_false_test));
check(pkpy_get_global(vm, "false_test")); check(pkpy_exec(vm, "print(false_test)"));
check(pkpy_getglobal(vm, m_false_test));
check(pkpy_is_bool(vm, -1)); check(pkpy_is_bool(vm, -1));
check(pkpy_to_bool(vm, -1, &r_bool)); check(pkpy_to_bool(vm, -1, &r_bool));
printf("%i\n", r_bool); printf("%i\n", r_bool);
@ -139,19 +137,19 @@ int main(int argc, char** argv) {
fail(pkpy_is_voidp(vm, -1)); fail(pkpy_is_voidp(vm, -1));
printf("\ntesting string methods\n"); printf("\ntesting string methods\n");
char* r_string; pkpy_CString r_string;
check(pkpy_push_string(vm, "hello!")); check(pkpy_push_string(vm, pkpy_string("hello!")));
check(pkpy_set_global(vm, "hello1")); check(pkpy_setglobal(vm, pkpy_name("hello1")));
check(pkpy_vm_run(vm, "print(hello1)")); check(pkpy_exec(vm, "print(hello1)"));
check(pkpy_push_stringn(vm, "hello!", 5)); check(pkpy_push_string(vm, pkpy_string("hello!")));
check(pkpy_is_string(vm, -1)); check(pkpy_is_string(vm, -1));
check(pkpy_to_string(vm, -1, &r_string)); check(pkpy_to_string(vm, -1, &r_string));
printf("%s\n", r_string);
free(r_string); for(int i=0; i<r_string.size; i++) {
const char* r_stringn; putchar(r_string.data[i]);
int r_size; }
check(pkpy_to_stringn(vm, -1, &r_stringn, &r_size)); putchar('\n');
printf("%.*s\n", r_size, r_stringn);
fail(pkpy_is_int(vm, -1)); fail(pkpy_is_int(vm, -1));
fail(pkpy_is_float(vm, -1)); fail(pkpy_is_float(vm, -1));
fail(pkpy_is_bool(vm, -1)); fail(pkpy_is_bool(vm, -1));
@ -160,9 +158,10 @@ int main(int argc, char** argv) {
printf("\ntesting None methods\n"); printf("\ntesting None methods\n");
check(pkpy_push_none(vm)); check(pkpy_push_none(vm));
check(pkpy_set_global(vm, "none")); pkpy_CName m_none = pkpy_name("none");
check(pkpy_vm_run(vm, "print(none)")); check(pkpy_setglobal(vm, m_none));
check(pkpy_get_global(vm, "none")); check(pkpy_exec(vm, "print(none)"));
check(pkpy_getglobal(vm, m_none));
check(pkpy_is_none(vm, -1)); check(pkpy_is_none(vm, -1));
fail(pkpy_is_int(vm, -1)); fail(pkpy_is_int(vm, -1));
fail(pkpy_is_float(vm, -1)); fail(pkpy_is_float(vm, -1));
@ -173,9 +172,9 @@ int main(int argc, char** argv) {
printf("\ntesting voidp methods\n"); printf("\ntesting voidp methods\n");
void* vp = (void*) 123; void* vp = (void*) 123;
check(pkpy_push_voidp(vm, vp)); check(pkpy_push_voidp(vm, vp));
check(pkpy_set_global(vm, "vp")); check(pkpy_setglobal(vm, pkpy_name("vp")));
check(pkpy_vm_run(vm, "print(vp)")); check(pkpy_exec(vm, "print(vp)"));
check(pkpy_get_global(vm, "vp")); check(pkpy_getglobal(vm, pkpy_name("vp")));
check(pkpy_is_voidp(vm, -1)); check(pkpy_is_voidp(vm, -1));
vp = NULL; vp = NULL;
check(pkpy_to_voidp(vm, -1, &vp)); check(pkpy_to_voidp(vm, -1, &vp));
@ -190,9 +189,6 @@ int main(int argc, char** argv) {
printf("\ntesting sizing and indexing\n"); printf("\ntesting sizing and indexing\n");
int stack_size = pkpy_stack_size(vm); int stack_size = pkpy_stack_size(vm);
printf("stack size %i\n", stack_size); printf("stack size %i\n", stack_size);
check(pkpy_check_stack(vm, 10));
check(pkpy_check_stack(vm, 26));
fail(pkpy_check_stack(vm, 27));
check(pkpy_is_int(vm, 0)); check(pkpy_is_int(vm, 0));
check(pkpy_is_float(vm, 1)); check(pkpy_is_float(vm, 1));
check(pkpy_is_bool(vm, 2)); check(pkpy_is_bool(vm, 2));
@ -205,53 +201,56 @@ int main(int argc, char** argv) {
check(pkpy_is_string(vm, -3)); check(pkpy_is_string(vm, -3));
check(pkpy_is_none(vm, -2)); check(pkpy_is_none(vm, -2));
check(pkpy_is_voidp(vm, -1)); check(pkpy_is_voidp(vm, -1));
check(pkpy_push(vm, -3));
check(pkpy_is_string(vm, -1));
printf("\ntesting error catching\n"); printf("\ntesting error catching\n");
error(pkpy_vm_run(vm, "let's make sure syntax errors get caught")); error(pkpy_exec(vm, "let's make sure syntax errors get caught"));
check(pkpy_stack_size(vm) == 0); //stack should be cleared after error is resolved check(pkpy_stack_size(vm) == 0); //stack should be cleared after error is resolved
printf("\ntesting calls\n"); printf("\ntesting calls\n");
check(pkpy_vm_run(vm, "def x(x, y) : return x - y")); check(pkpy_exec(vm, "def x(x, y) : return x - y"));
check(pkpy_vm_run(vm, "def vararg_x(*x) : return sum(x)")); check(pkpy_exec(vm, "def vararg_x(*x) : return sum(x)"));
check(pkpy_vm_run(vm, "def keyword_x(x=1, y=1) : return x+y")); check(pkpy_exec(vm, "def keyword_x(x=1, y=1) : return x+y"));
check(pkpy_vm_run(vm, "def retmany_x() : return 1, 2, 3")); check(pkpy_exec(vm, "def retmany_x() : return 1, 2, 3"));
check(pkpy_get_global(vm, "x")); check(pkpy_getglobal(vm, pkpy_name("x")));
check(pkpy_push_null(vm));
check(pkpy_push_int(vm, 2)); check(pkpy_push_int(vm, 2));
check(pkpy_push_int(vm, 3)); check(pkpy_push_int(vm, 3));
check(pkpy_call(vm, 2)); check(pkpy_vectorcall(vm, 2));
check(pkpy_to_int(vm, -1, &r_int)); check(pkpy_to_int(vm, -1, &r_int));
printf("x : %i\n", r_int); printf("x : %i\n", r_int);
check(pkpy_get_global(vm, "vararg_x")); check(pkpy_getglobal(vm, pkpy_name("vararg_x")));
check(pkpy_push_null(vm));
check(pkpy_push_int(vm, 1)); check(pkpy_push_int(vm, 1));
check(pkpy_push_int(vm, 2)); check(pkpy_push_int(vm, 2));
check(pkpy_push_int(vm, 3)); check(pkpy_push_int(vm, 3));
check(pkpy_push_int(vm, 4)); check(pkpy_push_int(vm, 4));
check(pkpy_push_int(vm, 5)); check(pkpy_push_int(vm, 5));
check(pkpy_push_int(vm, 6)); check(pkpy_push_int(vm, 6));
check(pkpy_call(vm, 6)); check(pkpy_vectorcall(vm, 6));
check(pkpy_to_int(vm, -1, &r_int)); check(pkpy_to_int(vm, -1, &r_int));
printf("vararg_x : %i\n", r_int); printf("vararg_x : %i\n", r_int);
check(pkpy_get_global(vm, "keyword_x")); check(pkpy_getglobal(vm, pkpy_name("keyword_x")));
check(pkpy_push_null(vm));
check(pkpy_push_int(vm, 3)); check(pkpy_push_int(vm, 3));
check(pkpy_call(vm, 1)); check(pkpy_vectorcall(vm, 1));
check(pkpy_to_int(vm, -1, &r_int)); check(pkpy_to_int(vm, -1, &r_int));
printf("keyword_x : %i\n", r_int); printf("keyword_x : %i\n", r_int);
check(pkpy_get_global(vm, "keyword_x")); check(pkpy_getglobal(vm, pkpy_name("keyword_x")));
check(pkpy_call(vm, 0)); check(pkpy_push_null(vm));
check(pkpy_vectorcall(vm, 0));
check(pkpy_to_int(vm, -1, &r_int)); check(pkpy_to_int(vm, -1, &r_int));
printf("keyword_x : %i\n", r_int); printf("keyword_x : %i\n", r_int);
check(pkpy_stack_size(vm) == 4); check(pkpy_stack_size(vm) == 4);
check(pkpy_get_global(vm, "retmany_x")); check(pkpy_getglobal(vm, pkpy_name("retmany_x")));
check(pkpy_call(vm, 0)); check(pkpy_push_null(vm));
check(pkpy_vectorcall(vm, 0));
check(pkpy_stack_size(vm) == 7); check(pkpy_stack_size(vm) == 7);
check(pkpy_to_int(vm, -3, &r_int)); check(pkpy_to_int(vm, -3, &r_int));
printf("retmany_x : %i\n", r_int); printf("retmany_x : %i\n", r_int);
@ -260,69 +259,73 @@ int main(int argc, char** argv) {
check(pkpy_to_int(vm, -1, &r_int)); check(pkpy_to_int(vm, -1, &r_int));
printf("retmany_x : %i\n", r_int); printf("retmany_x : %i\n", r_int);
check(pkpy_get_global(vm, "x")); check(pkpy_getglobal(vm, pkpy_name("x")));
error(pkpy_call(vm, 0)); check(pkpy_push_null(vm));
error(pkpy_vectorcall(vm, 0));
check(pkpy_vm_run(vm, "l = []")); check(pkpy_exec(vm, "l = []"));
check(pkpy_get_global(vm, "l")); check(pkpy_getglobal(vm, pkpy_name("l")));
check(pkpy_push_string(vm, "hello")); check(pkpy_get_unbound_method(vm, pkpy_name("append")));
check(pkpy_call_method(vm, "append", 1)); check(pkpy_push_string(vm, pkpy_string("hello")));
check(pkpy_vm_run(vm, "print(l)")); check(pkpy_vectorcall(vm, 1));
check(pkpy_exec(vm, "print(l)"));
printf("\ntesting pushing functions\n"); printf("\ntesting pushing functions\n");
check(pkpy_push_function(vm, test_binding, 0)); check(pkpy_push_function(vm, "test_binding()", test_binding));
check(pkpy_set_global(vm, "test_binding")); check(pkpy_setglobal(vm, pkpy_name("test_binding")));
check(pkpy_vm_run(vm, "print(test_binding())")); check(pkpy_exec(vm, "print(test_binding())"));
check(pkpy_push_function(vm, test_multiple_return, 0)); check(pkpy_push_function(vm, "test_multiple_return()", test_multiple_return));
check(pkpy_set_global(vm, "test_multiple_return")); check(pkpy_setglobal(vm, pkpy_name("test_multiple_return")));
//uncomment if _exec changes //uncomment if _exec changes
//check(pkpy_vm_run(vm, "test_multiple_return()")); //check(pkpy_exec(vm, "test_multiple_return()"));
//check(pkpy_stack_size(vm) == 2); //check(pkpy_stack_size(vm) == 2);
check(pkpy_push_function(vm, test_error_propagate, 0)); check(pkpy_push_function(vm, "test_error_propagate()", test_error_propagate));
check(pkpy_set_global(vm, "test_error_propagate")); check(pkpy_setglobal(vm, pkpy_name("test_error_propagate")));
error(pkpy_vm_run(vm, "test_error_propagate()")); error(pkpy_exec(vm, "test_error_propagate()"));
check(pkpy_get_global(vm, "test_multiple_return")); check(pkpy_getglobal(vm, pkpy_name("test_multiple_return")));
check(pkpy_call(vm, 0)); check(pkpy_push_null(vm));
check(pkpy_vectorcall(vm, 0));
check(pkpy_stack_size(vm) == 2); check(pkpy_stack_size(vm) == 2);
check(pkpy_pop(vm, 2)); check(pkpy_pop(vm, 2));
check(pkpy_stack_size(vm) == 0); check(pkpy_stack_size(vm) == 0);
check(pkpy_check_global(vm, "test_error_propagate")); check(pkpy_getglobal(vm, pkpy_name("test_error_propagate")));
fail(pkpy_check_global(vm, "nonexistant")); check(pkpy_pop_top(vm));
fail(pkpy_getglobal(vm, pkpy_name("nonexistant")));
error(pkpy_vm_run(vm, "raise NameError('testing error throwing from python')")); error(pkpy_exec(vm, "raise NameError('testing error throwing from python')"));
pkpy_vm_run(vm, "test_error_propagate()"); pkpy_exec(vm, "test_error_propagate()");
check(pkpy_check_error(vm)); check(pkpy_check_error(vm));
// testing code going to standard error, can ignore next error // testing code going to standard error, can ignore next error
pkpy_clear_error(vm, NULL); pkpy_clear_error(vm, NULL);
//errors //errors
//this should be catchable //this should be catchable
check(pkpy_vm_run(vm, "try : test_error_propagate(); except NameError : pass")); check(pkpy_exec(vm, "try : test_error_propagate(); except NameError : pass"));
error(pkpy_error(vm, "_", "test direct error mechanism")); error(pkpy_error(vm, "_", pkpy_string("test direct error mechanism")));
//more complicated error handling //more complicated error handling
check(pkpy_vm_run(vm, "def error_from_python() : raise NotImplementedError()")); check(pkpy_exec(vm, "def error_from_python() : raise NotImplementedError()"));
check(pkpy_push_function(vm, test_nested_error, 0)); check(pkpy_push_function(vm, "test_nested_error()", test_nested_error));
check(pkpy_set_global(vm, "test_nested_error")); check(pkpy_setglobal(vm, pkpy_name("test_nested_error")));
error(pkpy_vm_run(vm, "test_nested_error()")); error(pkpy_exec(vm, "test_nested_error()"));
check(pkpy_vm_run(vm, "import math")); check(pkpy_exec(vm, "import math"));
check(pkpy_get_global(vm, "math")); check(pkpy_getglobal(vm, pkpy_name("math")));
check(pkpy_getattr(vm, "pi")); check(pkpy_getattr(vm, pkpy_name("pi")));
check(pkpy_to_float(vm, -1, &r_float)); check(pkpy_to_float(vm, -1, &r_float));
printf("pi: %.2f\n", r_float); printf("pi: %.2f\n", r_float);
@ -335,8 +338,8 @@ int main(int argc, char** argv) {
// math.pi = 2 // math.pi = 2
check(pkpy_push_int(vm, 2)); check(pkpy_push_int(vm, 2));
check(pkpy_eval(vm, "math")); check(pkpy_eval(vm, "math"));
check(pkpy_setattr(vm, "pi")); check(pkpy_setattr(vm, pkpy_name("pi")));
check(pkpy_vm_run(vm, "print(math.pi)")); check(pkpy_exec(vm, "print(math.pi)"));
//should give a type error //should give a type error

2
docs/C-API/error.md
View File

@ -15,6 +15,6 @@ order: 5
Return true if the vm is currently in an error state. Return true if the vm is currently in an error state.
#### `bool pkpy_error(pkpy_vm*, const char* name, const char* message)` #### `bool pkpy_error(pkpy_vm*, const char* name, pkpy_CString message)`
Set the error state of the vm. It is almost equivalent to `raise` in python. Set the error state of the vm. It is almost equivalent to `raise` in python.

4
docs/C-API/specials.md
View File

@ -15,3 +15,7 @@ order: 6
+ `pkpy_CName pkpy_name(const char*)` + `pkpy_CName pkpy_name(const char*)`
Construct a `pkpy_CName` from a null-terminated C string. You should cache the result of this function if you are going to use it multiple times. Construct a `pkpy_CName` from a null-terminated C string. You should cache the result of this function if you are going to use it multiple times.
+ `pkpy_CString pkpy_name_to_string(pkpy_CName)`
Convert a `pkpy_CName` to a `pkpy_CString`.

3
include/pocketpy/pocketpy_c.h
View File

@ -77,7 +77,7 @@ PK_EXPORT bool pkpy_unpack_sequence(pkpy_vm*, int size);
PK_EXPORT bool pkpy_get_unbound_method(pkpy_vm*, pkpy_CName); PK_EXPORT bool pkpy_get_unbound_method(pkpy_vm*, pkpy_CName);
/* Error Handling */ /* Error Handling */
PK_EXPORT bool pkpy_error(pkpy_vm*, const char* name, const char* message); PK_EXPORT bool pkpy_error(pkpy_vm*, const char* name, pkpy_CString);
PK_EXPORT bool pkpy_check_error(pkpy_vm*); PK_EXPORT bool pkpy_check_error(pkpy_vm*);
PK_EXPORT bool pkpy_clear_error(pkpy_vm*, char** message); PK_EXPORT bool pkpy_clear_error(pkpy_vm*, char** message);
@ -88,6 +88,7 @@ PK_EXPORT bool pkpy_vectorcall(pkpy_vm*, int argc);
PK_EXPORT void pkpy_free(void* p); PK_EXPORT void pkpy_free(void* p);
PK_EXPORT pkpy_CString pkpy_string(const char*); PK_EXPORT pkpy_CString pkpy_string(const char*);
PK_EXPORT pkpy_CName pkpy_name(const char*); PK_EXPORT pkpy_CName pkpy_name(const char*);
PK_EXPORT pkpy_CString pkpy_name_to_string(pkpy_CName);
PK_EXPORT void pkpy_compile_to_string(pkpy_vm*, const char* source, const char* filename, int mode, bool* ok, char** out); PK_EXPORT void pkpy_compile_to_string(pkpy_vm*, const char* source, const char* filename, int mode, bool* ok, char** out);
/* REPL */ /* REPL */

24
src/pocketpy_c.cpp
View File

@ -1,4 +1,5 @@
#include "pocketpy.h" #include "pocketpy.h"
#include "pocketpy/pocketpy_c.h"
#include "pocketpy_c.h" #include "pocketpy_c.h"
using namespace pkpy; using namespace pkpy;
@ -9,7 +10,7 @@ typedef int (*LuaStyleFuncC)(VM*);
int __ex_count = count_extra_elements(vm, n); \ int __ex_count = count_extra_elements(vm, n); \
if(__ex_count < n){ \ if(__ex_count < n){ \
std::string msg = fmt("expected at least ", n, " elements, got ", __ex_count); \ std::string msg = fmt("expected at least ", n, " elements, got ", __ex_count); \
pkpy_error(vm_handle, "StackError", msg.c_str()); \ pkpy_error(vm_handle, "StackError", pkpy_string(msg.c_str())); \
return false; \ return false; \
} }
@ -373,14 +374,15 @@ bool pkpy_setattr(pkpy_vm* vm_handle, pkpy_CName name) {
} }
//get global will also get bulitins //get global will also get bulitins
bool pkpy_getglobal(pkpy_vm* vm_handle, const char* name) { bool pkpy_getglobal(pkpy_vm* vm_handle, pkpy_CName name_) {
VM* vm = (VM*) vm_handle; VM* vm = (VM*) vm_handle;
StrName name(name_);
PK_ASSERT_NO_ERROR() PK_ASSERT_NO_ERROR()
PyObject* o = vm->_main->attr().try_get(name); PyObject* o = vm->_main->attr().try_get(name);
if (o == nullptr) { if (o == nullptr) {
o = vm->builtins->attr().try_get(name); o = vm->builtins->attr().try_get(name);
if (o == nullptr){ if (o == nullptr){
pkpy_error(vm_handle, "NameError", name); pkpy_error(vm_handle, "NameError", pkpy_name_to_string(name_));
return false; return false;
} }
} }
@ -388,11 +390,11 @@ bool pkpy_getglobal(pkpy_vm* vm_handle, const char* name) {
return true; return true;
} }
bool pkpy_setglobal(pkpy_vm* vm_handle, const char* name) { bool pkpy_setglobal(pkpy_vm* vm_handle, pkpy_CName name_) {
VM* vm = (VM*) vm_handle; VM* vm = (VM*) vm_handle;
PK_ASSERT_NO_ERROR() PK_ASSERT_NO_ERROR()
PK_ASSERT_N_EXTRA_ELEMENTS(1) PK_ASSERT_N_EXTRA_ELEMENTS(1)
vm->_main->attr().set(name, vm->s_data.popx()); vm->_main->attr().set(StrName(name_), vm->s_data.popx());
return true; return true;
} }
@ -440,10 +442,10 @@ bool pkpy_get_unbound_method(pkpy_vm* vm_handle, pkpy_CName name){
} }
/* Error Handling */ /* Error Handling */
bool pkpy_error(pkpy_vm* vm_handle, const char* name, const char* message) { bool pkpy_error(pkpy_vm* vm_handle, const char* name, pkpy_CString message) {
VM* vm = (VM*) vm_handle; VM* vm = (VM*) vm_handle;
PK_ASSERT_NO_ERROR() PK_ASSERT_NO_ERROR()
vm->_c.error = py_var(vm, Exception(name, message)); vm->_c.error = py_var(vm, Exception(name, Str(message.data, message.size)));
return false; return false;
} }
@ -494,6 +496,14 @@ pkpy_CName pkpy_name(const char* name){
return StrName(name).index; return StrName(name).index;
} }
pkpy_CString pkpy_name_to_string(pkpy_CName name){
std::string_view sv = StrName(name).sv();
pkpy_CString s;
s.data = sv.data();
s.size = sv.size();
return s;
}
void pkpy_compile_to_string(pkpy_vm* vm_handle, const char* source, const char* filename, int mode, bool* ok, char** out){ void pkpy_compile_to_string(pkpy_vm* vm_handle, const char* source, const char* filename, int mode, bool* ok, char** out){
VM* vm = (VM*) vm_handle; VM* vm = (VM*) vm_handle;
try{ try{