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

...

Browse Source
This commit is contained in:
blueloveTH 2023-07-09 16:10:15 +08:00
parent 9d91801626
commit 85a9588459
16 changed files with 216 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -30,3 +30,4 @@ APPS
build
pocketpy.dSYM
main

18
CMakeLists.txt
View File

@ -26,31 +26,25 @@ else()
endif()
endif()
option(PK_EXPORT_C_API "Export C API" ON)
option(PK_EXPORT_CXX_API "Export C++ API" OFF)
include_directories(${CMAKE_CURRENT_LIST_DIR}/include)
if(PK_EXPORT_C_API)
message(STATUS "Exporting C API")
include_directories(${CMAKE_CURRENT_LIST_DIR}/c_bindings)
set(PK_LIB_CPP ${CMAKE_CURRENT_LIST_DIR}/c_bindings/pocketpy_c.cpp)
else()
set(PK_LIB_CPP ${CMAKE_CURRENT_LIST_DIR}/src2/lib.cpp)
endif()
aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/src POCKETPY_SRC)
option(PK_BUILD_SHARED_LIB "Build shared library" OFF)
option(PK_BUILD_STATIC_LIB "Build static library" OFF)
if (PK_EXPORT_CXX_API)
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
endif()
if(PK_BUILD_SHARED_LIB)
add_library(${PROJECT_NAME} SHARED ${POCKETPY_SRC} ${PK_LIB_CPP})
add_library(${PROJECT_NAME} SHARED ${POCKETPY_SRC})
elseif(PK_BUILD_STATIC_LIB)
add_library(${PROJECT_NAME} STATIC ${POCKETPY_SRC} ${PK_LIB_CPP})
add_library(${PROJECT_NAME} STATIC ${POCKETPY_SRC})
else()
add_library(${PROJECT_NAME} SHARED ${POCKETPY_SRC} ${PK_LIB_CPP})
add_library(${PROJECT_NAME} SHARED ${POCKETPY_SRC})
set(PROJECT_EXE_NAME main)
add_executable(${PROJECT_EXE_NAME} src2/main.cpp)
target_link_libraries(${PROJECT_EXE_NAME} ${PROJECT_NAME})

18
amalgamate.py
View File

@ -10,7 +10,7 @@ pipeline = [
["obj.h", "dict.h", "codeobject.h", "frame.h"],
["gc.h", "vm.h", "ceval.h", "expr.h", "compiler.h", "repl.h"],
["_generated.h", "cffi.h", "bindings.h", "iter.h", "base64.h", "random.h", "re.h", "linalg.h", "easing.h", "io.h"],
["pocketpy.h"]
["pocketpy.h", "pocketpy_c.h"]
]
copied = set()
@ -88,28 +88,12 @@ if sys.platform in ['linux', 'darwin']:
print("amalgamated/pocketpy.h")
content = []
for i in ["include/pocketpy/export.h", "c_bindings/pocketpy_c.h", "c_bindings/pocketpy_c.cpp"]:
with open(i, "rt", encoding='utf-8') as g:
content.append(g.read())
with open("amalgamated/pocketpy.cpp", "wt", encoding='utf-8') as f:
content = '\n\n'.join(content)
content = content.replace('#include "pocketpy/export.h"', '')
content = content.replace('#include "pocketpy_c.h"', '')
f.write(content)
shutil.copy("amalgamated/pocketpy.h", "plugins/flutter/src/pocketpy.h")
shutil.copy("amalgamated/pocketpy.cpp", "plugins/flutter/src/pocketpy.cpp")
shutil.copy("amalgamated/pocketpy.h", "plugins/macos/pocketpy/pocketpy.h")
shutil.copy("amalgamated/pocketpy.cpp", "plugins/macos/pocketpy/pocketpy.cpp")
# unity plugin
unity_ios_root = 'plugins/unity/PocketPyUnityPlugin/Assets/PocketPython/Plugins/iOS'
if os.path.exists(unity_ios_root):
shutil.copy("amalgamated/pocketpy.h", unity_ios_root)
shutil.copy("amalgamated/pocketpy.cpp", unity_ios_root)

22
include/pocketpy/common.h
View File

@ -150,25 +150,3 @@ inline PyObject* const PY_OP_YIELD = (PyObject*)0b110011;
#define ADD_MODULE_PLACEHOLDER(name) namespace pkpy { inline void add_module_##name(void* vm) { (void)vm; } }
} // namespace pkpy
#ifdef _WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <Windows.h>
#elif __EMSCRIPTEN__
#include <emscripten.h>
#elif __unix__
#include <dlfcn.h>
#endif

26
include/pocketpy/export.h
View File

@ -9,11 +9,27 @@
#define PK_EXPORT __attribute__((visibility("default")))
#endif
#define PK_INLINE_EXPORT PK_EXPORT inline
#endif
#ifdef PK_SHARED_MODULE
#undef PK_INLINE_EXPORT
#define PK_INLINE_EXPORT inline
#ifdef _WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <Windows.h>
#elif __EMSCRIPTEN__
#include <emscripten.h>
#elif __unix__
#include <dlfcn.h>
#endif

4
include/pocketpy/memory.h
View File

@ -246,8 +246,8 @@ struct MemoryPool{
}
};
PK_EXPORT inline MemoryPool<64> pool64;
PK_EXPORT inline MemoryPool<128> pool128;
inline MemoryPool<64> pool64;
inline MemoryPool<128> pool128;
template <typename T>
struct shared_ptr {

79
include/pocketpy/pocketpy.h
View File

@ -95,82 +95,3 @@ void add_module_traceback(VM* vm);
void add_module_gc(VM* vm);
} // namespace pkpy
/*************************GLOBAL NAMESPACE*************************/
extern "C" {
PK_INLINE_EXPORT
void pkpy_free(void* p){
free(p);
}
PK_INLINE_EXPORT
void pkpy_vm_exec(pkpy::VM* vm, const char* source){
vm->exec(source, "main.py", pkpy::EXEC_MODE);
}
PK_INLINE_EXPORT
void pkpy_vm_exec_2(pkpy::VM* vm, const char* source, const char* filename, int mode, const char* module){
pkpy::PyObject* mod;
if(module == nullptr) mod = vm->_main;
else{
mod = vm->_modules.try_get(module);
if(mod == nullptr) return;
}
vm->exec(source, filename, (pkpy::CompileMode)mode, mod);
}
PK_INLINE_EXPORT
void pkpy_vm_compile(pkpy::VM* vm, const char* source, const char* filename, int mode, bool* ok, char** res){
try{
pkpy::CodeObject_ code = vm->compile(source, filename, (pkpy::CompileMode)mode);
*res = code->serialize(vm).c_str_dup();
*ok = true;
}catch(pkpy::Exception& e){
*ok = false;
*res = e.summary().c_str_dup();
}catch(std::exception& e){
*ok = false;
*res = strdup(e.what());
}catch(...){
*ok = false;
*res = strdup("unknown error");
}
}
PK_INLINE_EXPORT
pkpy::REPL* pkpy_new_repl(pkpy::VM* vm){
pkpy::REPL* p = new pkpy::REPL(vm);
return p;
}
PK_INLINE_EXPORT
bool pkpy_repl_input(pkpy::REPL* r, const char* line){
return r->input(line);
}
PK_INLINE_EXPORT
void pkpy_vm_add_module(pkpy::VM* vm, const char* name, const char* source){
vm->_lazy_modules[name] = source;
}
PK_INLINE_EXPORT
pkpy::VM* pkpy_new_vm(bool enable_os=true){
pkpy::VM* p = new pkpy::VM(enable_os);
return p;
}
PK_INLINE_EXPORT
void pkpy_delete_vm(pkpy::VM* vm){
delete vm;
}
PK_INLINE_EXPORT
void pkpy_delete_repl(pkpy::REPL* repl){
delete repl;
}
PK_INLINE_EXPORT
void pkpy_vm_gc_on_delete(pkpy::VM* vm, void (*f)(pkpy::VM *, pkpy::PyObject *)){
vm->heap._gc_on_delete = f;
}
}

39
c_bindings/pocketpy_c.h → include/pocketpy/pocketpy_c.h
View File

@ -8,7 +8,7 @@ extern "C" {
#include <stdbool.h>
#include <stdint.h>
#include "pocketpy/export.h"
#include "export.h"
typedef struct pkpy_vm_handle pkpy_vm;
@ -119,4 +119,41 @@ PK_EXPORT bool pkpy_eval(pkpy_vm*, const char* source);
}
#endif
/*************************GLOBAL NAMESPACE*************************/
extern "C" {
PK_EXPORT
void pkpy_free(void* p);
PK_EXPORT
void pkpy_vm_exec(void* vm, const char* source);
PK_EXPORT
void pkpy_vm_exec_2(void* vm, const char* source, const char* filename, int mode, const char* module);
PK_EXPORT
void pkpy_vm_compile(void* vm, const char* source, const char* filename, int mode, bool* ok, char** res);
PK_EXPORT
void* pkpy_new_repl(void* vm);
PK_EXPORT
bool pkpy_repl_input(void* r, const char* line);
PK_EXPORT
void pkpy_vm_add_module(void* vm, const char* name, const char* source);
PK_EXPORT
void* pkpy_new_vm(bool enable_os=true);
PK_EXPORT
void pkpy_delete_vm(void* vm);
PK_EXPORT
void pkpy_delete_repl(void* repl);
}
#endif

2
include/pocketpy/repl.h
View File

@ -5,8 +5,6 @@
namespace pkpy{
std::string platform_getline(bool* eof=nullptr);
class REPL {
protected:
int need_more_lines = 0;

3
include/pocketpy_c.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
#include "pocketpy/pocketpy_c.h"

24
src/pocketpy.cpp
View File

@ -11,7 +11,29 @@ static dylib_entry_t load_dylib(const char* path){
std::error_code ec;
auto p = std::filesystem::absolute(path, ec);
if(ec) return nullptr;
HMODULE handle = LoadLibraryA((LPCSTR)p.c_str());
HMODULE handle = LoadLibraryA((LPCSTR)"test.dll");
// get last error
// Get the last error code
SetErrorMode(SEM_FAILCRITICALERRORS);
DWORD errorCode = GetLastError();
// Convert the error code to text
LPSTR errorMessage = nullptr;
FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr,
errorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR)&errorMessage,
0,
nullptr
);
// Print the error message to stdout
printf("%lu: %s\n", errorCode, errorMessage);
// Free the message buffer
LocalFree(errorMessage);
if(!handle) return nullptr;
return (dylib_entry_t)GetProcAddress(handle, "platform_module__init__");
}

64
c_bindings/pocketpy_c.cpp → src/pocketpy_c.cpp
View File

@ -552,3 +552,67 @@ bool pkpy_eval(pkpy_vm* vm_handle, const char* code) {
ERRHANDLER_CLOSE
return true;
}
/*****************************************************************/
void pkpy_free(void* p){
free(p);
}
void pkpy_vm_exec(void* vm, const char* source){
((VM*)vm)->exec(source, "main.py", EXEC_MODE);
}
void pkpy_vm_exec_2(void* vm_, const char* source, const char* filename, int mode, const char* module){
VM* vm = (VM*)vm_;
PyObject* mod;
if(module == nullptr) mod = vm->_main;
else{
mod = vm->_modules.try_get(module);
if(mod == nullptr) return;
}
vm->exec(source, filename, (CompileMode)mode, mod);
}
void pkpy_vm_compile(void* vm_, const char* source, const char* filename, int mode, bool* ok, char** res){
VM* vm = (VM*)vm_;
try{
CodeObject_ code = vm->compile(source, filename, (CompileMode)mode);
*res = code->serialize(vm).c_str_dup();
*ok = true;
}catch(Exception& e){
*ok = false;
*res = e.summary().c_str_dup();
}catch(std::exception& e){
*ok = false;
*res = strdup(e.what());
}catch(...){
*ok = false;
*res = strdup("unknown error");
}
}
void* pkpy_new_repl(void* vm){
return new REPL((VM*)vm);
}
bool pkpy_repl_input(void* r, const char* line){
return ((REPL*)r)->input(line);
}
void pkpy_vm_add_module(void* vm, const char* name, const char* source){
((VM*)vm)->_lazy_modules[name] = source;
}
void* pkpy_new_vm(bool enable_os){
void* p = new VM(enable_os);
return p;
}
void pkpy_delete_vm(void* vm){
delete (VM*)vm;
}
void pkpy_delete_repl(void* repl){
delete (REPL*)repl;
}

33
src/repl.cpp
View File

@ -1,39 +1,6 @@
#include "pocketpy/repl.h"
namespace pkpy {
#ifdef _WIN32
std::string platform_getline(bool* eof){
HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
std::wstringstream wss;
WCHAR buf;
DWORD read;
while (ReadConsoleW(hStdin, &buf, 1, &read, NULL) && buf != L'\n') {
if(eof && buf == L'\x1A') *eof = true; // Ctrl+Z
wss << buf;
}
std::wstring wideInput = wss.str();
int length = WideCharToMultiByte(CP_UTF8, 0, wideInput.c_str(), (int)wideInput.length(), NULL, 0, NULL, NULL);
std::string output;
output.resize(length);
WideCharToMultiByte(CP_UTF8, 0, wideInput.c_str(), (int)wideInput.length(), &output[0], length, NULL, NULL);
if(!output.empty() && output.back() == '\r') output.pop_back();
return output;
}
#else
std::string platform_getline(bool* eof){
std::string line;
if(!std::getline(std::cin, line)){
if(eof) *eof = true;
}
return line;
}
#endif
REPL::REPL(VM* vm) : vm(vm){
vm->_stdout(vm, "pocketpy " PK_VERSION " (" __DATE__ ", " __TIME__ ") ");
vm->_stdout(vm, fmt("[", sizeof(void*)*8, " bit]" "\n"));

1
src2/lib.cpp
View File

@ -1 +0,0 @@
#include "pocketpy.h"

65
src2/main.cpp
View File

@ -1,33 +1,72 @@
#include <fstream>
#include <filesystem>
#include <iostream>
#include "pocketpy.h"
#include "pocketpy_c.h"
std::string f_input(){
return pkpy::platform_getline();
#ifdef _WIN32
void pkpy_platform_getline(char* buffer, int size, bool* eof){
HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
std::wstringstream wss;
WCHAR buf;
DWORD read;
while (ReadConsoleW(hStdin, &buf, 1, &read, NULL) && buf != L'\n') {
if(eof && buf == L'\x1A') *eof = true; // Ctrl+Z
wss << buf;
}
std::wstring wideInput = wss.str();
int length = WideCharToMultiByte(CP_UTF8, 0, wideInput.c_str(), (int)wideInput.length(), NULL, 0, NULL, NULL);
std::string output;
output.resize(length);
WideCharToMultiByte(CP_UTF8, 0, wideInput.c_str(), (int)wideInput.length(), &output[0], length, NULL, NULL);
if(!output.empty() && output.back() == '\r') output.pop_back();
size = std::min<int>(size-1, output.size());
for(int i=0; i<size; i++) buffer[i] = output[i];
buffer[size] = '\0';
}
#else
void pkpy_platform_getline(char* buffer, int size, bool* eof){
std::string output;
if(!std::getline(std::cin, output)){
if(eof) *eof = true;
}
size = std::min<int>(size-1, output.size());
for(int i=0; i<size; i++) buffer[i] = output[i];
buffer[size] = '\0';
}
#endif
// std::string f_input(){
// return pkpy::platform_getline();
// }
int main(int argc, char** argv){
char buffer[1024];
#if _WIN32
SetConsoleOutputCP(CP_UTF8);
// implicitly load pocketpy.dll in current directory
#elif __linux__
dlopen("libpocketpy.so", RTLD_NOW | RTLD_GLOBAL);
#elif __APPLE__
dlopen("libpocketpy.dylib", RTLD_NOW | RTLD_GLOBAL);
#endif
pkpy::VM* vm = pkpy_new_vm();
pkpy::_bind(vm, vm->builtins, "input() -> str", &f_input);
void* vm = pkpy_new_vm();
// pkpy::_bind(vm, vm->builtins, "input() -> str", &f_input);
if(argc == 1){
pkpy::REPL* repl = pkpy_new_repl(vm);
void* repl = pkpy_new_repl(vm);
bool need_more_lines = false;
while(true){
vm->_stdout(vm, need_more_lines ? "... " : ">>> ");
std::cout << (need_more_lines ? "... " : ">>> ");
bool eof = false;
std::string line = pkpy::platform_getline(&eof);
pkpy_platform_getline(buffer, 1024, &eof);
if(eof) break;
need_more_lines = pkpy_repl_input(repl, line.c_str());
need_more_lines = pkpy_repl_input(repl, buffer);
}
pkpy_delete_vm(vm);
return 0;
@ -54,10 +93,10 @@ int main(int argc, char** argv){
// set parent path as cwd
std::filesystem::current_path(filepath.parent_path());
pkpy::PyObject* ret = nullptr;
ret = vm->exec(src.c_str(), filepath.filename().string(), pkpy::EXEC_MODE);
pkpy_vm_exec_2(vm, src.c_str(), filepath.filename().string().c_str(), 0, NULL);
pkpy_delete_vm(vm);
return ret != nullptr ? 0 : 1;
// return ret != nullptr ? 0 : 1;
return 0;
}
__HELP:

12
tests/dylib/test.cpp
View File

@ -1,4 +1,3 @@
#define PK_SHARED_MODULE
#include "pocketpy.h"
using namespace pkpy;
@ -15,15 +14,4 @@ extern "C" {
});
return mod;
}
#if _WIN32
BOOL WINAPI DllMain(
HINSTANCE hinstDLL, // handle to DLL module
DWORD fdwReason, // reason for calling function
LPVOID lpvReserved ) // reserved
{
return TRUE; // Successful DLL_PROCESS_ATTACH.
}
#endif
}