mirror of
https://github.com/pocketpy/pocketpy
synced 2026-02-20 14:30:17 +00:00
some fix
This commit is contained in:
blueloveTH
parent
275f958cfc
commit
c55dcd9ab8
76
.github/workflows/numpy.yml
vendored
76
.github/workflows/numpy.yml
vendored
@ -1,76 +0,0 @@
|
||||
name: numpy Build and Test
|
||||
|
||||
on:
|
||||
push:
|
||||
paths-ignore:
|
||||
- 'docs/**'
|
||||
- 'web/**'
|
||||
- '**.md'
|
||||
pull_request:
|
||||
paths-ignore:
|
||||
- 'docs/**'
|
||||
- 'web/**'
|
||||
- '**.md'
|
||||
|
||||
jobs:
|
||||
build_linux:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout code
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Set up GCC
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y gcc g++
|
||||
|
||||
- name: Set up CMake
|
||||
uses: jwlawson/actions-setup-cmake@v1.10
|
||||
|
||||
- name: Test
|
||||
run: |
|
||||
cd 3rd/numpy/tests
|
||||
cmake -B build
|
||||
cmake --build build --config Release --parallel
|
||||
./build/numpy_bindings
|
||||
|
||||
build_mac:
|
||||
runs-on: macos-latest
|
||||
steps:
|
||||
- name: Checkout code
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Set up Clang
|
||||
run: |
|
||||
brew install llvm
|
||||
echo 'export PATH="/usr/local/opt/llvm/bin:$PATH"' >> ~/.zshrc
|
||||
source ~/.zshrc
|
||||
|
||||
- name: Set up CMake
|
||||
uses: jwlawson/actions-setup-cmake@v1.10
|
||||
|
||||
- name: Test
|
||||
run: |
|
||||
cd 3rd/numpy/tests
|
||||
cmake -B build -DENABLE_TEST=ON
|
||||
cmake --build build --config Release --parallel
|
||||
./build/numpy_bindings
|
||||
|
||||
build_windows:
|
||||
runs-on: windows-latest
|
||||
steps:
|
||||
- name: Checkout code
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Set up MSVC
|
||||
uses: ilammy/msvc-dev-cmd@v1
|
||||
|
||||
- name: Set up CMake
|
||||
uses: jwlawson/actions-setup-cmake@v1.10
|
||||
|
||||
- name: Test
|
||||
run: |
|
||||
cd 3rd\numpy\tests
|
||||
cmake -B build
|
||||
cmake --build build --config Release --parallel
|
||||
build\Release\numpy_bindings.exe
|
||||
@ -2,16 +2,18 @@
|
||||
|
||||
// clang-format off
|
||||
|
||||
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
|
||||
#if defined(_WIN32) || defined(_WIN64)
|
||||
// define something for Windows (32-bit and 64-bit, this part is common)
|
||||
#ifdef PY_DYNAMIC_MODULE
|
||||
#define PK_EXPORT __declspec(dllimport)
|
||||
#define PK_API __declspec(dllimport)
|
||||
#else
|
||||
#define PK_EXPORT __declspec(dllexport)
|
||||
#define PK_API __declspec(dllexport)
|
||||
#endif
|
||||
#define PK_EXPORT __declspec(dllexport)
|
||||
#define PY_SYS_PLATFORM 0
|
||||
#define PY_SYS_PLATFORM_STRING "win32"
|
||||
#elif __EMSCRIPTEN__
|
||||
#define PK_API
|
||||
#define PK_EXPORT
|
||||
#define PY_SYS_PLATFORM 1
|
||||
#define PY_SYS_PLATFORM_STRING "emscripten"
|
||||
@ -31,17 +33,20 @@
|
||||
#else
|
||||
# error "Unknown Apple platform"
|
||||
#endif
|
||||
#define PK_API __attribute__((visibility("default")))
|
||||
#define PK_EXPORT __attribute__((visibility("default")))
|
||||
#elif __ANDROID__
|
||||
#define PK_API __attribute__((visibility("default")))
|
||||
#define PK_EXPORT __attribute__((visibility("default")))
|
||||
#define PY_SYS_PLATFORM 4
|
||||
#define PY_SYS_PLATFORM_STRING "android"
|
||||
#elif __linux__
|
||||
#define PK_API __attribute__((visibility("default")))
|
||||
#define PK_EXPORT __attribute__((visibility("default")))
|
||||
#define PY_SYS_PLATFORM 5
|
||||
#define PY_SYS_PLATFORM_STRING "linux"
|
||||
#else
|
||||
#define PK_EXPORT
|
||||
#define PK_API
|
||||
#define PY_SYS_PLATFORM 6
|
||||
#define PY_SYS_PLATFORM_STRING "unknown"
|
||||
#endif
|
||||
|
||||
@ -73,24 +73,24 @@ enum py_CompileMode { EXEC_MODE, EVAL_MODE, SINGLE_MODE };
|
||||
/************* Global Setup *************/
|
||||
|
||||
/// Initialize pocketpy and the default VM.
|
||||
PK_EXPORT void py_initialize();
|
||||
PK_API void py_initialize();
|
||||
/// Finalize pocketpy and free all VMs.
|
||||
PK_EXPORT void py_finalize();
|
||||
PK_API void py_finalize();
|
||||
/// Get the current VM index.
|
||||
PK_EXPORT int py_currentvm();
|
||||
PK_API int py_currentvm();
|
||||
/// Switch to a VM.
|
||||
/// @param index index of the VM ranging from 0 to 16 (exclusive). `0` is the default VM.
|
||||
PK_EXPORT void py_switchvm(int index);
|
||||
PK_API void py_switchvm(int index);
|
||||
/// Reset the current VM.
|
||||
PK_EXPORT void py_resetvm();
|
||||
PK_API void py_resetvm();
|
||||
/// Get the current VM context. This is used for user-defined data.
|
||||
PK_EXPORT void* py_getvmctx();
|
||||
PK_API void* py_getvmctx();
|
||||
/// Set the current VM context. This is used for user-defined data.
|
||||
PK_EXPORT void py_setvmctx(void* ctx);
|
||||
PK_API void py_setvmctx(void* ctx);
|
||||
/// Set `sys.argv`. Used for storing command-line arguments.
|
||||
PK_EXPORT void py_sys_setargv(int argc, char** argv);
|
||||
PK_API void py_sys_setargv(int argc, char** argv);
|
||||
/// Setup the callbacks for the current VM.
|
||||
PK_EXPORT py_Callbacks* py_callbacks();
|
||||
PK_API py_Callbacks* py_callbacks();
|
||||
|
||||
/// Run a source string.
|
||||
/// @param source source string.
|
||||
@ -98,13 +98,13 @@ PK_EXPORT py_Callbacks* py_callbacks();
|
||||
/// @param mode compile mode. Use `EXEC_MODE` for statements `EVAL_MODE` for expressions.
|
||||
/// @param module target module. Use NULL for the main module.
|
||||
/// @return `true` if the execution is successful or `false` if an exception is raised.
|
||||
PK_EXPORT bool py_exec(const char* source,
|
||||
PK_API bool py_exec(const char* source,
|
||||
const char* filename,
|
||||
enum py_CompileMode mode,
|
||||
py_Ref module) PY_RAISE PY_RETURN;
|
||||
|
||||
/// Evaluate a source string. Equivalent to `py_exec(source, "<string>", EVAL_MODE, module)`.
|
||||
PK_EXPORT bool py_eval(const char* source, py_Ref module) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_eval(const char* source, py_Ref module) PY_RAISE PY_RETURN;
|
||||
|
||||
/// Run a source string with smart interpretation.
|
||||
/// Example:
|
||||
@ -112,96 +112,96 @@ PK_EXPORT bool py_eval(const char* source, py_Ref module) PY_RAISE PY_RETURN;
|
||||
/// `py_newint(py_r1(), 123);`
|
||||
/// `py_smartexec("print(_0, _1)", NULL, py_r0(), py_r1());`
|
||||
/// `// "abc 123" will be printed`.
|
||||
PK_EXPORT bool py_smartexec(const char* source, py_Ref module, ...) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_smartexec(const char* source, py_Ref module, ...) PY_RAISE PY_RETURN;
|
||||
/// Evaluate a source string with smart interpretation.
|
||||
/// Example:
|
||||
/// `py_newstr(py_r0(), "abc");`
|
||||
/// `py_smarteval("len(_)", NULL, py_r0());`
|
||||
/// `int res = py_toint(py_retval());`
|
||||
/// `// res will be 3`.
|
||||
PK_EXPORT bool py_smarteval(const char* source, py_Ref module, ...) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_smarteval(const char* source, py_Ref module, ...) PY_RAISE PY_RETURN;
|
||||
|
||||
/// Compile a source string into a code object.
|
||||
/// Use python's `exec()` or `eval()` to execute it.
|
||||
PK_EXPORT bool py_compile(const char* source,
|
||||
PK_API bool py_compile(const char* source,
|
||||
const char* filename,
|
||||
enum py_CompileMode mode,
|
||||
bool is_dynamic) PY_RAISE PY_RETURN;
|
||||
|
||||
/// Python equivalent to `globals()`.
|
||||
PK_EXPORT void py_newglobals(py_OutRef);
|
||||
PK_API void py_newglobals(py_OutRef);
|
||||
/// Python equivalent to `locals()`.
|
||||
/// @return a temporary object, which expires on the associated function return.
|
||||
PK_EXPORT void py_newlocals(py_OutRef);
|
||||
PK_API void py_newlocals(py_OutRef);
|
||||
|
||||
/************* Values Creation *************/
|
||||
|
||||
/// A shorthand for `True`.
|
||||
PK_EXPORT py_GlobalRef py_True();
|
||||
PK_API py_GlobalRef py_True();
|
||||
/// A shorthand for `False`.
|
||||
PK_EXPORT py_GlobalRef py_False();
|
||||
PK_API py_GlobalRef py_False();
|
||||
/// A shorthand for `None`.
|
||||
PK_EXPORT py_GlobalRef py_None();
|
||||
PK_API py_GlobalRef py_None();
|
||||
/// A shorthand for `nil`. `nil` is not a valid python object.
|
||||
PK_EXPORT py_GlobalRef py_NIL();
|
||||
PK_API py_GlobalRef py_NIL();
|
||||
|
||||
/// Create an `int` object.
|
||||
PK_EXPORT void py_newint(py_OutRef, py_i64);
|
||||
PK_API void py_newint(py_OutRef, py_i64);
|
||||
/// Create a `float` object.
|
||||
PK_EXPORT void py_newfloat(py_OutRef, py_f64);
|
||||
PK_API void py_newfloat(py_OutRef, py_f64);
|
||||
/// Create a `bool` object.
|
||||
PK_EXPORT void py_newbool(py_OutRef, bool);
|
||||
PK_API void py_newbool(py_OutRef, bool);
|
||||
/// Create a `str` object from a null-terminated string (utf-8).
|
||||
PK_EXPORT void py_newstr(py_OutRef, const char*);
|
||||
PK_API void py_newstr(py_OutRef, const char*);
|
||||
/// Create a `str` object with `n` UNINITIALIZED bytes plus `'\0'`.
|
||||
PK_EXPORT char* py_newstrn(py_OutRef, int);
|
||||
PK_API char* py_newstrn(py_OutRef, int);
|
||||
/// Create a `str` object from a `c11_sv`.
|
||||
PK_EXPORT void py_newstrv(py_OutRef, c11_sv);
|
||||
PK_API void py_newstrv(py_OutRef, c11_sv);
|
||||
/// Create a `bytes` object with `n` UNINITIALIZED bytes.
|
||||
PK_EXPORT unsigned char* py_newbytes(py_OutRef, int n);
|
||||
PK_API unsigned char* py_newbytes(py_OutRef, int n);
|
||||
/// Create a `None` object.
|
||||
PK_EXPORT void py_newnone(py_OutRef);
|
||||
PK_API void py_newnone(py_OutRef);
|
||||
/// Create a `NotImplemented` object.
|
||||
PK_EXPORT void py_newnotimplemented(py_OutRef);
|
||||
PK_API void py_newnotimplemented(py_OutRef);
|
||||
/// Create a `...` object.
|
||||
PK_EXPORT void py_newellipsis(py_OutRef);
|
||||
PK_API void py_newellipsis(py_OutRef);
|
||||
/// Create a `nil` object. `nil` is an invalid representation of an object.
|
||||
/// Don't use it unless you know what you are doing.
|
||||
PK_EXPORT void py_newnil(py_OutRef);
|
||||
PK_API void py_newnil(py_OutRef);
|
||||
/// Create a `tuple` with `n` UNINITIALIZED elements.
|
||||
/// You should initialize all elements before using it.
|
||||
PK_EXPORT void py_newtuple(py_OutRef, int n);
|
||||
PK_API void py_newtuple(py_OutRef, int n);
|
||||
/// Create an empty `list`.
|
||||
PK_EXPORT void py_newlist(py_OutRef);
|
||||
PK_API void py_newlist(py_OutRef);
|
||||
/// Create a `list` with `n` UNINITIALIZED elements.
|
||||
/// You should initialize all elements before using it.
|
||||
PK_EXPORT void py_newlistn(py_OutRef, int n);
|
||||
PK_API void py_newlistn(py_OutRef, int n);
|
||||
/// Create an empty `dict`.
|
||||
PK_EXPORT void py_newdict(py_OutRef);
|
||||
PK_API void py_newdict(py_OutRef);
|
||||
/// Create an UNINITIALIZED `slice` object.
|
||||
/// You should use `py_setslot()` to set `start`, `stop`, and `step`.
|
||||
PK_EXPORT void py_newslice(py_OutRef);
|
||||
PK_API void py_newslice(py_OutRef);
|
||||
/// Create a `nativefunc` object.
|
||||
PK_EXPORT void py_newnativefunc(py_OutRef, py_CFunction);
|
||||
PK_API void py_newnativefunc(py_OutRef, py_CFunction);
|
||||
/// Create a `function` object.
|
||||
PK_EXPORT py_Name py_newfunction(py_OutRef out,
|
||||
PK_API py_Name py_newfunction(py_OutRef out,
|
||||
const char* sig,
|
||||
py_CFunction f,
|
||||
const char* docstring,
|
||||
int slots);
|
||||
/// Create a `boundmethod` object.
|
||||
PK_EXPORT void py_newboundmethod(py_OutRef out, py_Ref self, py_Ref func);
|
||||
PK_API void py_newboundmethod(py_OutRef out, py_Ref self, py_Ref func);
|
||||
|
||||
/************* Name Convertions *************/
|
||||
|
||||
/// Convert a null-terminated string to a name.
|
||||
PK_EXPORT py_Name py_name(const char*);
|
||||
PK_API py_Name py_name(const char*);
|
||||
/// Convert a name to a null-terminated string.
|
||||
PK_EXPORT const char* py_name2str(py_Name);
|
||||
PK_API const char* py_name2str(py_Name);
|
||||
/// Convert a `c11_sv` to a name.
|
||||
PK_EXPORT py_Name py_namev(c11_sv);
|
||||
PK_API py_Name py_namev(c11_sv);
|
||||
/// Convert a name to a `c11_sv`.
|
||||
PK_EXPORT c11_sv py_name2sv(py_Name);
|
||||
PK_API c11_sv py_name2sv(py_Name);
|
||||
|
||||
#define py_ismagicname(name) (name <= __missing__)
|
||||
|
||||
@ -212,7 +212,7 @@ PK_EXPORT c11_sv py_name2sv(py_Name);
|
||||
/// @param base base type.
|
||||
/// @param module module where the type is defined. Use `NULL` for built-in types.
|
||||
/// @param dtor destructor function. Use `NULL` if not needed.
|
||||
PK_EXPORT py_Type py_newtype(const char* name,
|
||||
PK_API py_Type py_newtype(const char* name,
|
||||
py_Type base,
|
||||
const py_GlobalRef module,
|
||||
py_Dtor dtor);
|
||||
@ -223,36 +223,36 @@ PK_EXPORT py_Type py_newtype(const char* name,
|
||||
/// @param slots number of slots. Use `-1` to create a `__dict__`.
|
||||
/// @param udsize size of your userdata.
|
||||
/// @return pointer to the userdata.
|
||||
PK_EXPORT void* py_newobject(py_OutRef out, py_Type type, int slots, int udsize);
|
||||
PK_API void* py_newobject(py_OutRef out, py_Type type, int slots, int udsize);
|
||||
|
||||
/************* Type Cast *************/
|
||||
|
||||
/// Convert an `int` object in python to `int64_t`.
|
||||
PK_EXPORT py_i64 py_toint(py_Ref);
|
||||
PK_API py_i64 py_toint(py_Ref);
|
||||
/// Convert a `float` object in python to `double`.
|
||||
PK_EXPORT py_f64 py_tofloat(py_Ref);
|
||||
PK_API py_f64 py_tofloat(py_Ref);
|
||||
/// Cast a `int` or `float` object in python to `double`.
|
||||
/// If successful, return true and set the value to `out`.
|
||||
/// Otherwise, return false and raise `TypeError`.
|
||||
PK_EXPORT bool py_castfloat(py_Ref, py_f64* out) PY_RAISE;
|
||||
PK_API bool py_castfloat(py_Ref, py_f64* out) PY_RAISE;
|
||||
/// 32-bit version of `py_castfloat`.
|
||||
PK_EXPORT bool py_castfloat32(py_Ref, float* out) PY_RAISE;
|
||||
PK_API bool py_castfloat32(py_Ref, float* out) PY_RAISE;
|
||||
/// Cast a `int` object in python to `int64_t`.
|
||||
PK_EXPORT bool py_castint(py_Ref, py_i64* out) PY_RAISE;
|
||||
PK_API bool py_castint(py_Ref, py_i64* out) PY_RAISE;
|
||||
/// Convert a `bool` object in python to `bool`.
|
||||
PK_EXPORT bool py_tobool(py_Ref);
|
||||
PK_API bool py_tobool(py_Ref);
|
||||
/// Convert a `type` object in python to `py_Type`.
|
||||
PK_EXPORT py_Type py_totype(py_Ref);
|
||||
PK_API py_Type py_totype(py_Ref);
|
||||
/// Convert a `str` object in python to null-terminated string.
|
||||
PK_EXPORT const char* py_tostr(py_Ref);
|
||||
PK_API const char* py_tostr(py_Ref);
|
||||
/// Convert a `str` object in python to char array.
|
||||
PK_EXPORT const char* py_tostrn(py_Ref, int* size);
|
||||
PK_API const char* py_tostrn(py_Ref, int* size);
|
||||
/// Convert a `str` object in python to `c11_sv`.
|
||||
PK_EXPORT c11_sv py_tosv(py_Ref);
|
||||
PK_API c11_sv py_tosv(py_Ref);
|
||||
/// Convert a `bytes` object in python to char array.
|
||||
PK_EXPORT unsigned char* py_tobytes(py_Ref, int* size);
|
||||
PK_API unsigned char* py_tobytes(py_Ref, int* size);
|
||||
/// Convert a user-defined object to its userdata.
|
||||
PK_EXPORT void* py_touserdata(py_Ref);
|
||||
PK_API void* py_touserdata(py_Ref);
|
||||
|
||||
#define py_isint(self) py_istype(self, tp_int)
|
||||
#define py_isfloat(self) py_istype(self, tp_float)
|
||||
@ -266,37 +266,37 @@ PK_EXPORT void* py_touserdata(py_Ref);
|
||||
#define py_isnone(self) py_istype(self, tp_NoneType)
|
||||
|
||||
/// Get the type of the object.
|
||||
PK_EXPORT py_Type py_typeof(py_Ref self);
|
||||
PK_API py_Type py_typeof(py_Ref self);
|
||||
/// Get type by module and name. e.g. `py_gettype("time", py_name("struct_time"))`.
|
||||
/// Return `0` if not found.
|
||||
PK_EXPORT py_Type py_gettype(const char* module, py_Name name);
|
||||
PK_API py_Type py_gettype(const char* module, py_Name name);
|
||||
/// Check if the object is exactly the given type.
|
||||
PK_EXPORT bool py_istype(py_Ref, py_Type);
|
||||
PK_API bool py_istype(py_Ref, py_Type);
|
||||
/// Check if the object is an instance of the given type.
|
||||
PK_EXPORT bool py_isinstance(py_Ref obj, py_Type type);
|
||||
PK_API bool py_isinstance(py_Ref obj, py_Type type);
|
||||
/// Check if the derived type is a subclass of the base type.
|
||||
PK_EXPORT bool py_issubclass(py_Type derived, py_Type base);
|
||||
PK_API bool py_issubclass(py_Type derived, py_Type base);
|
||||
|
||||
/// Get the magic method from the given type only.
|
||||
/// The returned reference is always valid. However, its value may be `nil`.
|
||||
PK_EXPORT py_GlobalRef py_tpgetmagic(py_Type type, py_Name name);
|
||||
PK_API py_GlobalRef py_tpgetmagic(py_Type type, py_Name name);
|
||||
/// Search the magic method from the given type to the base type.
|
||||
/// Return `NULL` if not found.
|
||||
PK_EXPORT py_GlobalRef py_tpfindmagic(py_Type, py_Name name);
|
||||
PK_API py_GlobalRef py_tpfindmagic(py_Type, py_Name name);
|
||||
/// Search the name from the given type to the base type.
|
||||
/// Return `NULL` if not found.
|
||||
PK_EXPORT py_ItemRef py_tpfindname(py_Type, py_Name name);
|
||||
PK_API py_ItemRef py_tpfindname(py_Type, py_Name name);
|
||||
|
||||
/// Get the type object of the given type.
|
||||
PK_EXPORT py_GlobalRef py_tpobject(py_Type type);
|
||||
PK_API py_GlobalRef py_tpobject(py_Type type);
|
||||
/// Get the type name.
|
||||
PK_EXPORT const char* py_tpname(py_Type type);
|
||||
PK_API const char* py_tpname(py_Type type);
|
||||
/// Call a type to create a new instance.
|
||||
PK_EXPORT bool py_tpcall(py_Type type, int argc, py_Ref argv) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_tpcall(py_Type type, int argc, py_Ref argv) PY_RAISE PY_RETURN;
|
||||
|
||||
/// Check if the object is an instance of the given type.
|
||||
/// Raise `TypeError` if the check fails.
|
||||
PK_EXPORT bool py_checktype(py_Ref self, py_Type type) PY_RAISE;
|
||||
PK_API bool py_checktype(py_Ref self, py_Type type) PY_RAISE;
|
||||
|
||||
#define py_checkint(self) py_checktype(self, tp_int)
|
||||
#define py_checkfloat(self) py_checktype(self, tp_float)
|
||||
@ -307,9 +307,9 @@ PK_EXPORT bool py_checktype(py_Ref self, py_Type type) PY_RAISE;
|
||||
|
||||
/// Get the i-th register.
|
||||
/// All registers are located in a contiguous memory.
|
||||
PK_EXPORT py_GlobalRef py_getreg(int i);
|
||||
PK_API py_GlobalRef py_getreg(int i);
|
||||
/// Set the i-th register.
|
||||
PK_EXPORT void py_setreg(int i, py_Ref val);
|
||||
PK_API void py_setreg(int i, py_Ref val);
|
||||
|
||||
#define py_r0() py_getreg(0)
|
||||
#define py_r1() py_getreg(1)
|
||||
@ -321,48 +321,48 @@ PK_EXPORT void py_setreg(int i, py_Ref val);
|
||||
#define py_r7() py_getreg(7)
|
||||
|
||||
/// Get variable in the `__main__` module.
|
||||
PK_EXPORT py_ItemRef py_getglobal(py_Name name);
|
||||
PK_API py_ItemRef py_getglobal(py_Name name);
|
||||
/// Set variable in the `__main__` module.
|
||||
PK_EXPORT void py_setglobal(py_Name name, py_Ref val);
|
||||
PK_API void py_setglobal(py_Name name, py_Ref val);
|
||||
/// Get variable in the `builtins` module.
|
||||
PK_EXPORT py_ItemRef py_getbuiltin(py_Name name);
|
||||
PK_API py_ItemRef py_getbuiltin(py_Name name);
|
||||
|
||||
/// Equivalent to `*dst = *src`.
|
||||
PK_EXPORT void py_assign(py_Ref dst, py_Ref src);
|
||||
PK_API void py_assign(py_Ref dst, py_Ref src);
|
||||
/// Get the last return value.
|
||||
PK_EXPORT py_GlobalRef py_retval();
|
||||
PK_API py_GlobalRef py_retval();
|
||||
|
||||
/// Get an item from the object's `__dict__`.
|
||||
/// Return `NULL` if not found.
|
||||
PK_EXPORT py_ItemRef py_getdict(py_Ref self, py_Name name);
|
||||
PK_API py_ItemRef py_getdict(py_Ref self, py_Name name);
|
||||
/// Set an item to the object's `__dict__`.
|
||||
PK_EXPORT void py_setdict(py_Ref self, py_Name name, py_Ref val);
|
||||
PK_API void py_setdict(py_Ref self, py_Name name, py_Ref val);
|
||||
/// Delete an item from the object's `__dict__`.
|
||||
/// Return `true` if the deletion is successful.
|
||||
PK_EXPORT bool py_deldict(py_Ref self, py_Name name);
|
||||
PK_API bool py_deldict(py_Ref self, py_Name name);
|
||||
/// Prepare an insertion to the object's `__dict__`.
|
||||
PK_EXPORT py_ItemRef py_emplacedict(py_Ref self, py_Name name);
|
||||
PK_API py_ItemRef py_emplacedict(py_Ref self, py_Name name);
|
||||
/// Apply a function to all items in the object's `__dict__`.
|
||||
/// Return `true` if the function is successful for all items.
|
||||
/// NOTE: Be careful if `f` modifies the object's `__dict__`.
|
||||
PK_EXPORT bool
|
||||
PK_API bool
|
||||
py_applydict(py_Ref self, bool (*f)(py_Name name, py_Ref val, void* ctx), void* ctx) PY_RAISE;
|
||||
|
||||
/// Get the i-th slot of the object.
|
||||
/// The object must have slots and `i` must be in valid range.
|
||||
PK_EXPORT py_ObjectRef py_getslot(py_Ref self, int i);
|
||||
PK_API py_ObjectRef py_getslot(py_Ref self, int i);
|
||||
/// Set the i-th slot of the object.
|
||||
PK_EXPORT void py_setslot(py_Ref self, int i, py_Ref val);
|
||||
PK_API void py_setslot(py_Ref self, int i, py_Ref val);
|
||||
|
||||
/************* Inspection *************/
|
||||
|
||||
/// Get the current `function` object on the stack.
|
||||
/// Return `NULL` if not available.
|
||||
/// NOTE: This function should be placed at the beginning of your decl-based bindings.
|
||||
PK_EXPORT py_StackRef py_inspect_currentfunction();
|
||||
PK_API py_StackRef py_inspect_currentfunction();
|
||||
/// Get the current `module` object where the code is executed.
|
||||
/// Return `NULL` if not available.
|
||||
PK_EXPORT py_GlobalRef py_inspect_currentmodule();
|
||||
PK_API py_GlobalRef py_inspect_currentmodule();
|
||||
|
||||
/************* Bindings *************/
|
||||
|
||||
@ -370,23 +370,23 @@ PK_EXPORT py_GlobalRef py_inspect_currentmodule();
|
||||
/// @param obj the target object.
|
||||
/// @param sig signature of the function. e.g. `add(x, y)`.
|
||||
/// @param f function to bind.
|
||||
PK_EXPORT void py_bind(py_Ref obj, const char* sig, py_CFunction f);
|
||||
PK_API void py_bind(py_Ref obj, const char* sig, py_CFunction f);
|
||||
/// Bind a method to type via "argc-based" style.
|
||||
/// @param type the target type.
|
||||
/// @param name name of the method.
|
||||
/// @param f function to bind.
|
||||
PK_EXPORT void py_bindmethod(py_Type type, const char* name, py_CFunction f);
|
||||
PK_API void py_bindmethod(py_Type type, const char* name, py_CFunction f);
|
||||
/// Bind a function to the object via "argc-based" style.
|
||||
/// @param obj the target object.
|
||||
/// @param name name of the function.
|
||||
/// @param f function to bind.
|
||||
PK_EXPORT void py_bindfunc(py_Ref obj, const char* name, py_CFunction f);
|
||||
PK_API void py_bindfunc(py_Ref obj, const char* name, py_CFunction f);
|
||||
/// Bind a property to type.
|
||||
/// @param type the target type.
|
||||
/// @param name name of the property.
|
||||
/// @param getter getter function.
|
||||
/// @param setter setter function. Use `NULL` if not needed.
|
||||
PK_EXPORT void
|
||||
PK_API void
|
||||
py_bindproperty(py_Type type, const char* name, py_CFunction getter, py_CFunction setter);
|
||||
|
||||
#define py_bindmagic(type, __magic__, f) py_newnativefunc(py_tpgetmagic((type), __magic__), (f))
|
||||
@ -403,22 +403,22 @@ PK_EXPORT void
|
||||
/************* Python Equivalents *************/
|
||||
|
||||
/// Python equivalent to `getattr(self, name)`.
|
||||
PK_EXPORT bool py_getattr(py_Ref self, py_Name name) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_getattr(py_Ref self, py_Name name) PY_RAISE PY_RETURN;
|
||||
/// Python equivalent to `setattr(self, name, val)`.
|
||||
PK_EXPORT bool py_setattr(py_Ref self, py_Name name, py_Ref val) PY_RAISE;
|
||||
PK_API bool py_setattr(py_Ref self, py_Name name, py_Ref val) PY_RAISE;
|
||||
/// Python equivalent to `delattr(self, name)`.
|
||||
PK_EXPORT bool py_delattr(py_Ref self, py_Name name) PY_RAISE;
|
||||
PK_API bool py_delattr(py_Ref self, py_Name name) PY_RAISE;
|
||||
/// Python equivalent to `self[key]`.
|
||||
PK_EXPORT bool py_getitem(py_Ref self, py_Ref key) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_getitem(py_Ref self, py_Ref key) PY_RAISE PY_RETURN;
|
||||
/// Python equivalent to `self[key] = val`.
|
||||
PK_EXPORT bool py_setitem(py_Ref self, py_Ref key, py_Ref val) PY_RAISE;
|
||||
PK_API bool py_setitem(py_Ref self, py_Ref key, py_Ref val) PY_RAISE;
|
||||
/// Python equivalent to `del self[key]`.
|
||||
PK_EXPORT bool py_delitem(py_Ref self, py_Ref key) PY_RAISE;
|
||||
PK_API bool py_delitem(py_Ref self, py_Ref key) PY_RAISE;
|
||||
|
||||
/// Perform a binary operation.
|
||||
/// The result will be set to `py_retval()`.
|
||||
/// The stack remains unchanged after the operation.
|
||||
PK_EXPORT bool py_binaryop(py_Ref lhs, py_Ref rhs, py_Name op, py_Name rop) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_binaryop(py_Ref lhs, py_Ref rhs, py_Name op, py_Name rop) PY_RAISE PY_RETURN;
|
||||
|
||||
#define py_binaryadd(lhs, rhs) py_binaryop(lhs, rhs, __add__, __radd__)
|
||||
#define py_binarysub(lhs, rhs) py_binaryop(lhs, rhs, __sub__, __rsub__)
|
||||
@ -439,69 +439,69 @@ PK_EXPORT bool py_binaryop(py_Ref lhs, py_Ref rhs, py_Name op, py_Name rop) PY_R
|
||||
|
||||
/// Get the i-th object from the top of the stack.
|
||||
/// `i` should be negative, e.g. (-1) means TOS.
|
||||
PK_EXPORT py_StackRef py_peek(int i);
|
||||
PK_API py_StackRef py_peek(int i);
|
||||
/// Push the object to the stack.
|
||||
PK_EXPORT void py_push(py_Ref src);
|
||||
PK_API void py_push(py_Ref src);
|
||||
/// Push a `nil` object to the stack.
|
||||
PK_EXPORT void py_pushnil();
|
||||
PK_API void py_pushnil();
|
||||
/// Push a `None` object to the stack.
|
||||
PK_EXPORT void py_pushnone();
|
||||
PK_API void py_pushnone();
|
||||
/// Push a `py_Name` to the stack. This is used for keyword arguments.
|
||||
PK_EXPORT void py_pushname(py_Name name);
|
||||
PK_API void py_pushname(py_Name name);
|
||||
/// Pop an object from the stack.
|
||||
PK_EXPORT void py_pop();
|
||||
PK_API void py_pop();
|
||||
/// Shrink the stack by n.
|
||||
PK_EXPORT void py_shrink(int n);
|
||||
PK_API void py_shrink(int n);
|
||||
/// Get a temporary variable from the stack.
|
||||
PK_EXPORT py_StackRef py_pushtmp();
|
||||
PK_API py_StackRef py_pushtmp();
|
||||
/// Get the unbound method of the object.
|
||||
/// Assume the object is located at the top of the stack.
|
||||
/// If return true: `[self] -> [unbound, self]`.
|
||||
/// If return false: `[self] -> [self]` (no change).
|
||||
PK_EXPORT bool py_pushmethod(py_Name name);
|
||||
PK_API bool py_pushmethod(py_Name name);
|
||||
/// Call a callable object.
|
||||
/// Assume `argc + kwargc` arguments are already pushed to the stack.
|
||||
/// The result will be set to `py_retval()`.
|
||||
/// The stack size will be reduced by `argc + kwargc`.
|
||||
PK_EXPORT bool py_vectorcall(uint16_t argc, uint16_t kwargc) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_vectorcall(uint16_t argc, uint16_t kwargc) PY_RAISE PY_RETURN;
|
||||
/// Evaluate an expression and push the result to the stack.
|
||||
/// This function is used for testing.
|
||||
PK_EXPORT bool py_pusheval(const char* expr, py_GlobalRef module) PY_RAISE;
|
||||
PK_API bool py_pusheval(const char* expr, py_GlobalRef module) PY_RAISE;
|
||||
|
||||
/************* Modules *************/
|
||||
|
||||
/// Create a new module.
|
||||
PK_EXPORT py_GlobalRef py_newmodule(const char* path);
|
||||
PK_API py_GlobalRef py_newmodule(const char* path);
|
||||
/// Get a module by path.
|
||||
PK_EXPORT py_GlobalRef py_getmodule(const char* path);
|
||||
PK_API py_GlobalRef py_getmodule(const char* path);
|
||||
|
||||
/// Import a module.
|
||||
/// The result will be set to `py_retval()`.
|
||||
/// -1: error, 0: not found, 1: success
|
||||
PK_EXPORT int py_import(const char* path) PY_RAISE;
|
||||
PK_API int py_import(const char* path) PY_RAISE;
|
||||
|
||||
/************* Errors *************/
|
||||
|
||||
/// Raise an exception by type and message. Always return false.
|
||||
PK_EXPORT bool py_exception(py_Type type, const char* fmt, ...) PY_RAISE;
|
||||
PK_API bool py_exception(py_Type type, const char* fmt, ...) PY_RAISE;
|
||||
/// Raise an expection object. Always return false.
|
||||
PK_EXPORT bool py_raise(py_Ref) PY_RAISE;
|
||||
PK_API bool py_raise(py_Ref) PY_RAISE;
|
||||
/// Print the current exception.
|
||||
/// The exception will be set as handled.
|
||||
PK_EXPORT void py_printexc();
|
||||
PK_API void py_printexc();
|
||||
/// Format the current exception and return a null-terminated string.
|
||||
/// The result should be freed by the caller.
|
||||
/// The exception will be set as handled.
|
||||
PK_EXPORT char* py_formatexc();
|
||||
PK_API char* py_formatexc();
|
||||
/// Check if an exception is raised.
|
||||
PK_EXPORT bool py_checkexc(bool ignore_handled);
|
||||
PK_API bool py_checkexc(bool ignore_handled);
|
||||
/// Check if the exception is an instance of the given type.
|
||||
/// This function is roughly equivalent to python's `except <T> as e:` block.
|
||||
/// If match, the exception will be stored in `py_retval()` as handled.
|
||||
PK_EXPORT bool py_matchexc(py_Type type) PY_RETURN;
|
||||
PK_API bool py_matchexc(py_Type type) PY_RETURN;
|
||||
/// Clear the current exception.
|
||||
/// @param p0 the unwinding point. Use `NULL` if not needed.
|
||||
PK_EXPORT void py_clearexc(py_StackRef p0);
|
||||
PK_API void py_clearexc(py_StackRef p0);
|
||||
|
||||
#define NameError(n) py_exception(tp_NameError, "name '%n' is not defined", (n))
|
||||
#define TypeError(...) py_exception(tp_TypeError, __VA_ARGS__)
|
||||
@ -516,20 +516,20 @@ PK_EXPORT void py_clearexc(py_StackRef p0);
|
||||
#define UnboundLocalError(n) \
|
||||
py_exception(tp_UnboundLocalError, "local variable '%n' referenced before assignment", (n))
|
||||
|
||||
PK_EXPORT bool StopIteration() PY_RAISE;
|
||||
PK_EXPORT bool KeyError(py_Ref key) PY_RAISE;
|
||||
PK_API bool StopIteration() PY_RAISE;
|
||||
PK_API bool KeyError(py_Ref key) PY_RAISE;
|
||||
|
||||
/************* Operators *************/
|
||||
|
||||
/// Python equivalent to `bool(val)`.
|
||||
/// 1: true, 0: false, -1: error
|
||||
PK_EXPORT int py_bool(py_Ref val) PY_RAISE;
|
||||
PK_API int py_bool(py_Ref val) PY_RAISE;
|
||||
/// Compare two objects.
|
||||
/// 1: lhs == rhs, 0: lhs != rhs, -1: error
|
||||
PK_EXPORT int py_equal(py_Ref lhs, py_Ref rhs) PY_RAISE;
|
||||
PK_API int py_equal(py_Ref lhs, py_Ref rhs) PY_RAISE;
|
||||
/// Compare two objects.
|
||||
/// 1: lhs < rhs, 0: lhs >= rhs, -1: error
|
||||
PK_EXPORT int py_less(py_Ref lhs, py_Ref rhs) PY_RAISE;
|
||||
PK_API int py_less(py_Ref lhs, py_Ref rhs) PY_RAISE;
|
||||
|
||||
#define py_eq(lhs, rhs) py_binaryop(lhs, rhs, __eq__, __eq__)
|
||||
#define py_ne(lhs, rhs) py_binaryop(lhs, rhs, __ne__, __ne__)
|
||||
@ -539,76 +539,76 @@ PK_EXPORT int py_less(py_Ref lhs, py_Ref rhs) PY_RAISE;
|
||||
#define py_ge(lhs, rhs) py_binaryop(lhs, rhs, __ge__, __le__)
|
||||
|
||||
/// Python equivalent to `callable(val)`.
|
||||
PK_EXPORT bool py_callable(py_Ref val);
|
||||
PK_API bool py_callable(py_Ref val);
|
||||
/// Get the hash value of the object.
|
||||
PK_EXPORT bool py_hash(py_Ref, py_i64* out) PY_RAISE;
|
||||
PK_API bool py_hash(py_Ref, py_i64* out) PY_RAISE;
|
||||
/// Get the iterator of the object.
|
||||
PK_EXPORT bool py_iter(py_Ref) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_iter(py_Ref) PY_RAISE PY_RETURN;
|
||||
/// Get the next element from the iterator.
|
||||
/// 1: success, 0: StopIteration, -1: error
|
||||
PK_EXPORT int py_next(py_Ref) PY_RAISE PY_RETURN;
|
||||
PK_API int py_next(py_Ref) PY_RAISE PY_RETURN;
|
||||
/// Python equivalent to `lhs is rhs`.
|
||||
PK_EXPORT bool py_isidentical(py_Ref, py_Ref);
|
||||
PK_API bool py_isidentical(py_Ref, py_Ref);
|
||||
/// Call a function.
|
||||
/// It prepares the stack and then performs a `vectorcall(argc, 0, false)`.
|
||||
/// The result will be set to `py_retval()`.
|
||||
/// The stack remains unchanged after the operation.
|
||||
PK_EXPORT bool py_call(py_Ref f, int argc, py_Ref argv) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_call(py_Ref f, int argc, py_Ref argv) PY_RAISE PY_RETURN;
|
||||
|
||||
#ifndef NDEBUG
|
||||
/// Call a `py_CFunction` in a safe way.
|
||||
/// This function does extra checks to help you debug `py_CFunction`.
|
||||
PK_EXPORT bool py_callcfunc(py_CFunction f, int argc, py_Ref argv) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_callcfunc(py_CFunction f, int argc, py_Ref argv) PY_RAISE PY_RETURN;
|
||||
#else
|
||||
#define py_callcfunc(f, argc, argv) (f((argc), (argv)))
|
||||
#endif
|
||||
|
||||
/// Python equivalent to `str(val)`.
|
||||
PK_EXPORT bool py_str(py_Ref val) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_str(py_Ref val) PY_RAISE PY_RETURN;
|
||||
/// Python equivalent to `repr(val)`.
|
||||
PK_EXPORT bool py_repr(py_Ref val) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_repr(py_Ref val) PY_RAISE PY_RETURN;
|
||||
/// Python equivalent to `len(val)`.
|
||||
PK_EXPORT bool py_len(py_Ref val) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_len(py_Ref val) PY_RAISE PY_RETURN;
|
||||
/// Python equivalent to `json.dumps(val)`.
|
||||
PK_EXPORT bool py_json_dumps(py_Ref val) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_json_dumps(py_Ref val) PY_RAISE PY_RETURN;
|
||||
/// Python equivalent to `json.loads(val)`.
|
||||
PK_EXPORT bool py_json_loads(const char* source) PY_RAISE PY_RETURN;
|
||||
PK_API bool py_json_loads(const char* source) PY_RAISE PY_RETURN;
|
||||
|
||||
/************* Unchecked Functions *************/
|
||||
|
||||
PK_EXPORT py_ObjectRef py_tuple_data(py_Ref self);
|
||||
PK_EXPORT py_ObjectRef py_tuple_getitem(py_Ref self, int i);
|
||||
PK_EXPORT void py_tuple_setitem(py_Ref self, int i, py_Ref val);
|
||||
PK_EXPORT int py_tuple_len(py_Ref self);
|
||||
PK_API py_ObjectRef py_tuple_data(py_Ref self);
|
||||
PK_API py_ObjectRef py_tuple_getitem(py_Ref self, int i);
|
||||
PK_API void py_tuple_setitem(py_Ref self, int i, py_Ref val);
|
||||
PK_API int py_tuple_len(py_Ref self);
|
||||
|
||||
PK_EXPORT py_ItemRef py_list_data(py_Ref self);
|
||||
PK_EXPORT py_ItemRef py_list_getitem(py_Ref self, int i);
|
||||
PK_EXPORT void py_list_setitem(py_Ref self, int i, py_Ref val);
|
||||
PK_EXPORT void py_list_delitem(py_Ref self, int i);
|
||||
PK_EXPORT int py_list_len(py_Ref self);
|
||||
PK_EXPORT void py_list_swap(py_Ref self, int i, int j);
|
||||
PK_EXPORT void py_list_append(py_Ref self, py_Ref val);
|
||||
PK_EXPORT py_ItemRef py_list_emplace(py_Ref self);
|
||||
PK_EXPORT void py_list_clear(py_Ref self);
|
||||
PK_EXPORT void py_list_insert(py_Ref self, int i, py_Ref val);
|
||||
PK_API py_ItemRef py_list_data(py_Ref self);
|
||||
PK_API py_ItemRef py_list_getitem(py_Ref self, int i);
|
||||
PK_API void py_list_setitem(py_Ref self, int i, py_Ref val);
|
||||
PK_API void py_list_delitem(py_Ref self, int i);
|
||||
PK_API int py_list_len(py_Ref self);
|
||||
PK_API void py_list_swap(py_Ref self, int i, int j);
|
||||
PK_API void py_list_append(py_Ref self, py_Ref val);
|
||||
PK_API py_ItemRef py_list_emplace(py_Ref self);
|
||||
PK_API void py_list_clear(py_Ref self);
|
||||
PK_API void py_list_insert(py_Ref self, int i, py_Ref val);
|
||||
|
||||
/// -1: error, 0: not found, 1: found
|
||||
PK_EXPORT int py_dict_getitem(py_Ref self, py_Ref key) PY_RAISE PY_RETURN;
|
||||
PK_API int py_dict_getitem(py_Ref self, py_Ref key) PY_RAISE PY_RETURN;
|
||||
/// true: success, false: error
|
||||
PK_EXPORT bool py_dict_setitem(py_Ref self, py_Ref key, py_Ref val) PY_RAISE;
|
||||
PK_API bool py_dict_setitem(py_Ref self, py_Ref key, py_Ref val) PY_RAISE;
|
||||
/// -1: error, 0: not found, 1: found (and deleted)
|
||||
PK_EXPORT int py_dict_delitem(py_Ref self, py_Ref key) PY_RAISE;
|
||||
PK_API int py_dict_delitem(py_Ref self, py_Ref key) PY_RAISE;
|
||||
/// -1: error, 0: not found, 1: found
|
||||
PK_EXPORT int py_dict_getitem_by_str(py_Ref self, const char* key) PY_RAISE PY_RETURN;
|
||||
PK_API int py_dict_getitem_by_str(py_Ref self, const char* key) PY_RAISE PY_RETURN;
|
||||
/// true: success, false: error
|
||||
PK_EXPORT bool py_dict_setitem_by_str(py_Ref self, const char* key, py_Ref val) PY_RAISE;
|
||||
PK_API bool py_dict_setitem_by_str(py_Ref self, const char* key, py_Ref val) PY_RAISE;
|
||||
/// -1: error, 0: not found, 1: found (and deleted)
|
||||
PK_EXPORT int py_dict_delitem_by_str(py_Ref self, const char* key) PY_RAISE;
|
||||
PK_API int py_dict_delitem_by_str(py_Ref self, const char* key) PY_RAISE;
|
||||
/// true: success, false: error
|
||||
PK_EXPORT bool
|
||||
PK_API bool
|
||||
py_dict_apply(py_Ref self, bool (*f)(py_Ref key, py_Ref val, void* ctx), void* ctx) PY_RAISE;
|
||||
/// noexcept
|
||||
PK_EXPORT int py_dict_len(py_Ref self);
|
||||
PK_API int py_dict_len(py_Ref self);
|
||||
|
||||
/************* linalg module *************/
|
||||
void py_newvec2(py_OutRef out, c11_vec2);
|
||||
@ -625,7 +625,7 @@ c11_mat3x3* py_tomat3x3(py_Ref self);
|
||||
/************* Others *************/
|
||||
|
||||
/// An utility function to read a line from stdin for REPL.
|
||||
PK_EXPORT int py_replinput(char* buf, int max_size);
|
||||
PK_API int py_replinput(char* buf, int max_size);
|
||||
|
||||
/// Python favored string formatting.
|
||||
/// %d: int
|
||||
|
||||
@ -52,7 +52,7 @@ using module_ = module;
|
||||
|
||||
#define PYBIND11_MODULE(name, variable) \
|
||||
static void _pkbind_register_##name(::pkbind::module& variable); \
|
||||
extern "C" bool py_module_initialize() { \
|
||||
extern "C" PK_EXPORT bool py_module_initialize() { \
|
||||
auto m = ::pkbind::module::create(#name); \
|
||||
_pkbind_register_##name(m); \
|
||||
return true; \
|
||||
|
||||
@ -13,7 +13,7 @@ class Function:
|
||||
is_py_return: bool
|
||||
|
||||
def signature(self):
|
||||
tmp = f"PK_EXPORT {self.ret} {self.name}{self.args}"
|
||||
tmp = f"PK_API {self.ret} {self.name}{self.args}"
|
||||
return tmp + ';'
|
||||
|
||||
def badges(self):
|
||||
@ -37,7 +37,7 @@ class Function:
|
||||
with open('include/pocketpy/pocketpy.h') as f:
|
||||
header = f.read()
|
||||
|
||||
matches = re.finditer(r"((?:/// [^\n]+[\n])*?)PK_EXPORT\s+(\w+\*?)\s+(\w+)(\(.*?\))\s*(PY_RAISE)?\s*(PY_RETURN)?\s*;", header, re.DOTALL)
|
||||
matches = re.finditer(r"((?:/// [^\n]+[\n])*?)PK_API\s+(\w+\*?)\s+(\w+)(\(.*?\))\s*(PY_RAISE)?\s*(PY_RETURN)?\s*;", header, re.DOTALL)
|
||||
# ^1 comment ^2 ret ^3 n ^4 args ^5 py_raise? ^6 py_return?
|
||||
|
||||
functions: list[Function] = []
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user