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

Implement dynamic dlib (#309)

Browse Source 
* lazy cpp_function and capsule.

* remove retv.

* remove type_map.

* remove object pool from initialize.

* support dynamic library.

* remove vector_bool.

* remove unused header.

* fix export name.

* fix test name.

* some fix

* some fix

* ...

---------

Co-authored-by: blueloveTH <blueloveth@foxmail.com>
This commit is contained in:
ykiko 2024-09-22 21:48:10 +08:00 committed by GitHub
parent e1d52653bf
commit 2773b9993e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
34 changed files with 389 additions and 551 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
.github/workflows/numpy.yml vendored
View File

@ -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

27
3rd/numpy/tests/CMakeLists.txt → 3rd/numpy/CMakeLists.txt
View File

@ -1,17 +1,13 @@
cmake_minimum_required(VERSION 3.10)
project(numpy_bindings)
project(numpy)
# Set C++ standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# Add pocketpy as a subdirectory
add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/../../.." "${CMAKE_CURRENT_BINARY_DIR}/pocketpy")
# Include pybind11 and numpy
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../../../include")
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include")
include_directories("${CMAKE_CURRENT_LIST_DIR}/../../include")
include_directories("${CMAKE_CURRENT_LIST_DIR}/include")
# Control xtensor warnings (OFF by default)
option(SHOW_XTENSOR_WARNINGS "Show warnings from xtensor" OFF)
@ -32,14 +28,17 @@ if(NOT SHOW_XTENSOR_WARNINGS)
endif()
# Add numpy source and test files
file (GLOB SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/../src/numpy.cpp")
file (GLOB TESTS "${CMAKE_CURRENT_SOURCE_DIR}/test_numpy.cpp")
file(GLOB_RECURSE SOURCES ${CMAKE_CURRENT_LIST_DIR}/src/*.cpp)
# Create numpy executables
add_executable(numpy_bindings ${TESTS} ${SOURCES})
# Create numpy dynamic library
add_library(${PROJECT_NAME} SHARED ${SOURCES})
# Set VS debugger working directory (if relevant)
set_property(TARGET ${PROJECT_NAME} PROPERTY VS_DEBUGGER_WORKING_DIRECTORY CMAKE_CURRENT_LIST_DIR)
# Define PY_DYNAMIC_MODULE for numpy
target_compile_definitions(${PROJECT_NAME} PRIVATE PY_DYNAMIC_MODULE)
# Link numpy with pocketpy
target_link_libraries(${PROJECT_NAME} PRIVATE pocketpy)
target_link_libraries(
${PROJECT_NAME}
PRIVATE
${CMAKE_CURRENT_LIST_DIR}/../..//build/Release/pocketpy.lib
)

49
3rd/numpy/README.md
View File

@ -1,49 +1,6 @@
# numpy
# How to build
### How to run **numpy** module programs with **gsoc-2024-dev** [pybind11](https://github.com/pocketpy/gsoc-2024-dev/tree/main/pybind11)
1. Prepare the python code file with the numpy operations you want to run. \
\
For example : let's try out numpy [arange](https://numpy.org/doc/stable/reference/generated/numpy.arange.html) function in `test_numpy.py`
```py
import numpy_bindings as np
def test_arange(n):
a = np.arange(n)
print(a.sum())
test_arange(100)
```
2. Read the script and execute it in `test_numpy.cpp`.
```cpp
#include <pybind11/embed.h>
#include <fstream>
#include <sstream>
#include <string>
namespace py = pybind11;
using namespace pybind11;
int main() {
py::scoped_interpreter guard{};
std::ifstream file("test_numpy.py");
std::stringstream buffer;
buffer << file.rdbuf();
std::string script = buffer.str();
py::exec(script);
return 0;
}
```
3. Build the project at root to generate the executable at `build/gsoc2024`.
```sh
cmake -B build
cmake --build build
```
4. Now run the executable to get the output.
```sh
|base| gsoc-2024-dev ±|main ✗|→ build/gsoc2024
4950
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release
```

2
3rd/numpy/src/numpy.cpp
View File

@ -2869,7 +2869,7 @@ void array_creation_registry(py::module_& m) {
}
PYBIND11_EMBEDDED_MODULE(numpy_bindings, m) {
PYBIND11_MODULE(numpy, m) {
m.doc() = "Python bindings for pkpy::numpy::ndarray using pybind11";
m.attr("bool_") = "bool";

12
3rd/numpy/tests/test_numpy.py
View File

@ -1,12 +1,10 @@
import sys
import math
from typing import TYPE_CHECKING
is_pkpy = not hasattr(sys, 'getrefcount')
if is_pkpy:
import numpy_bindings as np
else:
if TYPE_CHECKING:
import numpy as np
else:
np = __import__('E:/pocketpy/3rd/numpy/build/Release/numpy.dll')
def assert_equal(a, b):
assert (a == b).all()
@ -888,3 +886,5 @@ assert_equal(arr1[-2:3:1], np.array([[[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10]],
[[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]]]))
print("ALL TESTS PASSED")

14
include/pocketpy/export.h
View File

@ -2,12 +2,17 @@
// clang-format off
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
//define something for Windows (32-bit and 64-bit, this part is common)
#if defined(_WIN32) || defined(_WIN64)
#ifdef PY_DYNAMIC_MODULE
#define PK_API __declspec(dllimport)
#else
#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"
@ -27,17 +32,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

1
include/pocketpy/interpreter/vm.h
View File

@ -14,7 +14,6 @@
// 4. stack balance guanrantee
// 5. stack effect of each opcode
// 6. py_TypeInfo
// 7. Direct assignment of py_NIL, py_True, py_False, py_None. They are slow.
typedef struct VM {
Frame* top_frame;

324
include/pocketpy/pocketpy.h
View File

@ -70,36 +70,27 @@ typedef bool (*py_CFunction)(int argc, py_StackRef argv) PY_RAISE PY_RETURN;
/// + `SINGLE_MODE`: for REPL or jupyter notebook execution.
enum py_CompileMode { EXEC_MODE, EVAL_MODE, SINGLE_MODE };
/// A shorthand for `True`.
PK_EXPORT extern py_GlobalRef py_True;
/// A shorthand for `False`.
PK_EXPORT extern py_GlobalRef py_False;
/// A shorthand for `None`.
PK_EXPORT extern py_GlobalRef py_None;
/// A shorthand for `nil`. `nil` is not a valid python object.
PK_EXPORT extern py_GlobalRef py_NIL;
/************* 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.
@ -107,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:
@ -121,87 +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_API py_GlobalRef py_True();
/// A shorthand for `False`.
PK_API py_GlobalRef py_False();
/// A shorthand for `None`.
PK_API py_GlobalRef py_None();
/// A shorthand for `nil`. `nil` is not a valid python object.
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

36
include/pybind11/internal/builtins.h
View File

@ -17,7 +17,9 @@ inline object eval(std::string_view code, handle globals = none(), handle locals
return object::from_ret();
} else {
handle eval = py_getbuiltin(py_name("eval"));
return eval(str(code), globals.is_none() ? dict() : globals, locals.is_none() ? dict() : locals);
return eval(str(code),
globals.is_none() ? dict() : globals,
locals.is_none() ? dict() : locals);
}
}
@ -75,7 +77,8 @@ inline bool isinstance(handle obj, type type) { return py_isinstance(obj.ptr(),
inline bool python_error::match(type type) const { return isinstance(m_exception.ptr(), type); }
template <typename T>
constexpr inline bool is_pyobject_v = std::is_base_of_v<object, std::decay_t<T>> || std::is_same_v<type, T>;
constexpr inline bool is_pyobject_v =
std::is_base_of_v<object, std::decay_t<T>> || std::is_same_v<type, T>;
template <typename T>
inline type type::of() {
@ -86,8 +89,8 @@ inline type type::of() {
return type(T::type_or_check());
}
} else {
auto it = m_type_map->find(typeid(T));
if(it != m_type_map->end()) {
auto it = m_type_map.find(typeid(T));
if(it != m_type_map.end()) {
return type(it->second);
} else {
// if not found, raise error
@ -104,8 +107,8 @@ inline bool type::isinstance(handle obj) {
if constexpr(is_pyobject_v<T>) {
// for every python object wrapper type, there must be a `type_or_check` method.
// for some types, it returns the underlying type in pkpy, e.g., `int_` -> `tp_int`.
// for other types that may not have a corresponding type in pkpy, it returns a check function.
// e.g., `iterable` -> `[](handle h){ return hasattr(h, "iter"); }`.
// for other types that may not have a corresponding type in pkpy, it returns a check
// function. e.g., `iterable` -> `[](handle h){ return hasattr(h, "iter"); }`.
auto type_or_check = T::type_or_check();
if constexpr(is_check_v<T>) {
return type_or_check(obj);
@ -117,7 +120,9 @@ inline bool type::isinstance(handle obj) {
}
}
inline bool issubclass(type derived, type base) { return py_issubclass(derived.index(), base.index()); }
inline bool issubclass(type derived, type base) {
return py_issubclass(derived.index(), base.index());
}
template <typename T>
inline bool isinstance(handle obj) {
@ -131,17 +136,23 @@ template <typename T, typename SFINAE = void>
struct type_caster;
template <typename T>
object cast(T&& value, return_value_policy policy = return_value_policy::automatic_reference, handle parent = {}) {
object cast(T&& value,
return_value_policy policy = return_value_policy::automatic_reference,
handle parent = {}) {
// decay_t can resolve c-array type, but remove_cv_ref_t can't.
using underlying_type = std::decay_t<T>;
if constexpr(std::is_convertible_v<underlying_type, handle> && !is_pyobject_v<underlying_type>) {
if constexpr(std::is_convertible_v<underlying_type, handle> &&
!is_pyobject_v<underlying_type>) {
return object(std::forward<T>(value), object::realloc_t{});
} else if constexpr(is_unique_pointer_v<underlying_type>) {
using pointer = typename underlying_type::pointer;
return type_caster<pointer>::cast(value.release(), return_value_policy::take_ownership, parent);
return type_caster<pointer>::cast(value.release(),
return_value_policy::take_ownership,
parent);
} else {
static_assert(!is_multiple_pointer_v<underlying_type>, "multiple pointer is not supported.");
static_assert(!is_multiple_pointer_v<underlying_type>,
"multiple pointer is not supported.");
static_assert(!std::is_void_v<std::remove_pointer_t<underlying_type>>,
"void* is not supported, consider using py::capsule.");
@ -163,7 +174,8 @@ object cast(T&& value, return_value_policy policy = return_value_policy::automat
template <typename T>
T cast(handle obj, bool convert = true) {
using caster_t = type_caster<T>;
constexpr auto is_dangling_v = (std::is_reference_v<T> || is_pointer_v<T>) && caster_t::is_temporary_v;
constexpr auto is_dangling_v =
(std::is_reference_v<T> || is_pointer_v<T>) && caster_t::is_temporary_v;
static_assert(!is_dangling_v, "dangling reference or pointer is not allowed.");
assert(obj.ptr() != nullptr);

5
include/pybind11/internal/class.h
View File

@ -25,7 +25,7 @@ public:
static_cast<instance*>(data)->~instance();
})),
m_scope(scope) {
m_type_map->try_emplace(typeid(T), this->index());
m_type_map.try_emplace(typeid(T), this->index());
auto& info = type_info::of<T>();
info.name = name;
@ -40,7 +40,8 @@ public:
auto info = &type_info::of<T>();
int slot = ((std::is_same_v<dynamic_attr, Args> || ...) ? -1 : 0);
void* data = py_newobject(retv, steal<type>(cls).index(), slot, sizeof(instance));
void* data =
py_newobject(py_retval(), steal<type>(cls).index(), slot, sizeof(instance));
new (data) instance{instance::Flag::Own, operator new (info->size), info};
return true;
},

10
include/pybind11/internal/error.h
View File

@ -34,13 +34,9 @@ inline auto raise_call(Args&&... args) {
using type = decltype(result);
if constexpr(std::is_same_v<type, bool>) {
if(result != false) {
return result;
}
if(result != false) { return result; }
} else if constexpr(std::is_same_v<type, int>) {
if(result != -1) {
return result;
}
if(result != -1) { return result; }
} else {
static_assert(dependent_false<type>, "invalid return type");
}
@ -87,7 +83,7 @@ inline object::operator bool () const { return raise_call<py_bool>(m_ptr); }
#define PKBIND_BINARY_OPERATOR(name, lop, rop) \
inline object operator name (handle lhs, handle rhs) { \
raise_call<py_binaryop>(lhs.ptr(), rhs.ptr(), lop, rop); \
return object(retv, object::realloc_t{}); \
return object::from_ret(); \
}
PKBIND_BINARY_OPERATOR(==, __eq__, __eq__)

35
include/pybind11/internal/function.h
View File

@ -515,20 +515,18 @@ struct template_parser<Callable,
} // namespace impl
class cpp_function : public function {
inline static py_Type m_type = 0;
PKBIND_TYPE_IMPL(function, cpp_function, tp_function);
static void register_() {
m_type = py_newtype("function_record", tp_object, nullptr, [](void* data) {
inline static lazy<py_Type> tp_function_record = +[](py_Type& type) {
type = py_newtype("function_record", tp_object, nullptr, [](void* data) {
static_cast<impl::function_record*>(data)->~function_record();
});
}
};
static bool is_function_record(handle h) {
if(isinstance<function>(h)) {
auto slot = py_getslot(h.ptr(), 0);
if(slot) { return py_typeof(slot) == m_type; }
if(slot) { return py_typeof(slot) == tp_function_record; }
}
return false;
}
@ -539,7 +537,15 @@ class cpp_function : public function {
// bind the function
std::string sig = name;
sig += is_method ? "(self, *args, **kwargs)" : "(*args, **kwargs)";
auto call = [](int argc, py_Ref stack) {
py_newfunction(m_ptr, sig.c_str(), call, nullptr, 1);
auto slot = py_getslot(m_ptr, 0);
void* data = py_newobject(slot, tp_function_record, 0, sizeof(impl::function_record));
new (data) impl::function_record(std::forward<Fn>(fn), extras...);
}
private:
static bool call(int argc, py_Ref stack) {
handle func = py_inspect_currentfunction();
auto data = py_touserdata(py_getslot(func.ptr(), 0));
auto& record = *static_cast<impl::function_record*>(data);
@ -560,26 +566,13 @@ class cpp_function : public function {
py_exception(tp_IndexError, e.what());
} catch(key_error& e) { py_exception(tp_KeyError, e.what()); } catch(value_error& e) {
py_exception(tp_ValueError, e.what());
} catch(type_error& e) {
py_exception(tp_TypeError, e.what());
} catch(import_error& e) {
} catch(type_error& e) { py_exception(tp_TypeError, e.what()); } catch(import_error& e) {
py_exception(tp_ImportError, e.what());
} catch(attribute_error& e) {
py_exception(tp_AttributeError, e.what());
} catch(std::exception& e) { py_exception(tp_RuntimeError, e.what()); }
return false;
};
py_newfunction(m_ptr, sig.c_str(), call, nullptr, 1);
assert(m_type != 0 && "function record type not registered");
auto slot = py_getslot(m_ptr, 0);
void* data = py_newobject(slot, m_type, 0, sizeof(impl::function_record));
new (data) impl::function_record(std::forward<Fn>(fn), extras...);
}
template <typename Fn, typename... Extras>
cpp_function(Fn&& fn, const Extras&... extras) :
cpp_function("lambda", std::forward<Fn>(fn), extras...) {}
};
class property : public object {

74
include/pybind11/internal/kernel.h
View File

@ -6,6 +6,7 @@
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <optional>
#include <typeindex>
#include <stdexcept>
#include <unordered_map>
@ -17,40 +18,18 @@ namespace pkbind {
class handle;
/// hold the object temporarily
template <int N>
struct reg_t {
py_Ref value;
struct action {
using function = void (*)();
inline static std::vector<function> starts;
void operator= (py_Ref ref) & { py_setreg(N, ref); }
operator py_Ref () & {
assert(value && "register is not initialized");
return value;
static void initialize() noexcept {
for(auto func: starts) {
func();
}
}
void operator= (handle value) &;
operator handle () &;
// pkpy provide user 8 registers.
// 8th register is used for object pool, so N is limited to [0, 7).
static_assert(N >= 0 && N <= 6, "N must be in [0, 7)");
};
struct retv_t {
py_Ref value;
void operator= (py_Ref ref) & { py_assign(value, ref); }
operator py_Ref () & {
assert(value && "return value is not initialized");
return value;
}
void operator= (handle value) &;
operator handle () &;
// register a function to be called at the start of the vm.
static void register_start(function func) { starts.push_back(func); }
};
/// hold the object long time.
@ -78,6 +57,7 @@ struct object_pool {
/// alloc an object from pool, note that the object is uninitialized.
static object_ref alloc() {
if(!indices_) { initialize(1024); }
auto& indices = *indices_;
if(cache != -1) {
auto index = cache;
@ -126,25 +106,27 @@ struct object_pool {
}
};
struct action {
using function = void (*)();
inline static std::vector<function> starts;
template <typename T>
class lazy {
public:
lazy(void (*init)(T&)) : init(init) {}
static void initialize() noexcept {
for(auto func: starts) {
func();
operator T& () {
if(!initialized) {
if(init) { init(value); }
initialized = true;
}
return value;
}
// register a function to be called at the start of the vm.
static void register_start(function func) { starts.push_back(func); }
T& operator* () { return static_cast<T&>(*this); }
void reset() { initialized = false; }
private:
T value;
bool initialized = false;
void (*init)(T&) = nullptr;
};
template <int N>
inline reg_t<N> reg;
inline retv_t retv;
inline std::unordered_map<std::type_index, py_Type>* m_type_map = nullptr;
} // namespace pkbind

10
include/pybind11/internal/module.h
View File

@ -50,4 +50,14 @@ using module_ = module;
} \
static void _pkbind_register_##name(::pkbind::module& variable)
#define PYBIND11_MODULE(name, variable) \
static void _pkbind_register_##name(::pkbind::module& variable); \
extern "C" PK_EXPORT bool py_module_initialize() { \
auto m = ::pkbind::module::create(#name); \
_pkbind_register_##name(m); \
py_assign(py_retval(), m.ptr()); \
return true; \
} \
static void _pkbind_register_##name(::pkbind::module& variable)
} // namespace pkbind

20
include/pybind11/internal/object.h
View File

@ -261,7 +261,7 @@ public:
object(handle h, ref_t) : handle(h) {}
static object from_ret() { return object(retv, realloc_t{}); }
static object from_ret() { return object(py_retval(), realloc_t{}); }
operator object_pool::object_ref () const { return {m_ptr, m_index}; }
@ -281,24 +281,6 @@ T borrow(handle h) {
return T(h, object::realloc_t{});
}
template <int N>
void reg_t<N>::operator= (handle h) & {
py_setreg(N, h.ptr());
}
template <int N>
reg_t<N>::operator handle () & {
assert(value && "register is not initialized");
return value;
}
inline void retv_t::operator= (handle h) & { py_assign(value, h.ptr()); }
inline retv_t::operator handle () & {
assert(value && "return value is not initialized");
return value;
}
static_assert(std::is_trivially_copyable_v<name>);
static_assert(std::is_trivially_copyable_v<handle>);

24
include/pybind11/internal/types.h
View File

@ -29,6 +29,8 @@ public:
using object ::object;
using object ::operator=;
inline static std::unordered_map<std::type_index, py_Type> m_type_map;
// note: type is global instance, so we use ref_t.
explicit type(py_Type type) : object(py_tpobject(type), ref_t{}) {}
@ -49,14 +51,14 @@ class none : public object {
PKBIND_TYPE_IMPL(object, none, tp_NoneType);
// note: none is global instance, so we use ref_t.
none() : object(py_None, ref_t{}) {}
none() : object(py_None(), ref_t{}) {}
};
class bool_ : public object {
PKBIND_TYPE_IMPL(object, bool_, tp_bool);
// same as none, bool is a singleton.
bool_(bool value) : object(value ? py_True : py_False, ref_t{}) {}
bool_(bool value) : object(value ? py_True() : py_False(), ref_t{}) {}
explicit operator bool () { return py_tobool(ptr()); }
};
@ -101,7 +103,7 @@ public:
iterator& operator++ () {
int result = raise_call<py_next>(m_ptr);
if(result == 1) {
m_value = object(retv, realloc_t{});
m_value = object::from_ret();
} else if(result == 0) {
m_value = object();
}
@ -125,7 +127,7 @@ private:
template <typename Dervied>
iterator interface<Dervied>::begin() const {
raise_call<py_iter>(ptr());
return iterator(retv);
return iterator(py_retval());
}
template <typename Dervied>
@ -330,24 +332,22 @@ class kwargs : public dict {
// TODO:
class capsule : public object {
PKBIND_TYPE_IMPL(object, capsule, *tp_capsule);
struct capsule_impl {
void* data;
void (*destructor)(void*);
};
inline static py_Type m_type = 0;
PKBIND_TYPE_IMPL(object, capsule, m_type);
static void register_() {
m_type = py_newtype("capsule", tp_object, nullptr, [](void* data) {
inline static lazy<py_Type> tp_capsule = +[](py_Type& type) {
type = py_newtype("capsule", tp_object, nullptr, [](void* data) {
auto impl = static_cast<capsule_impl*>(data);
if(impl->data && impl->destructor) { impl->destructor(impl->data); }
});
}
};
capsule(void* data, void (*destructor)(void*) = nullptr) : object(alloc_t{}) {
void* impl = py_newobject(m_ptr, m_type, 0, sizeof(capsule_impl));
void* impl = py_newobject(m_ptr, tp_capsule, 0, sizeof(capsule_impl));
new (impl) capsule_impl{data, destructor};
}

27
include/pybind11/pybind11.h
View File

@ -13,28 +13,6 @@ inline bool initialized = false;
/// initialize the vm.
inline void initialize(int object_pool_size = 1024) {
if(!initialized) { py_initialize(); }
// initialize all registers.
reg<0>.value = py_getreg(0);
reg<1>.value = py_getreg(1);
reg<2>.value = py_getreg(2);
reg<3>.value = py_getreg(3);
reg<4>.value = py_getreg(4);
reg<5>.value = py_getreg(5);
reg<6>.value = py_getreg(6);
// initialize ret.
retv.value = py_retval();
// initialize object pool.
object_pool::initialize(object_pool_size);
m_type_map = new std::unordered_map<std::type_index, py_Type>();
// register types.
capsule::register_();
cpp_function::register_();
action::initialize();
initialized = true;
}
@ -42,9 +20,10 @@ inline void initialize(int object_pool_size = 1024) {
/// finalize the vm.
inline void finalize(bool test = false) {
if(!initialized) { return; }
delete m_type_map;
m_type_map = nullptr;
object_pool::finalize();
type::m_type_map.clear();
capsule::tp_capsule.reset();
cpp_function::tp_function_record.reset();
if(test) {
py_resetvm();
} else {

38
include/pybind11/stl.h
View File

@ -56,40 +56,6 @@ constexpr bool is_py_list_like_v<std::list<T, Allocator>> = true;
template <typename T, typename Allocator>
constexpr bool is_py_list_like_v<std::deque<T, Allocator>> = true;
template <>
struct type_caster<std::vector<bool>> {
std::vector<bool> data;
template <typename U>
static object cast(U&& src, return_value_policy policy, handle parent) {
auto list = pkbind::list();
for(auto&& item: src) {
list.append(pkbind::cast(bool(item), policy, parent));
}
return list;
}
bool load(handle src, bool convert) {
if(!isinstance<list>(src)) { return false; }
auto list = src.cast<pkbind::list>();
data.clear();
data.reserve(list.size());
for(auto item: list) {
type_caster<bool> caster;
if(!caster.load(item, convert)) { return false; }
data.push_back(caster.value());
}
return true;
}
std::vector<bool>& value() { return data; }
constexpr inline static bool is_temporary_v = true;
};
template <typename T>
struct type_caster<T, std::enable_if_t<is_py_list_like_v<T>>> {
T data;
@ -98,8 +64,12 @@ struct type_caster<T, std::enable_if_t<is_py_list_like_v<T>>> {
static object cast(U&& src, return_value_policy policy, handle parent) {
auto list = pkbind::list();
for(auto&& item: src) {
if constexpr(std::is_same_v<T, std::vector<bool>>) {
list.append(pkbind::cast(bool(item), policy, parent));
} else {
list.append(pkbind::cast(std::move(item), policy, parent));
}
}
return list;
}

27
include/pybind11/tests/module.cpp
View File

@ -12,6 +12,17 @@ PYBIND11_EMBEDDED_MODULE(example, m) {
});
}
PYBIND11_MODULE(example3, m) {
m.def("add", [](int a, int b) {
return a + b;
});
auto math = m.def_submodule("math");
math.def("sub", [](int a, int b) {
return a - b;
});
}
namespace {
TEST_F(PYBIND11_TEST, module) {
@ -52,4 +63,20 @@ TEST_F(PYBIND11_TEST, raw_module) {
EXPECT_EQ(math2.attr("sub")(4, 3).cast<int>(), 1);
}
TEST_F(PYBIND11_TEST, dynamic_module) {
py_module_initialize();
py::exec("import example3");
EXPECT_EVAL_EQ("example3.add(1, 2)", 3);
py::exec("from example3 import math");
EXPECT_EVAL_EQ("math.sub(1, 2)", -1);
py::exec("from example3.math import sub");
EXPECT_EVAL_EQ("sub(1, 2)", -1);
auto math = py::module::import("example3.math");
EXPECT_EQ(math.attr("sub")(4, 3).cast<int>(), 1);
}
} // namespace

4
scripts/gen_docs.py
View File

@ -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] = []

5
src/interpreter/dll.c
View File

@ -22,7 +22,10 @@ int load_module_from_dll_desktop_only(const char* path) PY_RAISE PY_RETURN {
if(dll == NULL) return 0;
py_module_initialize_t f_init = (py_module_initialize_t)dlsym(dll, f_init_name);
#endif
if(f_init == NULL) return 0;
if(f_init == NULL) {
RuntimeError("%s() not found in '%s'", f_init_name, path);
return -1;
}
bool success = f_init();
if(!success) return -1;
return 1;

14
src/interpreter/vm.c
View File

@ -52,23 +52,23 @@ static void py_TypeInfo__ctor(py_TypeInfo* self,
};
self->module = module;
self->annotations = *py_NIL;
self->annotations = *py_NIL();
}
void VM__ctor(VM* self) {
self->top_frame = NULL;
ModuleDict__ctor(&self->modules, NULL, *py_NIL);
ModuleDict__ctor(&self->modules, NULL, *py_NIL());
TypeList__ctor(&self->types);
self->builtins = *py_NIL;
self->main = *py_NIL;
self->builtins = *py_NIL();
self->main = *py_NIL();
self->callbacks.importfile = pk_default_importfile;
self->callbacks.print = pk_default_print;
self->last_retval = *py_NIL;
self->curr_exception = *py_NIL;
self->last_retval = *py_NIL();
self->curr_exception = *py_NIL();
self->is_curr_exc_handled = false;
self->ctx = NULL;
@ -329,7 +329,7 @@ py_Type pk_newtype(const char* name,
if(base_ti && base_ti->is_sealed) {
c11__abort("type '%s' is not an acceptable base type", py_name2str(base_ti->name));
}
py_TypeInfo__ctor(ti, py_name(name), index, base, base_ti, module ? *module : *py_NIL);
py_TypeInfo__ctor(ti, py_name(name), index, base, base_ti, module ? *module : *py_NIL());
if(!dtor && base) dtor = base_ti->dtor;
ti->dtor = dtor;
ti->is_python = is_python;

2
src/modules/array2d.c
View File

@ -106,7 +106,7 @@ static bool array2d_get(int argc, py_Ref argv) {
PY_CHECK_ARG_TYPE(1, tp_int);
PY_CHECK_ARG_TYPE(2, tp_int);
if(argc == 3) {
default_ = py_None;
default_ = py_None();
} else if(argc == 4) {
default_ = py_arg(3);
} else {

6
src/modules/json.c
View File

@ -21,9 +21,9 @@ static bool json_dumps(int argc, py_Ref argv) {
void pk__add_module_json() {
py_Ref mod = py_newmodule("json");
py_setdict(mod, py_name("null"), py_None);
py_setdict(mod, py_name("true"), py_True);
py_setdict(mod, py_name("false"), py_False);
py_setdict(mod, py_name("null"), py_None());
py_setdict(mod, py_name("true"), py_True());
py_setdict(mod, py_name("false"), py_False());
py_bindfunc(mod, "loads", json_loads);
py_bindfunc(mod, "dumps", json_dumps);

2
src/objects/codeobject.c
View File

@ -162,7 +162,7 @@ void CodeObject__dtor(CodeObject* self) {
void Function__ctor(Function* self, FuncDecl_ decl, py_TValue* module) {
PK_INCREF(decl);
self->decl = decl;
self->module = module ? *module : *py_NIL;
self->module = module ? *module : *py_NIL();
self->clazz = NULL;
self->closure = NULL;
self->cfunc = NULL;

20
src/public/internal.c
View File

@ -11,13 +11,9 @@
VM* pk_current_vm;
py_GlobalRef py_True;
py_GlobalRef py_False;
py_GlobalRef py_None;
py_GlobalRef py_NIL;
static VM pk_default_vm;
static VM* pk_all_vm[16];
static py_TValue _True, _False, _None, _NIL;
void py_initialize() {
if(pk_current_vm){
@ -30,18 +26,18 @@ void py_initialize() {
pk_current_vm = pk_all_vm[0] = &pk_default_vm;
// initialize some convenient references
static py_TValue _True, _False, _None, _NIL;
py_newbool(&_True, true);
py_newbool(&_False, false);
py_newnone(&_None);
py_newnil(&_NIL);
py_True = &_True;
py_False = &_False;
py_None = &_None;
py_NIL = &_NIL;
VM__ctor(&pk_default_vm);
}
py_GlobalRef py_True() { return &_True; }
py_GlobalRef py_False() { return &_False; }
py_GlobalRef py_None() { return &_None; }
py_GlobalRef py_NIL() { return &_NIL; }
void py_finalize() {
for(int i = 1; i < 16; i++) {
VM* vm = pk_all_vm[i];
@ -169,7 +165,7 @@ bool pk_loadmethod(py_StackRef self, py_Name name) {
py_Ref cls_var = py_tpfindmagic(py_totype(self), name);
if(cls_var) {
self[0] = *cls_var;
self[1] = *py_NIL;
self[1] = *py_NIL();
return true;
}
return false;
@ -197,7 +193,7 @@ bool pk_loadmethod(py_StackRef self, py_Name name) {
}
case tp_staticmethod:
self[0] = *py_getslot(cls_var, 0);
self[1] = *py_NIL;
self[1] = *py_NIL();
break;
case tp_classmethod:
self[0] = *py_getslot(cls_var, 0);

6
src/public/modules.c
View File

@ -676,11 +676,11 @@ py_TValue pk_builtins__register() {
// some patches
py_bindmagic(tp_NoneType, __repr__, NoneType__repr__);
*py_tpgetmagic(tp_NoneType, __hash__) = *py_None;
*py_tpgetmagic(tp_NoneType, __hash__) = *py_None();
py_bindmagic(tp_ellipsis, __repr__, ellipsis__repr__);
*py_tpgetmagic(tp_ellipsis, __hash__) = *py_None;
*py_tpgetmagic(tp_ellipsis, __hash__) = *py_None();
py_bindmagic(tp_NotImplementedType, __repr__, NotImplementedType__repr__);
*py_tpgetmagic(tp_NotImplementedType, __hash__) = *py_None;
*py_tpgetmagic(tp_NotImplementedType, __hash__) = *py_None();
return *builtins;
}

6
src/public/py_dict.c
View File

@ -389,7 +389,7 @@ static bool dict_update(int argc, py_Ref argv) {
static bool dict_get(int argc, py_Ref argv) {
Dict* self = py_touserdata(argv);
if(argc > 3) return TypeError("get() takes at most 3 arguments (%d given)", argc);
py_Ref default_val = argc == 3 ? py_arg(2) : py_None;
py_Ref default_val = argc == 3 ? py_arg(2) : py_None();
DictEntry* entry;
if(!Dict__try_get(self, py_arg(1), &entry)) return false;
*py_retval() = entry ? entry->val : *default_val;
@ -399,7 +399,7 @@ static bool dict_get(int argc, py_Ref argv) {
static bool dict_pop(int argc, py_Ref argv) {
Dict* self = py_touserdata(argv);
if(argc < 2 || argc > 3) return TypeError("pop() takes 1 or 2 arguments (%d given)", argc - 1);
py_Ref default_val = argc == 3 ? py_arg(2) : py_None;
py_Ref default_val = argc == 3 ? py_arg(2) : py_None();
int res = Dict__pop(self, py_arg(1));
if(res == -1) return false;
if(res == 0) { py_assign(py_retval(), default_val); }
@ -482,7 +482,7 @@ py_Type pk_dict__register() {
py_bindmethod(type, "keys", dict_keys);
py_bindmethod(type, "values", dict_values);
py_setdict(py_tpobject(type), __hash__, py_None);
py_setdict(py_tpobject(type), __hash__, py_None());
return type;
}

4
src/public/py_exception.c
View File

@ -134,8 +134,8 @@ bool py_matchexc(py_Type type) {
void py_clearexc(py_StackRef p0) {
VM* vm = pk_current_vm;
vm->last_retval = *py_NIL;
vm->curr_exception = *py_NIL;
vm->last_retval = *py_NIL();
vm->curr_exception = *py_NIL();
vm->is_curr_exc_handled = false;
/* Don't clear this, because StopIteration() may corrupt the class defination */

2
src/public/py_list.c
View File

@ -444,6 +444,6 @@ py_Type pk_list__register() {
py_bind(py_tpobject(type), "sort(self, key=None, reverse=False)", list_sort);
py_setdict(py_tpobject(type), __hash__, py_None);
py_setdict(py_tpobject(type), __hash__, py_None());
return type;
}

2
src/public/py_property.c
View File

@ -8,7 +8,7 @@ static bool property__new__(int argc, py_Ref argv) {
py_newobject(py_retval(), tp_property, 2, 0);
if(argc == 1 + 1) {
py_setslot(py_retval(), 0, py_arg(1));
py_setslot(py_retval(), 1, py_None);
py_setslot(py_retval(), 1, py_None());
} else if(argc == 1 + 2) {
py_setslot(py_retval(), 0, py_arg(1));
py_setslot(py_retval(), 1, py_arg(2));

2
src/public/py_slice.c
View File

@ -100,7 +100,7 @@ py_Type pk_slice__register() {
py_bindmagic(type, __eq__, slice__eq__);
py_bindmagic(type, __ne__, slice__ne__);
py_setdict(py_tpobject(type), __hash__, py_None);
py_setdict(py_tpobject(type), __hash__, py_None());
py_bindproperty(type, "start", slice_start, NULL);
py_bindproperty(type, "stop", slice_stop, NULL);

2
src/public/stack_ops.c
View File

@ -30,7 +30,7 @@ void py_setdict(py_Ref self, py_Name name, py_Ref val) {
}
py_ItemRef py_emplacedict(py_Ref self, py_Name name){
py_setdict(self, name, py_NIL);
py_setdict(self, name, py_NIL());
return py_getdict(self, name);
}

2
src/public/values.c
View File

@ -67,7 +67,7 @@ void py_bindproperty(py_Type type, const char* name, py_CFunction getter, py_CFu
if(setter) {
py_newnativefunc(py_getslot(&tmp, 1), setter);
} else {
py_setslot(&tmp, 1, py_None);
py_setslot(&tmp, 1, py_None());
}
py_setdict(py_tpobject(type), py_name(name), &tmp);
}