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

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

10
src/common.h
View File

@ -23,16 +23,18 @@
#include <memory>
#include <functional>
#include <iostream>
// #include <filesystem>
// namespace fs = std::filesystem;
#include "hash_table8.hpp"
#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
#define UNREACHABLE() throw std::runtime_error( __FILE__ + std::string(":") + std::to_string(__LINE__) + " UNREACHABLE()!");
#endif
#define PK_VERSION "0.8.6"
#define PK_VERSION "0.8.7"
typedef int64_t i64;
typedef double f64;
@ -59,4 +61,6 @@ void* tid() {
}
//#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){
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;
std::getline(std::cin, line);
return vm->PyStr(line);

9
src/obj.h
View File

@ -7,7 +7,7 @@ struct Frame;
struct BaseRef;
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_;
namespace pkpy{
@ -17,7 +17,7 @@ struct NativeFunc {
bool 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 {
@ -94,7 +94,10 @@ template <typename T>
struct Py_ : PyObject {
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>
|| std::is_same_v<T, pkpy::Function_> || std::is_same_v<T, pkpy::NativeFunc>) {
_attr = new pkpy::NameDict();

223
src/pocketpy.h
View File

@ -5,8 +5,8 @@
#include "repl.h"
#include "iter.h"
#define CPP_LAMBDA(x) ([](VM* vm, const pkpy::Args& args) { return x; })
#define CPP_NOT_IMPLEMENTED() ([](VM* vm, const pkpy::Args& args) { vm->NotImplementedError(); return vm->None; })
#define CPP_LAMBDA(x) ([](VM* vm, pkpy::Args& args) { return x; })
#define CPP_NOT_IMPLEMENTED() ([](VM* vm, pkpy::Args& args) { vm->NotImplementedError(); return vm->None; })
CodeObject_ VM::compile(Str source, Str filename, CompileMode 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) \
_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)){ \
return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \
}else{ \
@ -28,7 +28,7 @@ CodeObject_ VM::compile(Str source, Str filename, CompileMode mode) {
});
#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 _1 = args[1]->is_type(vm->tp_int) || args[1]->is_type(vm->tp_float); \
if(!_0 || !_1){ \
@ -54,29 +54,29 @@ void init_builtins(VM* _vm) {
#undef BIND_NUM_ARITH_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]);
return vm->None;
});
_vm->bind_builtin_func<0>("super", [](VM* vm, const pkpy::Args& args) {
auto it = vm->top_frame()->f_locals().find(m_self);
if(it == vm->top_frame()->f_locals().end()) vm->TypeError("super() can only be called in a class method");
return vm->new_object(vm->tp_super, it->second);
_vm->bind_builtin_func<0>("super", [](VM* vm, pkpy::Args& args) {
const PyVar* self = vm->top_frame()->f_locals().try_get(m_self);
if(self == nullptr) vm->TypeError("super() can only be called in a class");
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);
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);
vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals);
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);
else if(args.size() == 1) std::exit((int)vm->PyInt_AS_C(args[0]));
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>("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]);
if (i < 0 || i > 128) vm->ValueError("chr() arg not in range(128)");
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]);
if (s.size() != 1) vm->TypeError("ord() expected an ASCII character");
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);
});
_vm->bind_builtin_func<3>("setattr", [](VM* vm, const pkpy::Args& args) {
PyVar obj = args[0];
vm->setattr(obj, vm->PyStr_AS_C(args[1]), args[2]);
_vm->bind_builtin_func<3>("setattr", [](VM* vm, pkpy::Args& args) {
vm->setattr(args[0], vm->PyStr_AS_C(args[1]), args[2]);
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]);
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;
ss << std::hex << vm->PyInt_AS_C(args[0]);
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;
if(args[0]->is_attr_valid()){
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));
});
_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];
StrStream ss;
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>("range", "__new__", [](VM* vm, const pkpy::Args& args) {
_vm->bind_static_method<-1>("range", "__new__", [](VM* vm, pkpy::Args& args) {
pkpy::Range r;
switch (args.size()) {
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", "__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]);
if (rhs == 0) vm->ZeroDivisionError();
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)){
return vm->PyInt((i64)round(pow(vm->PyInt_AS_C(args[0]), vm->PyInt_AS_C(args[1]))));
}else{
@ -179,7 +178,7 @@ void init_builtins(VM* _vm) {
});
/************ 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_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);
@ -198,28 +197,28 @@ void init_builtins(VM* _vm) {
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]);
if(rhs == 0) vm->ZeroDivisionError();
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]);
if(rhs == 0) vm->ZeroDivisionError();
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])));
});
_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])));
});
#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])); \
});
@ -232,7 +231,7 @@ void init_builtins(VM* _vm) {
#undef __INT_BITWISE_OP
/************ 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_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);
@ -251,7 +250,7 @@ void init_builtins(VM* _vm) {
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]);
if(std::isinf(val) || std::isnan(val)) return vm->PyStr(std::to_string(val));
StrStream ss;
@ -261,7 +260,7 @@ void init_builtins(VM* _vm) {
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]);
if(std::isinf(val) || std::isnan(val)) vm->ValueError("cannot jsonify 'nan' or 'inf'");
return vm->PyStr(std::to_string(val));
@ -270,18 +269,18 @@ void init_builtins(VM* _vm) {
/************ PyString ************/
_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& rhs = vm->PyStr_AS_C(args[1]);
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]);
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& other = vm->PyStr_AS_C(args[1]);
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->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]);
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]);
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))
return vm->PyBool(vm->PyStr_AS_C(args[0]) == vm->PyStr_AS_C(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))
return vm->PyBool(vm->PyStr_AS_C(args[0]) != vm->PyStr_AS_C(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]));
if(args[1]->is_type(vm->tp_slice)){
@ -329,19 +328,19 @@ void init_builtins(VM* _vm) {
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& _obj (vm->PyStr_AS_C(args[1]));
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& _obj (vm->PyStr_AS_C(args[1]));
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& _old = vm->PyStr_AS_C(args[1]);
const Str& _new = vm->PyStr_AS_C(args[2]);
@ -355,19 +354,19 @@ void init_builtins(VM* _vm) {
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& _prefix = vm->PyStr_AS_C(args[1]);
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& _suffix = vm->PyStr_AS_C(args[1]);
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]);
StrStream ss;
if(args[1]->is_type(vm->tp_list)){
@ -389,13 +388,13 @@ void init_builtins(VM* _vm) {
});
/************ 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]);
self.push_back(args[1]);
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]);
int n = (int)vm->PyInt_AS_C(args[1]);
pkpy::List result;
@ -404,7 +403,7 @@ void init_builtins(VM* _vm) {
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]);
int _index = (int)vm->PyInt_AS_C(args[1]);
if(_index < 0) _index += _self.size();
@ -414,16 +413,16 @@ void init_builtins(VM* _vm) {
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();
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]));
});
_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& _obj = vm->PyList_AS_C(args[1]);
pkpy::List _new_list = _self;
@ -431,16 +430,16 @@ void init_builtins(VM* _vm) {
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]);
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]));
});
_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]);
if(args[1]->is_type(vm->tp_slice)){
@ -456,7 +455,7 @@ void init_builtins(VM* _vm) {
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]);
int _index = (int)vm->PyInt_AS_C(args[1]);
_index = vm->normalized_index(_index, _self.size());
@ -464,7 +463,7 @@ void init_builtins(VM* _vm) {
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]);
int _index = (int)vm->PyInt_AS_C(args[1]);
_index = vm->normalized_index(_index, _self.size());
@ -473,16 +472,16 @@ void init_builtins(VM* _vm) {
});
/************ 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));
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]));
});
_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]);
if(args[1]->is_type(vm->tp_slice)){
@ -498,7 +497,7 @@ void init_builtins(VM* _vm) {
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]);
return vm->PyInt(self.size());
});
@ -506,17 +505,17 @@ void init_builtins(VM* _vm) {
/************ PyBool ************/
_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]);
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]);
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 _obj = vm->PyBool_AS_C(args[1]);
return vm->PyBool(_self ^ _obj);
@ -541,7 +540,7 @@ void init_builtins(VM* _vm) {
void add_module_time(VM* vm){
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();
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<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]);
return vm->None;
});
@ -562,7 +561,7 @@ void add_module_sys(VM* vm){
void add_module_json(VM* vm){
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]);
CodeObject_ code = vm->compile(expr, "<json>", JSON_MODE);
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){
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;
(*vm->_stdout) << vm->disassemble(code);
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 {
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, "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]);
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]);
int index = (int)vm->PyInt_AS_C(args[1]);
index = vm->normalized_index(index, self.m.size());
@ -642,19 +705,19 @@ void add_module_re(VM* vm){
PyVar mod = vm->new_module("re");
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& string = vm->PyStr_AS_C(args[1]);
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& string = vm->PyStr_AS_C(args[1]);
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& repl = vm->PyStr_AS_C(args[1]);
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));
});
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& string = vm->PyStr_AS_C(args[1]);
std::regex re(pattern);
@ -679,20 +742,20 @@ void add_module_re(VM* vm){
void add_module_random(VM* vm){
PyVar mod = vm->new_module("random");
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]));
return vm->None;
});
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 b = vm->PyInt_AS_C(args[1]);
if(a > b) std::swap(a, b);
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 b = vm->PyFloat_AS_C(args[1]);
if(a > b) std::swap(a, b);
@ -817,6 +880,8 @@ extern "C" {
add_module_re(vm);
add_module_dis(vm);
add_module_random(vm);
add_module_io(vm);
add_module_os(vm);
CodeObject_ code = vm->compile(kBuiltinsCode, "<builtins>", EXEC_MODE);
vm->_exec(code, vm->builtins, pkpy::make_shared<pkpy::NameDict>());

41
src/vm.h
View File

@ -8,9 +8,8 @@
check_type(obj, ptype); \
return OBJ_GET(ctype, obj); \
} \
inline PyVar Py##type(ctype value) { \
return new_object(ptype, value); \
}
inline PyVar Py##type(const ctype& value) { return new_object(ptype, value);} \
inline PyVar Py##type(ctype&& value) { return new_object(ptype, std::move(value));}
class Generator;
@ -420,13 +419,13 @@ public:
}
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){
return call(_callable, std::forward<ArgT>(args), pkpy::no_arg(), false);
}
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){
return call(getattr(obj, func), std::forward<ArgT>(args), pkpy::no_arg(), false);
}
@ -620,15 +619,23 @@ public:
}
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();
return pkpy::make_shared<PyObject, Py_<T>>(
OBJ_GET(Type, type), _value);
return pkpy::make_shared<PyObject, Py_<RAW(T)>>(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>
inline PyVar new_object(Type type, T _value) {
return pkpy::make_shared<PyObject, Py_<T>>(type, _value);
inline PyVar new_object(Type type, const T& _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>
@ -703,14 +710,19 @@ public:
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>
void bind_method(Str typeName, Str funcName, NativeFuncRaw fn) {
bind_method<ARGC>(_types[typeName], funcName, fn);
}
template<int ARGC>
void bind_static_method(Str typeName, Str funcName, NativeFuncRaw fn) {
bind_func<ARGC>(_types[typeName], funcName, fn);
template<int ARGC, typename... Args>
void bind_static_method(Args&&... args) {
bind_func<ARGC>(std::forward<Args>(args)...);
}
template<int ARGC>
@ -956,6 +968,7 @@ private:
}
public:
void IOError(const Str& msg) { _error("IOError", msg); }
void NotImplementedError(){ _error("NotImplementedError", ""); }
void TypeError(const Str& msg){ _error("TypeError", msg); }
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);
}
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
if(argc != -1 && args_size != argc) {
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' + '测试'