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

add FileIO and open

Browse Source
This commit is contained in:
BLUELOVETH 2023-02-13 17:38:35 +00:00
parent 418101df19
commit 0e4052744b
6 changed files with 198 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/common.h
View File

@ -23,16 +23,18 @@
#include <memory> #include <memory>
#include <functional> #include <functional>
#include <iostream> #include <iostream>
// #include <filesystem>
// namespace fs = std::filesystem;
#include "hash_table8.hpp" #include "hash_table8.hpp"
#ifdef POCKETPY_H #ifdef POCKETPY_H
#define UNREACHABLE() throw std::runtime_error( "L" + std::to_string(__LINE__) + " UNREACHABLE()! This should be a bug, please report it"); #define UNREACHABLE() throw std::runtime_error( "L" + std::to_string(__LINE__) + " UNREACHABLE()!");
#else #else
#define UNREACHABLE() throw std::runtime_error( __FILE__ + std::string(":") + std::to_string(__LINE__) + " UNREACHABLE()!"); #define UNREACHABLE() throw std::runtime_error( __FILE__ + std::string(":") + std::to_string(__LINE__) + " UNREACHABLE()!");
#endif #endif
#define PK_VERSION "0.8.6" #define PK_VERSION "0.8.7"
typedef int64_t i64; typedef int64_t i64;
typedef double f64; typedef double f64;
@ -60,3 +62,5 @@ void* tid() {
//#define THREAD_LOCAL thread_local //#define THREAD_LOCAL thread_local
#define THREAD_LOCAL #define THREAD_LOCAL
#define RAW(T) std::remove_const_t<std::remove_reference_t<T>>

2
src/main.cpp
View File

@ -5,7 +5,7 @@
int main(int argc, char** argv){ int main(int argc, char** argv){
VM* vm = pkpy_new_vm(true); VM* vm = pkpy_new_vm(true);
vm->bind_builtin_func<0>("input", [](VM* vm, const pkpy::Args& args){ vm->bind_builtin_func<0>("input", [](VM* vm, pkpy::Args& args){
static std::string line; static std::string line;
std::getline(std::cin, line); std::getline(std::cin, line);
return vm->PyStr(line); return vm->PyStr(line);

9
src/obj.h
View File

@ -7,7 +7,7 @@ struct Frame;
struct BaseRef; struct BaseRef;
class VM; class VM;
typedef std::function<PyVar(VM*, const pkpy::Args&)> NativeFuncRaw; typedef std::function<PyVar(VM*, pkpy::Args&)> NativeFuncRaw;
typedef pkpy::shared_ptr<CodeObject> CodeObject_; typedef pkpy::shared_ptr<CodeObject> CodeObject_;
namespace pkpy{ namespace pkpy{
@ -17,7 +17,7 @@ struct NativeFunc {
bool method; bool method;
NativeFunc(NativeFuncRaw f, int argc, bool method) : f(f), argc(argc), method(method) {} NativeFunc(NativeFuncRaw f, int argc, bool method) : f(f), argc(argc), method(method) {}
inline PyVar operator()(VM* vm, const pkpy::Args& args) const; inline PyVar operator()(VM* vm, pkpy::Args& args) const;
}; };
struct Function { struct Function {
@ -94,7 +94,10 @@ template <typename T>
struct Py_ : PyObject { struct Py_ : PyObject {
T _value; T _value;
Py_(Type type, T val) : PyObject(type, sizeof(Py_<T>)), _value(val) { Py_(Type type, const T& val): PyObject(type, sizeof(Py_<T>)), _value(val) { _init(); }
Py_(Type type, T&& val): PyObject(type, sizeof(Py_<T>)), _value(std::move(val)) { _init(); }
inline void _init() noexcept {
if constexpr (std::is_same_v<T, Dummy> || std::is_same_v<T, Type> if constexpr (std::is_same_v<T, Dummy> || std::is_same_v<T, Type>
|| std::is_same_v<T, pkpy::Function_> || std::is_same_v<T, pkpy::NativeFunc>) { || std::is_same_v<T, pkpy::Function_> || std::is_same_v<T, pkpy::NativeFunc>) {
_attr = new pkpy::NameDict(); _attr = new pkpy::NameDict();

223
src/pocketpy.h
View File

@ -5,8 +5,8 @@
#include "repl.h" #include "repl.h"
#include "iter.h" #include "iter.h"
#define CPP_LAMBDA(x) ([](VM* vm, const pkpy::Args& args) { return x; }) #define CPP_LAMBDA(x) ([](VM* vm, pkpy::Args& args) { return x; })
#define CPP_NOT_IMPLEMENTED() ([](VM* vm, const pkpy::Args& args) { vm->NotImplementedError(); return vm->None; }) #define CPP_NOT_IMPLEMENTED() ([](VM* vm, pkpy::Args& args) { vm->NotImplementedError(); return vm->None; })
CodeObject_ VM::compile(Str source, Str filename, CompileMode mode) { CodeObject_ VM::compile(Str source, Str filename, CompileMode mode) {
Compiler compiler(this, source.c_str(), filename, mode); Compiler compiler(this, source.c_str(), filename, mode);
@ -19,7 +19,7 @@ CodeObject_ VM::compile(Str source, Str filename, CompileMode mode) {
} }
#define BIND_NUM_ARITH_OPT(name, op) \ #define BIND_NUM_ARITH_OPT(name, op) \
_vm->_bind_methods<1>({"int","float"}, #name, [](VM* vm, const pkpy::Args& args){ \ _vm->_bind_methods<1>({"int","float"}, #name, [](VM* vm, pkpy::Args& args){ \
if(args[0]->is_type(vm->tp_int) && args[1]->is_type(vm->tp_int)){ \ if(args[0]->is_type(vm->tp_int) && args[1]->is_type(vm->tp_int)){ \
return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \ return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \
}else{ \ }else{ \
@ -28,7 +28,7 @@ CodeObject_ VM::compile(Str source, Str filename, CompileMode mode) {
}); });
#define BIND_NUM_LOGICAL_OPT(name, op, is_eq) \ #define BIND_NUM_LOGICAL_OPT(name, op, is_eq) \
_vm->_bind_methods<1>({"int","float"}, #name, [](VM* vm, const pkpy::Args& args){ \ _vm->_bind_methods<1>({"int","float"}, #name, [](VM* vm, pkpy::Args& args){ \
bool _0 = args[0]->is_type(vm->tp_int) || args[0]->is_type(vm->tp_float); \ bool _0 = args[0]->is_type(vm->tp_int) || args[0]->is_type(vm->tp_float); \
bool _1 = args[1]->is_type(vm->tp_int) || args[1]->is_type(vm->tp_float); \ bool _1 = args[1]->is_type(vm->tp_int) || args[1]->is_type(vm->tp_float); \
if(!_0 || !_1){ \ if(!_0 || !_1){ \
@ -54,29 +54,29 @@ void init_builtins(VM* _vm) {
#undef BIND_NUM_ARITH_OPT #undef BIND_NUM_ARITH_OPT
#undef BIND_NUM_LOGICAL_OPT #undef BIND_NUM_LOGICAL_OPT
_vm->bind_builtin_func<1>("__sys_stdout_write", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<1>("__sys_stdout_write", [](VM* vm, pkpy::Args& args) {
(*vm->_stdout) << vm->PyStr_AS_C(args[0]); (*vm->_stdout) << vm->PyStr_AS_C(args[0]);
return vm->None; return vm->None;
}); });
_vm->bind_builtin_func<0>("super", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<0>("super", [](VM* vm, pkpy::Args& args) {
auto it = vm->top_frame()->f_locals().find(m_self); const PyVar* self = vm->top_frame()->f_locals().try_get(m_self);
if(it == vm->top_frame()->f_locals().end()) vm->TypeError("super() can only be called in a class method"); if(self == nullptr) vm->TypeError("super() can only be called in a class");
return vm->new_object(vm->tp_super, it->second); return vm->new_object(vm->tp_super, *self);
}); });
_vm->bind_builtin_func<1>("eval", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<1>("eval", [](VM* vm, pkpy::Args& args) {
CodeObject_ code = vm->compile(vm->PyStr_AS_C(args[0]), "<eval>", EVAL_MODE); CodeObject_ code = vm->compile(vm->PyStr_AS_C(args[0]), "<eval>", EVAL_MODE);
return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals); return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals);
}); });
_vm->bind_builtin_func<1>("exec", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<1>("exec", [](VM* vm, pkpy::Args& args) {
CodeObject_ code = vm->compile(vm->PyStr_AS_C(args[0]), "<exec>", EXEC_MODE); CodeObject_ code = vm->compile(vm->PyStr_AS_C(args[0]), "<exec>", EXEC_MODE);
vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals); vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals);
return vm->None; return vm->None;
}); });
_vm->bind_builtin_func<-1>("exit", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<-1>("exit", [](VM* vm, pkpy::Args& args) {
if(args.size() == 0) std::exit(0); if(args.size() == 0) std::exit(0);
else if(args.size() == 1) std::exit((int)vm->PyInt_AS_C(args[0])); else if(args.size() == 1) std::exit((int)vm->PyInt_AS_C(args[0]));
else vm->TypeError("exit() takes at most 1 argument"); else vm->TypeError("exit() takes at most 1 argument");
@ -87,40 +87,39 @@ void init_builtins(VM* _vm) {
_vm->bind_builtin_func<1>("hash", CPP_LAMBDA(vm->PyInt(vm->hash(args[0])))); _vm->bind_builtin_func<1>("hash", CPP_LAMBDA(vm->PyInt(vm->hash(args[0]))));
_vm->bind_builtin_func<1>("len", CPP_LAMBDA(vm->call(args[0], __len__, pkpy::no_arg()))); _vm->bind_builtin_func<1>("len", CPP_LAMBDA(vm->call(args[0], __len__, pkpy::no_arg())));
_vm->bind_builtin_func<1>("chr", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<1>("chr", [](VM* vm, pkpy::Args& args) {
i64 i = vm->PyInt_AS_C(args[0]); i64 i = vm->PyInt_AS_C(args[0]);
if (i < 0 || i > 128) vm->ValueError("chr() arg not in range(128)"); if (i < 0 || i > 128) vm->ValueError("chr() arg not in range(128)");
return vm->PyStr(std::string(1, (char)i)); return vm->PyStr(std::string(1, (char)i));
}); });
_vm->bind_builtin_func<1>("ord", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<1>("ord", [](VM* vm, pkpy::Args& args) {
Str s = vm->PyStr_AS_C(args[0]); Str s = vm->PyStr_AS_C(args[0]);
if (s.size() != 1) vm->TypeError("ord() expected an ASCII character"); if (s.size() != 1) vm->TypeError("ord() expected an ASCII character");
return vm->PyInt((i64)(s.c_str()[0])); return vm->PyInt((i64)(s.c_str()[0]));
}); });
_vm->bind_builtin_func<2>("hasattr", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<2>("hasattr", [](VM* vm, pkpy::Args& args) {
return vm->PyBool(vm->getattr(args[0], vm->PyStr_AS_C(args[1]), false) != nullptr); return vm->PyBool(vm->getattr(args[0], vm->PyStr_AS_C(args[1]), false) != nullptr);
}); });
_vm->bind_builtin_func<3>("setattr", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<3>("setattr", [](VM* vm, pkpy::Args& args) {
PyVar obj = args[0]; vm->setattr(args[0], vm->PyStr_AS_C(args[1]), args[2]);
vm->setattr(obj, vm->PyStr_AS_C(args[1]), args[2]);
return vm->None; return vm->None;
}); });
_vm->bind_builtin_func<2>("getattr", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<2>("getattr", [](VM* vm, pkpy::Args& args) {
Str name = vm->PyStr_AS_C(args[1]); Str name = vm->PyStr_AS_C(args[1]);
return vm->getattr(args[0], name); return vm->getattr(args[0], name);
}); });
_vm->bind_builtin_func<1>("hex", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<1>("hex", [](VM* vm, pkpy::Args& args) {
std::stringstream ss; std::stringstream ss;
ss << std::hex << vm->PyInt_AS_C(args[0]); ss << std::hex << vm->PyInt_AS_C(args[0]);
return vm->PyStr("0x" + ss.str()); return vm->PyStr("0x" + ss.str());
}); });
_vm->bind_builtin_func<1>("dir", [](VM* vm, const pkpy::Args& args) { _vm->bind_builtin_func<1>("dir", [](VM* vm, pkpy::Args& args) {
std::vector<Str> names; std::vector<Str> names;
if(args[0]->is_attr_valid()){ if(args[0]->is_attr_valid()){
for (auto& [k, _] : args[0]->attr()) names.push_back(k); for (auto& [k, _] : args[0]->attr()) names.push_back(k);
@ -133,7 +132,7 @@ void init_builtins(VM* _vm) {
return vm->PyList(std::move(ret)); return vm->PyList(std::move(ret));
}); });
_vm->bind_method<0>("object", "__repr__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("object", "__repr__", [](VM* vm, pkpy::Args& args) {
PyVar self = args[0]; PyVar self = args[0];
StrStream ss; StrStream ss;
ss << std::hex << (uintptr_t)self.get(); ss << std::hex << (uintptr_t)self.get();
@ -146,7 +145,7 @@ void init_builtins(VM* _vm) {
_vm->bind_static_method<1>("type", "__new__", CPP_LAMBDA(vm->_t(args[0]))); _vm->bind_static_method<1>("type", "__new__", CPP_LAMBDA(vm->_t(args[0])));
_vm->bind_static_method<-1>("range", "__new__", [](VM* vm, const pkpy::Args& args) { _vm->bind_static_method<-1>("range", "__new__", [](VM* vm, pkpy::Args& args) {
pkpy::Range r; pkpy::Range r;
switch (args.size()) { switch (args.size()) {
case 1: r.stop = vm->PyInt_AS_C(args[0]); break; case 1: r.stop = vm->PyInt_AS_C(args[0]); break;
@ -164,13 +163,13 @@ void init_builtins(VM* _vm) {
_vm->bind_method<0>("NoneType", "__repr__", CPP_LAMBDA(vm->PyStr("None"))); _vm->bind_method<0>("NoneType", "__repr__", CPP_LAMBDA(vm->PyStr("None")));
_vm->bind_method<0>("NoneType", "__json__", CPP_LAMBDA(vm->PyStr("null"))); _vm->bind_method<0>("NoneType", "__json__", CPP_LAMBDA(vm->PyStr("null")));
_vm->_bind_methods<1>({"int", "float"}, "__truediv__", [](VM* vm, const pkpy::Args& args) { _vm->_bind_methods<1>({"int", "float"}, "__truediv__", [](VM* vm, pkpy::Args& args) {
f64 rhs = vm->num_to_float(args[1]); f64 rhs = vm->num_to_float(args[1]);
if (rhs == 0) vm->ZeroDivisionError(); if (rhs == 0) vm->ZeroDivisionError();
return vm->PyFloat(vm->num_to_float(args[0]) / rhs); return vm->PyFloat(vm->num_to_float(args[0]) / rhs);
}); });
_vm->_bind_methods<1>({"int", "float"}, "__pow__", [](VM* vm, const pkpy::Args& args) { _vm->_bind_methods<1>({"int", "float"}, "__pow__", [](VM* vm, pkpy::Args& args) {
if(args[0]->is_type(vm->tp_int) && args[1]->is_type(vm->tp_int)){ if(args[0]->is_type(vm->tp_int) && args[1]->is_type(vm->tp_int)){
return vm->PyInt((i64)round(pow(vm->PyInt_AS_C(args[0]), vm->PyInt_AS_C(args[1])))); return vm->PyInt((i64)round(pow(vm->PyInt_AS_C(args[0]), vm->PyInt_AS_C(args[1]))));
}else{ }else{
@ -179,7 +178,7 @@ void init_builtins(VM* _vm) {
}); });
/************ PyInt ************/ /************ PyInt ************/
_vm->bind_static_method<1>("int", "__new__", [](VM* vm, const pkpy::Args& args) { _vm->bind_static_method<1>("int", "__new__", [](VM* vm, pkpy::Args& args) {
if (args[0]->is_type(vm->tp_int)) return args[0]; if (args[0]->is_type(vm->tp_int)) return args[0];
if (args[0]->is_type(vm->tp_float)) return vm->PyInt((i64)vm->PyFloat_AS_C(args[0])); if (args[0]->is_type(vm->tp_float)) return vm->PyInt((i64)vm->PyFloat_AS_C(args[0]));
if (args[0]->is_type(vm->tp_bool)) return vm->PyInt(vm->PyBool_AS_C(args[0]) ? 1 : 0); if (args[0]->is_type(vm->tp_bool)) return vm->PyInt(vm->PyBool_AS_C(args[0]) ? 1 : 0);
@ -198,28 +197,28 @@ void init_builtins(VM* _vm) {
return vm->None; return vm->None;
}); });
_vm->bind_method<1>("int", "__floordiv__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("int", "__floordiv__", [](VM* vm, pkpy::Args& args) {
i64 rhs = vm->PyInt_AS_C(args[1]); i64 rhs = vm->PyInt_AS_C(args[1]);
if(rhs == 0) vm->ZeroDivisionError(); if(rhs == 0) vm->ZeroDivisionError();
return vm->PyInt(vm->PyInt_AS_C(args[0]) / rhs); return vm->PyInt(vm->PyInt_AS_C(args[0]) / rhs);
}); });
_vm->bind_method<1>("int", "__mod__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("int", "__mod__", [](VM* vm, pkpy::Args& args) {
i64 rhs = vm->PyInt_AS_C(args[1]); i64 rhs = vm->PyInt_AS_C(args[1]);
if(rhs == 0) vm->ZeroDivisionError(); if(rhs == 0) vm->ZeroDivisionError();
return vm->PyInt(vm->PyInt_AS_C(args[0]) % rhs); return vm->PyInt(vm->PyInt_AS_C(args[0]) % rhs);
}); });
_vm->bind_method<0>("int", "__repr__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("int", "__repr__", [](VM* vm, pkpy::Args& args) {
return vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0]))); return vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0])));
}); });
_vm->bind_method<0>("int", "__json__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("int", "__json__", [](VM* vm, pkpy::Args& args) {
return vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0]))); return vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0])));
}); });
#define __INT_BITWISE_OP(name,op) \ #define __INT_BITWISE_OP(name,op) \
_vm->bind_method<1>("int", #name, [](VM* vm, const pkpy::Args& args) { \ _vm->bind_method<1>("int", #name, [](VM* vm, pkpy::Args& args) { \
return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \ return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \
}); });
@ -232,7 +231,7 @@ void init_builtins(VM* _vm) {
#undef __INT_BITWISE_OP #undef __INT_BITWISE_OP
/************ PyFloat ************/ /************ PyFloat ************/
_vm->bind_static_method<1>("float", "__new__", [](VM* vm, const pkpy::Args& args) { _vm->bind_static_method<1>("float", "__new__", [](VM* vm, pkpy::Args& args) {
if (args[0]->is_type(vm->tp_int)) return vm->PyFloat((f64)vm->PyInt_AS_C(args[0])); if (args[0]->is_type(vm->tp_int)) return vm->PyFloat((f64)vm->PyInt_AS_C(args[0]));
if (args[0]->is_type(vm->tp_float)) return args[0]; if (args[0]->is_type(vm->tp_float)) return args[0];
if (args[0]->is_type(vm->tp_bool)) return vm->PyFloat(vm->PyBool_AS_C(args[0]) ? 1.0 : 0.0); if (args[0]->is_type(vm->tp_bool)) return vm->PyFloat(vm->PyBool_AS_C(args[0]) ? 1.0 : 0.0);
@ -251,7 +250,7 @@ void init_builtins(VM* _vm) {
return vm->None; return vm->None;
}); });
_vm->bind_method<0>("float", "__repr__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("float", "__repr__", [](VM* vm, pkpy::Args& args) {
f64 val = vm->PyFloat_AS_C(args[0]); f64 val = vm->PyFloat_AS_C(args[0]);
if(std::isinf(val) || std::isnan(val)) return vm->PyStr(std::to_string(val)); if(std::isinf(val) || std::isnan(val)) return vm->PyStr(std::to_string(val));
StrStream ss; StrStream ss;
@ -261,7 +260,7 @@ void init_builtins(VM* _vm) {
return vm->PyStr(s); return vm->PyStr(s);
}); });
_vm->bind_method<0>("float", "__json__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("float", "__json__", [](VM* vm, pkpy::Args& args) {
f64 val = vm->PyFloat_AS_C(args[0]); f64 val = vm->PyFloat_AS_C(args[0]);
if(std::isinf(val) || std::isnan(val)) vm->ValueError("cannot jsonify 'nan' or 'inf'"); if(std::isinf(val) || std::isnan(val)) vm->ValueError("cannot jsonify 'nan' or 'inf'");
return vm->PyStr(std::to_string(val)); return vm->PyStr(std::to_string(val));
@ -270,18 +269,18 @@ void init_builtins(VM* _vm) {
/************ PyString ************/ /************ PyString ************/
_vm->bind_static_method<1>("str", "__new__", CPP_LAMBDA(vm->asStr(args[0]))); _vm->bind_static_method<1>("str", "__new__", CPP_LAMBDA(vm->asStr(args[0])));
_vm->bind_method<1>("str", "__add__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "__add__", [](VM* vm, pkpy::Args& args) {
const Str& lhs = vm->PyStr_AS_C(args[0]); const Str& lhs = vm->PyStr_AS_C(args[0]);
const Str& rhs = vm->PyStr_AS_C(args[1]); const Str& rhs = vm->PyStr_AS_C(args[1]);
return vm->PyStr(lhs + rhs); return vm->PyStr(lhs + rhs);
}); });
_vm->bind_method<0>("str", "__len__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("str", "__len__", [](VM* vm, pkpy::Args& args) {
const Str& self = vm->PyStr_AS_C(args[0]); const Str& self = vm->PyStr_AS_C(args[0]);
return vm->PyInt(self.u8_length()); return vm->PyInt(self.u8_length());
}); });
_vm->bind_method<1>("str", "__contains__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "__contains__", [](VM* vm, pkpy::Args& args) {
const Str& self = vm->PyStr_AS_C(args[0]); const Str& self = vm->PyStr_AS_C(args[0]);
const Str& other = vm->PyStr_AS_C(args[1]); const Str& other = vm->PyStr_AS_C(args[1]);
return vm->PyBool(self.find(other) != Str::npos); return vm->PyBool(self.find(other) != Str::npos);
@ -293,29 +292,29 @@ void init_builtins(VM* _vm) {
vm->PyIter(pkpy::make_shared<BaseIter, StringIter>(vm, args[0])) vm->PyIter(pkpy::make_shared<BaseIter, StringIter>(vm, args[0]))
)); ));
_vm->bind_method<0>("str", "__repr__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("str", "__repr__", [](VM* vm, pkpy::Args& args) {
const Str& _self = vm->PyStr_AS_C(args[0]); const Str& _self = vm->PyStr_AS_C(args[0]);
return vm->PyStr(_self.escape(true)); return vm->PyStr(_self.escape(true));
}); });
_vm->bind_method<0>("str", "__json__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("str", "__json__", [](VM* vm, pkpy::Args& args) {
const Str& _self = vm->PyStr_AS_C(args[0]); const Str& _self = vm->PyStr_AS_C(args[0]);
return vm->PyStr(_self.escape(false)); return vm->PyStr(_self.escape(false));
}); });
_vm->bind_method<1>("str", "__eq__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "__eq__", [](VM* vm, pkpy::Args& args) {
if(args[0]->is_type(vm->tp_str) && args[1]->is_type(vm->tp_str)) if(args[0]->is_type(vm->tp_str) && args[1]->is_type(vm->tp_str))
return vm->PyBool(vm->PyStr_AS_C(args[0]) == vm->PyStr_AS_C(args[1])); return vm->PyBool(vm->PyStr_AS_C(args[0]) == vm->PyStr_AS_C(args[1]));
return vm->PyBool(args[0] == args[1]); return vm->PyBool(args[0] == args[1]);
}); });
_vm->bind_method<1>("str", "__ne__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "__ne__", [](VM* vm, pkpy::Args& args) {
if(args[0]->is_type(vm->tp_str) && args[1]->is_type(vm->tp_str)) if(args[0]->is_type(vm->tp_str) && args[1]->is_type(vm->tp_str))
return vm->PyBool(vm->PyStr_AS_C(args[0]) != vm->PyStr_AS_C(args[1])); return vm->PyBool(vm->PyStr_AS_C(args[0]) != vm->PyStr_AS_C(args[1]));
return vm->PyBool(args[0] != args[1]); return vm->PyBool(args[0] != args[1]);
}); });
_vm->bind_method<1>("str", "__getitem__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "__getitem__", [](VM* vm, pkpy::Args& args) {
const Str& _self (vm->PyStr_AS_C(args[0])); const Str& _self (vm->PyStr_AS_C(args[0]));
if(args[1]->is_type(vm->tp_slice)){ if(args[1]->is_type(vm->tp_slice)){
@ -329,19 +328,19 @@ void init_builtins(VM* _vm) {
return vm->PyStr(_self.u8_getitem(_index)); return vm->PyStr(_self.u8_getitem(_index));
}); });
_vm->bind_method<1>("str", "__gt__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "__gt__", [](VM* vm, pkpy::Args& args) {
const Str& _self (vm->PyStr_AS_C(args[0])); const Str& _self (vm->PyStr_AS_C(args[0]));
const Str& _obj (vm->PyStr_AS_C(args[1])); const Str& _obj (vm->PyStr_AS_C(args[1]));
return vm->PyBool(_self > _obj); return vm->PyBool(_self > _obj);
}); });
_vm->bind_method<1>("str", "__lt__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "__lt__", [](VM* vm, pkpy::Args& args) {
const Str& _self (vm->PyStr_AS_C(args[0])); const Str& _self (vm->PyStr_AS_C(args[0]));
const Str& _obj (vm->PyStr_AS_C(args[1])); const Str& _obj (vm->PyStr_AS_C(args[1]));
return vm->PyBool(_self < _obj); return vm->PyBool(_self < _obj);
}); });
_vm->bind_method<2>("str", "replace", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<2>("str", "replace", [](VM* vm, pkpy::Args& args) {
const Str& _self = vm->PyStr_AS_C(args[0]); const Str& _self = vm->PyStr_AS_C(args[0]);
const Str& _old = vm->PyStr_AS_C(args[1]); const Str& _old = vm->PyStr_AS_C(args[1]);
const Str& _new = vm->PyStr_AS_C(args[2]); const Str& _new = vm->PyStr_AS_C(args[2]);
@ -355,19 +354,19 @@ void init_builtins(VM* _vm) {
return vm->PyStr(_copy); return vm->PyStr(_copy);
}); });
_vm->bind_method<1>("str", "startswith", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "startswith", [](VM* vm, pkpy::Args& args) {
const Str& _self = vm->PyStr_AS_C(args[0]); const Str& _self = vm->PyStr_AS_C(args[0]);
const Str& _prefix = vm->PyStr_AS_C(args[1]); const Str& _prefix = vm->PyStr_AS_C(args[1]);
return vm->PyBool(_self.find(_prefix) == 0); return vm->PyBool(_self.find(_prefix) == 0);
}); });
_vm->bind_method<1>("str", "endswith", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "endswith", [](VM* vm, pkpy::Args& args) {
const Str& _self = vm->PyStr_AS_C(args[0]); const Str& _self = vm->PyStr_AS_C(args[0]);
const Str& _suffix = vm->PyStr_AS_C(args[1]); const Str& _suffix = vm->PyStr_AS_C(args[1]);
return vm->PyBool(_self.rfind(_suffix) == _self.length() - _suffix.length()); return vm->PyBool(_self.rfind(_suffix) == _self.length() - _suffix.length());
}); });
_vm->bind_method<1>("str", "join", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("str", "join", [](VM* vm, pkpy::Args& args) {
const Str& self = vm->PyStr_AS_C(args[0]); const Str& self = vm->PyStr_AS_C(args[0]);
StrStream ss; StrStream ss;
if(args[1]->is_type(vm->tp_list)){ if(args[1]->is_type(vm->tp_list)){
@ -389,13 +388,13 @@ void init_builtins(VM* _vm) {
}); });
/************ PyList ************/ /************ PyList ************/
_vm->bind_method<1>("list", "append", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("list", "append", [](VM* vm, pkpy::Args& args) {
pkpy::List& self = vm->PyList_AS_C(args[0]); pkpy::List& self = vm->PyList_AS_C(args[0]);
self.push_back(args[1]); self.push_back(args[1]);
return vm->None; return vm->None;
}); });
_vm->bind_method<1>("list", "__mul__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("list", "__mul__", [](VM* vm, pkpy::Args& args) {
const pkpy::List& self = vm->PyList_AS_C(args[0]); const pkpy::List& self = vm->PyList_AS_C(args[0]);
int n = (int)vm->PyInt_AS_C(args[1]); int n = (int)vm->PyInt_AS_C(args[1]);
pkpy::List result; pkpy::List result;
@ -404,7 +403,7 @@ void init_builtins(VM* _vm) {
return vm->PyList(std::move(result)); return vm->PyList(std::move(result));
}); });
_vm->bind_method<2>("list", "insert", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<2>("list", "insert", [](VM* vm, pkpy::Args& args) {
pkpy::List& _self = vm->PyList_AS_C(args[0]); pkpy::List& _self = vm->PyList_AS_C(args[0]);
int _index = (int)vm->PyInt_AS_C(args[1]); int _index = (int)vm->PyInt_AS_C(args[1]);
if(_index < 0) _index += _self.size(); if(_index < 0) _index += _self.size();
@ -414,16 +413,16 @@ void init_builtins(VM* _vm) {
return vm->None; return vm->None;
}); });
_vm->bind_method<0>("list", "clear", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("list", "clear", [](VM* vm, pkpy::Args& args) {
vm->PyList_AS_C(args[0]).clear(); vm->PyList_AS_C(args[0]).clear();
return vm->None; return vm->None;
}); });
_vm->bind_method<0>("list", "copy", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("list", "copy", [](VM* vm, pkpy::Args& args) {
return vm->PyList(vm->PyList_AS_C(args[0])); return vm->PyList(vm->PyList_AS_C(args[0]));
}); });
_vm->bind_method<1>("list", "__add__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("list", "__add__", [](VM* vm, pkpy::Args& args) {
const pkpy::List& _self = vm->PyList_AS_C(args[0]); const pkpy::List& _self = vm->PyList_AS_C(args[0]);
const pkpy::List& _obj = vm->PyList_AS_C(args[1]); const pkpy::List& _obj = vm->PyList_AS_C(args[1]);
pkpy::List _new_list = _self; pkpy::List _new_list = _self;
@ -431,16 +430,16 @@ void init_builtins(VM* _vm) {
return vm->PyList(_new_list); return vm->PyList(_new_list);
}); });
_vm->bind_method<0>("list", "__len__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("list", "__len__", [](VM* vm, pkpy::Args& args) {
const pkpy::List& _self = vm->PyList_AS_C(args[0]); const pkpy::List& _self = vm->PyList_AS_C(args[0]);
return vm->PyInt(_self.size()); return vm->PyInt(_self.size());
}); });
_vm->bind_method<0>("list", "__iter__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("list", "__iter__", [](VM* vm, pkpy::Args& args) {
return vm->PyIter(pkpy::make_shared<BaseIter, ArrayIter<pkpy::List>>(vm, args[0])); return vm->PyIter(pkpy::make_shared<BaseIter, ArrayIter<pkpy::List>>(vm, args[0]));
}); });
_vm->bind_method<1>("list", "__getitem__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("list", "__getitem__", [](VM* vm, pkpy::Args& args) {
const pkpy::List& self = vm->PyList_AS_C(args[0]); const pkpy::List& self = vm->PyList_AS_C(args[0]);
if(args[1]->is_type(vm->tp_slice)){ if(args[1]->is_type(vm->tp_slice)){
@ -456,7 +455,7 @@ void init_builtins(VM* _vm) {
return self[index]; return self[index];
}); });
_vm->bind_method<2>("list", "__setitem__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<2>("list", "__setitem__", [](VM* vm, pkpy::Args& args) {
pkpy::List& _self = vm->PyList_AS_C(args[0]); pkpy::List& _self = vm->PyList_AS_C(args[0]);
int _index = (int)vm->PyInt_AS_C(args[1]); int _index = (int)vm->PyInt_AS_C(args[1]);
_index = vm->normalized_index(_index, _self.size()); _index = vm->normalized_index(_index, _self.size());
@ -464,7 +463,7 @@ void init_builtins(VM* _vm) {
return vm->None; return vm->None;
}); });
_vm->bind_method<1>("list", "__delitem__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("list", "__delitem__", [](VM* vm, pkpy::Args& args) {
pkpy::List& _self = vm->PyList_AS_C(args[0]); pkpy::List& _self = vm->PyList_AS_C(args[0]);
int _index = (int)vm->PyInt_AS_C(args[1]); int _index = (int)vm->PyInt_AS_C(args[1]);
_index = vm->normalized_index(_index, _self.size()); _index = vm->normalized_index(_index, _self.size());
@ -473,16 +472,16 @@ void init_builtins(VM* _vm) {
}); });
/************ PyTuple ************/ /************ PyTuple ************/
_vm->bind_static_method<1>("tuple", "__new__", [](VM* vm, const pkpy::Args& args) { _vm->bind_static_method<1>("tuple", "__new__", [](VM* vm, pkpy::Args& args) {
pkpy::List _list = vm->PyList_AS_C(vm->call(vm->builtins->attr("list"), args)); pkpy::List _list = vm->PyList_AS_C(vm->call(vm->builtins->attr("list"), args));
return vm->PyTuple(std::move(_list)); return vm->PyTuple(std::move(_list));
}); });
_vm->bind_method<0>("tuple", "__iter__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("tuple", "__iter__", [](VM* vm, pkpy::Args& args) {
return vm->PyIter(pkpy::make_shared<BaseIter, ArrayIter<pkpy::Args>>(vm, args[0])); return vm->PyIter(pkpy::make_shared<BaseIter, ArrayIter<pkpy::Args>>(vm, args[0]));
}); });
_vm->bind_method<1>("tuple", "__getitem__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("tuple", "__getitem__", [](VM* vm, pkpy::Args& args) {
const pkpy::Tuple& self = vm->PyTuple_AS_C(args[0]); const pkpy::Tuple& self = vm->PyTuple_AS_C(args[0]);
if(args[1]->is_type(vm->tp_slice)){ if(args[1]->is_type(vm->tp_slice)){
@ -498,7 +497,7 @@ void init_builtins(VM* _vm) {
return self[index]; return self[index];
}); });
_vm->bind_method<0>("tuple", "__len__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("tuple", "__len__", [](VM* vm, pkpy::Args& args) {
const pkpy::Tuple& self = vm->PyTuple_AS_C(args[0]); const pkpy::Tuple& self = vm->PyTuple_AS_C(args[0]);
return vm->PyInt(self.size()); return vm->PyInt(self.size());
}); });
@ -506,17 +505,17 @@ void init_builtins(VM* _vm) {
/************ PyBool ************/ /************ PyBool ************/
_vm->bind_static_method<1>("bool", "__new__", CPP_LAMBDA(vm->asBool(args[0]))); _vm->bind_static_method<1>("bool", "__new__", CPP_LAMBDA(vm->asBool(args[0])));
_vm->bind_method<0>("bool", "__repr__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("bool", "__repr__", [](VM* vm, pkpy::Args& args) {
bool val = vm->PyBool_AS_C(args[0]); bool val = vm->PyBool_AS_C(args[0]);
return vm->PyStr(val ? "True" : "False"); return vm->PyStr(val ? "True" : "False");
}); });
_vm->bind_method<0>("bool", "__json__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<0>("bool", "__json__", [](VM* vm, pkpy::Args& args) {
bool val = vm->PyBool_AS_C(args[0]); bool val = vm->PyBool_AS_C(args[0]);
return vm->PyStr(val ? "true" : "false"); return vm->PyStr(val ? "true" : "false");
}); });
_vm->bind_method<1>("bool", "__xor__", [](VM* vm, const pkpy::Args& args) { _vm->bind_method<1>("bool", "__xor__", [](VM* vm, pkpy::Args& args) {
bool _self = vm->PyBool_AS_C(args[0]); bool _self = vm->PyBool_AS_C(args[0]);
bool _obj = vm->PyBool_AS_C(args[1]); bool _obj = vm->PyBool_AS_C(args[1]);
return vm->PyBool(_self ^ _obj); return vm->PyBool(_self ^ _obj);
@ -541,7 +540,7 @@ void init_builtins(VM* _vm) {
void add_module_time(VM* vm){ void add_module_time(VM* vm){
PyVar mod = vm->new_module("time"); PyVar mod = vm->new_module("time");
vm->bind_func<0>(mod, "time", [](VM* vm, const pkpy::Args& args) { vm->bind_func<0>(mod, "time", [](VM* vm, pkpy::Args& args) {
auto now = std::chrono::high_resolution_clock::now(); auto now = std::chrono::high_resolution_clock::now();
return vm->PyFloat(std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count() / 1000000.0); return vm->PyFloat(std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count() / 1000000.0);
}); });
@ -554,7 +553,7 @@ void add_module_sys(VM* vm){
vm->bind_func<1>(mod, "getrefcount", CPP_LAMBDA(vm->PyInt(args[0].use_count()))); vm->bind_func<1>(mod, "getrefcount", CPP_LAMBDA(vm->PyInt(args[0].use_count())));
vm->bind_func<0>(mod, "getrecursionlimit", CPP_LAMBDA(vm->PyInt(vm->maxRecursionDepth))); vm->bind_func<0>(mod, "getrecursionlimit", CPP_LAMBDA(vm->PyInt(vm->maxRecursionDepth)));
vm->bind_func<1>(mod, "setrecursionlimit", [](VM* vm, const pkpy::Args& args) { vm->bind_func<1>(mod, "setrecursionlimit", [](VM* vm, pkpy::Args& args) {
vm->maxRecursionDepth = (int)vm->PyInt_AS_C(args[0]); vm->maxRecursionDepth = (int)vm->PyInt_AS_C(args[0]);
return vm->None; return vm->None;
}); });
@ -562,7 +561,7 @@ void add_module_sys(VM* vm){
void add_module_json(VM* vm){ void add_module_json(VM* vm){
PyVar mod = vm->new_module("json"); PyVar mod = vm->new_module("json");
vm->bind_func<1>(mod, "loads", [](VM* vm, const pkpy::Args& args) { vm->bind_func<1>(mod, "loads", [](VM* vm, pkpy::Args& args) {
const Str& expr = vm->PyStr_AS_C(args[0]); const Str& expr = vm->PyStr_AS_C(args[0]);
CodeObject_ code = vm->compile(expr, "<json>", JSON_MODE); CodeObject_ code = vm->compile(expr, "<json>", JSON_MODE);
return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals); return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals);
@ -592,13 +591,77 @@ void add_module_math(VM* vm){
void add_module_dis(VM* vm){ void add_module_dis(VM* vm){
PyVar mod = vm->new_module("dis"); PyVar mod = vm->new_module("dis");
vm->bind_func<1>(mod, "dis", [](VM* vm, const pkpy::Args& args) { vm->bind_func<1>(mod, "dis", [](VM* vm, pkpy::Args& args) {
CodeObject_ code = vm->PyFunction_AS_C(args[0])->code; CodeObject_ code = vm->PyFunction_AS_C(args[0])->code;
(*vm->_stdout) << vm->disassemble(code); (*vm->_stdout) << vm->disassemble(code);
return vm->None; return vm->None;
}); });
} }
#include <fstream>
struct FileIO {
PY_CLASS(io, FileIO)
Str file;
Str mode;
std::fstream _fs;
FileIO(VM* vm, Str file, Str mode): file(file), mode(mode) {
if(mode == "rt" || mode == "r"){
_fs.open(file, std::ios::in);
}else if(mode == "wt" || mode == "w"){
_fs.open(file, std::ios::out);
}else if(mode == "at" || mode == "a"){
_fs.open(file, std::ios::app);
}
if(!_fs.is_open()) vm->IOError(strerror(errno));
}
static void _register(VM* vm, PyVar mod, PyVar type){
vm->bind_static_method<2>(type, "__new__", [](VM* vm, pkpy::Args& args){
return vm->new_object<FileIO>(
vm, vm->PyStr_AS_C(args[0]), vm->PyStr_AS_C(args[1])
);
});
vm->bind_method<0>(type, "read", [](VM* vm, pkpy::Args& args){
FileIO& io = vm->py_cast<FileIO>(args[0]);
std::string buffer;
io._fs >> buffer;
return vm->PyStr(buffer);
});
vm->bind_method<1>(type, "write", [](VM* vm, pkpy::Args& args){
FileIO& io = vm->py_cast<FileIO>(args[0]);
io._fs << vm->PyStr_AS_C(args[1]);
return vm->None;
});
vm->bind_method<0>(type, "close", [](VM* vm, pkpy::Args& args){
FileIO& io = vm->py_cast<FileIO>(args[0]);
io._fs.close();
return vm->None;
});
vm->bind_method<0>(type, "__exit__", [](VM* vm, pkpy::Args& args){
FileIO& io = vm->py_cast<FileIO>(args[0]);
io._fs.close();
return vm->None;
});
vm->bind_method<0>(type, "__enter__", CPP_LAMBDA(vm->None));
}
};
void add_module_io(VM* vm){
PyVar mod = vm->new_module("io");
PyVar type = vm->register_class<FileIO>(mod);
vm->bind_builtin_func<2>("open", [type](VM* vm, const pkpy::Args& args){
return vm->call(type, args);
});
}
void add_module_os(VM* vm){}
struct ReMatch { struct ReMatch {
PY_CLASS(re, Match) PY_CLASS(re, Match)
@ -612,12 +675,12 @@ struct ReMatch {
vm->bind_method<0>(type, "start", CPP_LAMBDA(vm->PyInt(vm->py_cast<ReMatch>(args[0]).start))); vm->bind_method<0>(type, "start", CPP_LAMBDA(vm->PyInt(vm->py_cast<ReMatch>(args[0]).start)));
vm->bind_method<0>(type, "end", CPP_LAMBDA(vm->PyInt(vm->py_cast<ReMatch>(args[0]).end))); vm->bind_method<0>(type, "end", CPP_LAMBDA(vm->PyInt(vm->py_cast<ReMatch>(args[0]).end)));
vm->bind_method<0>(type, "span", [](VM* vm, const pkpy::Args& args) { vm->bind_method<0>(type, "span", [](VM* vm, pkpy::Args& args) {
auto& self = vm->py_cast<ReMatch>(args[0]); auto& self = vm->py_cast<ReMatch>(args[0]);
return vm->PyTuple({ vm->PyInt(self.start), vm->PyInt(self.end) }); return vm->PyTuple({ vm->PyInt(self.start), vm->PyInt(self.end) });
}); });
vm->bind_method<1>(type, "group", [](VM* vm, const pkpy::Args& args) { vm->bind_method<1>(type, "group", [](VM* vm, pkpy::Args& args) {
auto& self = vm->py_cast<ReMatch>(args[0]); auto& self = vm->py_cast<ReMatch>(args[0]);
int index = (int)vm->PyInt_AS_C(args[1]); int index = (int)vm->PyInt_AS_C(args[1]);
index = vm->normalized_index(index, self.m.size()); index = vm->normalized_index(index, self.m.size());
@ -642,19 +705,19 @@ void add_module_re(VM* vm){
PyVar mod = vm->new_module("re"); PyVar mod = vm->new_module("re");
vm->register_class<ReMatch>(mod); vm->register_class<ReMatch>(mod);
vm->bind_func<2>(mod, "match", [](VM* vm, const pkpy::Args& args) { vm->bind_func<2>(mod, "match", [](VM* vm, pkpy::Args& args) {
const Str& pattern = vm->PyStr_AS_C(args[0]); const Str& pattern = vm->PyStr_AS_C(args[0]);
const Str& string = vm->PyStr_AS_C(args[1]); const Str& string = vm->PyStr_AS_C(args[1]);
return _regex_search(pattern, string, true, vm); return _regex_search(pattern, string, true, vm);
}); });
vm->bind_func<2>(mod, "search", [](VM* vm, const pkpy::Args& args) { vm->bind_func<2>(mod, "search", [](VM* vm, pkpy::Args& args) {
const Str& pattern = vm->PyStr_AS_C(args[0]); const Str& pattern = vm->PyStr_AS_C(args[0]);
const Str& string = vm->PyStr_AS_C(args[1]); const Str& string = vm->PyStr_AS_C(args[1]);
return _regex_search(pattern, string, false, vm); return _regex_search(pattern, string, false, vm);
}); });
vm->bind_func<3>(mod, "sub", [](VM* vm, const pkpy::Args& args) { vm->bind_func<3>(mod, "sub", [](VM* vm, pkpy::Args& args) {
const Str& pattern = vm->PyStr_AS_C(args[0]); const Str& pattern = vm->PyStr_AS_C(args[0]);
const Str& repl = vm->PyStr_AS_C(args[1]); const Str& repl = vm->PyStr_AS_C(args[1]);
const Str& string = vm->PyStr_AS_C(args[2]); const Str& string = vm->PyStr_AS_C(args[2]);
@ -662,7 +725,7 @@ void add_module_re(VM* vm){
return vm->PyStr(std::regex_replace(string, re, repl)); return vm->PyStr(std::regex_replace(string, re, repl));
}); });
vm->bind_func<2>(mod, "split", [](VM* vm, const pkpy::Args& args) { vm->bind_func<2>(mod, "split", [](VM* vm, pkpy::Args& args) {
const Str& pattern = vm->PyStr_AS_C(args[0]); const Str& pattern = vm->PyStr_AS_C(args[0]);
const Str& string = vm->PyStr_AS_C(args[1]); const Str& string = vm->PyStr_AS_C(args[1]);
std::regex re(pattern); std::regex re(pattern);
@ -679,20 +742,20 @@ void add_module_re(VM* vm){
void add_module_random(VM* vm){ void add_module_random(VM* vm){
PyVar mod = vm->new_module("random"); PyVar mod = vm->new_module("random");
std::srand(std::time(0)); std::srand(std::time(0));
vm->bind_func<1>(mod, "seed", [](VM* vm, const pkpy::Args& args) { vm->bind_func<1>(mod, "seed", [](VM* vm, pkpy::Args& args) {
std::srand((unsigned int)vm->PyInt_AS_C(args[0])); std::srand((unsigned int)vm->PyInt_AS_C(args[0]));
return vm->None; return vm->None;
}); });
vm->bind_func<0>(mod, "random", CPP_LAMBDA(vm->PyFloat((f64)std::rand() / RAND_MAX))); vm->bind_func<0>(mod, "random", CPP_LAMBDA(vm->PyFloat((f64)std::rand() / RAND_MAX)));
vm->bind_func<2>(mod, "randint", [](VM* vm, const pkpy::Args& args) { vm->bind_func<2>(mod, "randint", [](VM* vm, pkpy::Args& args) {
i64 a = vm->PyInt_AS_C(args[0]); i64 a = vm->PyInt_AS_C(args[0]);
i64 b = vm->PyInt_AS_C(args[1]); i64 b = vm->PyInt_AS_C(args[1]);
if(a > b) std::swap(a, b); if(a > b) std::swap(a, b);
return vm->PyInt(a + std::rand() % (b - a + 1)); return vm->PyInt(a + std::rand() % (b - a + 1));
}); });
vm->bind_func<2>(mod, "uniform", [](VM* vm, const pkpy::Args& args) { vm->bind_func<2>(mod, "uniform", [](VM* vm, pkpy::Args& args) {
f64 a = vm->PyFloat_AS_C(args[0]); f64 a = vm->PyFloat_AS_C(args[0]);
f64 b = vm->PyFloat_AS_C(args[1]); f64 b = vm->PyFloat_AS_C(args[1]);
if(a > b) std::swap(a, b); if(a > b) std::swap(a, b);
@ -817,6 +880,8 @@ extern "C" {
add_module_re(vm); add_module_re(vm);
add_module_dis(vm); add_module_dis(vm);
add_module_random(vm); add_module_random(vm);
add_module_io(vm);
add_module_os(vm);
CodeObject_ code = vm->compile(kBuiltinsCode, "<builtins>", EXEC_MODE); CodeObject_ code = vm->compile(kBuiltinsCode, "<builtins>", EXEC_MODE);
vm->_exec(code, vm->builtins, pkpy::make_shared<pkpy::NameDict>()); vm->_exec(code, vm->builtins, pkpy::make_shared<pkpy::NameDict>());

41
src/vm.h
View File

@ -8,9 +8,8 @@
check_type(obj, ptype); \ check_type(obj, ptype); \
return OBJ_GET(ctype, obj); \ return OBJ_GET(ctype, obj); \
} \ } \
inline PyVar Py##type(ctype value) { \ inline PyVar Py##type(const ctype& value) { return new_object(ptype, value);} \
return new_object(ptype, value); \ inline PyVar Py##type(ctype&& value) { return new_object(ptype, std::move(value));}
}
class Generator; class Generator;
@ -420,13 +419,13 @@ public:
} }
template<typename ArgT> template<typename ArgT>
inline std::enable_if_t<std::is_same_v<std::remove_const_t<std::remove_reference_t<ArgT>>, pkpy::Args>, PyVar> inline std::enable_if_t<std::is_same_v<RAW(ArgT), pkpy::Args>, PyVar>
call(const PyVar& _callable, ArgT&& args){ call(const PyVar& _callable, ArgT&& args){
return call(_callable, std::forward<ArgT>(args), pkpy::no_arg(), false); return call(_callable, std::forward<ArgT>(args), pkpy::no_arg(), false);
} }
template<typename ArgT> template<typename ArgT>
inline std::enable_if_t<std::is_same_v<std::remove_const_t<std::remove_reference_t<ArgT>>, pkpy::Args>, PyVar> inline std::enable_if_t<std::is_same_v<RAW(ArgT), pkpy::Args>, PyVar>
call(const PyVar& obj, const Str& func, ArgT&& args){ call(const PyVar& obj, const Str& func, ArgT&& args){
return call(getattr(obj, func), std::forward<ArgT>(args), pkpy::no_arg(), false); return call(getattr(obj, func), std::forward<ArgT>(args), pkpy::no_arg(), false);
} }
@ -620,15 +619,23 @@ public:
} }
template<typename T> template<typename T>
inline PyVar new_object(PyVar type, T _value) { inline PyVar new_object(const PyVar& type, const T& _value) {
if(!type->is_type(tp_type)) UNREACHABLE(); if(!type->is_type(tp_type)) UNREACHABLE();
return pkpy::make_shared<PyObject, Py_<T>>( return pkpy::make_shared<PyObject, Py_<RAW(T)>>(OBJ_GET(Type, type), _value);
OBJ_GET(Type, type), _value); }
template<typename T>
inline PyVar new_object(const PyVar& type, T&& _value) {
if(!type->is_type(tp_type)) UNREACHABLE();
return pkpy::make_shared<PyObject, Py_<RAW(T)>>(OBJ_GET(Type, type), std::move(_value));
} }
template<typename T> template<typename T>
inline PyVar new_object(Type type, T _value) { inline PyVar new_object(Type type, const T& _value) {
return pkpy::make_shared<PyObject, Py_<T>>(type, _value); return pkpy::make_shared<PyObject, Py_<RAW(T)>>(type, _value);
}
template<typename T>
inline PyVar new_object(Type type, T&& _value) {
return pkpy::make_shared<PyObject, Py_<RAW(T)>>(type, std::move(_value));
} }
template<typename T, typename... Args> template<typename T, typename... Args>
@ -703,14 +710,19 @@ public:
setattr(obj, funcName, PyNativeFunc(pkpy::NativeFunc(fn, ARGC, false))); setattr(obj, funcName, PyNativeFunc(pkpy::NativeFunc(fn, ARGC, false)));
} }
template<int ARGC>
void bind_func(Str typeName, Str funcName, NativeFuncRaw fn) {
bind_func<ARGC>(_types[typeName], funcName, fn);
}
template<int ARGC> template<int ARGC>
void bind_method(Str typeName, Str funcName, NativeFuncRaw fn) { void bind_method(Str typeName, Str funcName, NativeFuncRaw fn) {
bind_method<ARGC>(_types[typeName], funcName, fn); bind_method<ARGC>(_types[typeName], funcName, fn);
} }
template<int ARGC> template<int ARGC, typename... Args>
void bind_static_method(Str typeName, Str funcName, NativeFuncRaw fn) { void bind_static_method(Args&&... args) {
bind_func<ARGC>(_types[typeName], funcName, fn); bind_func<ARGC>(std::forward<Args>(args)...);
} }
template<int ARGC> template<int ARGC>
@ -956,6 +968,7 @@ private:
} }
public: public:
void IOError(const Str& msg) { _error("IOError", msg); }
void NotImplementedError(){ _error("NotImplementedError", ""); } void NotImplementedError(){ _error("NotImplementedError", ""); }
void TypeError(const Str& msg){ _error("TypeError", msg); } void TypeError(const Str& msg){ _error("TypeError", msg); }
void ZeroDivisionError(){ _error("ZeroDivisionError", "division by zero"); } void ZeroDivisionError(){ _error("ZeroDivisionError", "division by zero"); }
@ -1119,7 +1132,7 @@ inline void Frame::try_deref(VM* vm, PyVar& v){
if(v->is_type(vm->tp_ref)) v = vm->PyRef_AS_C(v)->get(vm, this); if(v->is_type(vm->tp_ref)) v = vm->PyRef_AS_C(v)->get(vm, this);
} }
PyVar pkpy::NativeFunc::operator()(VM* vm, const pkpy::Args& args) const{ PyVar pkpy::NativeFunc::operator()(VM* vm, pkpy::Args& args) const{
int args_size = args.size() - (int)method; // remove self int args_size = args.size() - (int)method; // remove self
if(argc != -1 && args_size != argc) { if(argc != -1 && args_size != argc) {
vm->TypeError("expected " + std::to_string(argc) + " arguments, but got " + std::to_string(args_size)); vm->TypeError("expected " + std::to_string(argc) + " arguments, but got " + std::to_string(args_size));

13
tests/_file.py Normal file
View File

@ -0,0 +1,13 @@
a = open('123.txt', 'wt')
a.write('123')
a.write('456')
a.close()
with open('123.txt', 'rt') as f:
assert f.read() == '123456'
with open('123.txt', 'a') as f:
f.write('测试')
with open('123.txt', 'r') as f:
assert f.read() == '123456' + '测试'