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

some cleanup

Browse Source
This commit is contained in:
blueloveTH 2023-12-26 21:52:05 +08:00
parent 63d47cf62f
commit b89395a1fe
4 changed files with 0 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
include/pocketpy/codeobject.h
View File

@ -57,45 +57,6 @@ struct FuncDecl;
using CodeObject_ = std::shared_ptr<CodeObject>;
using FuncDecl_ = std::shared_ptr<FuncDecl>;
// struct CodeObjectSerializer{
// std::string buffer;
// int depth = 0;
// std::set<StrName> names;
// static const char END = '\n';
// CodeObjectSerializer();
// void write_int(i64 v);
// void write_float(f64 v);
// void write_str(const Str& v);
// void write_none();
// void write_ellipsis();
// void write_bool(bool v);
// void write_begin_mark();
// void write_name(StrName name);
// void write_end_mark();
// template<typename T>
// void write_bytes(T v){
// static_assert(std::is_trivially_copyable<T>::value);
// buffer += 'x';
// char* p = (char*)&v;
// for(int i=0; i<sizeof(T); i++){
// char c = p[i];
// buffer += "0123456789abcdef"[(c >> 4) & 0xf];
// buffer += "0123456789abcdef"[c & 0xf];
// }
// buffer += END;
// }
// void write_object(VM* vm, PyObject* obj);
// void write_code(VM* vm, const CodeObject* co);
// std::string str();
// };
struct CodeObject {
std::shared_ptr<SourceData> src;
Str name;
@ -117,8 +78,6 @@ struct CodeObject {
CodeObject(std::shared_ptr<SourceData> src, const Str& name);
void _gc_mark() const;
// void write(VM* vm, CodeObjectSerializer& ss) const;
// Str serialize(VM* vm) const;
};
struct FuncDecl {

146
src/codeobject.cpp
View File

@ -21,150 +21,4 @@ namespace pkpy{
this->argc = -1;
this->decl = decl;
}
// void CodeObject::write(VM* vm, CodeObjectSerializer& ss) const{
// ss.write_begin_mark(); // [
// ss.write_str(src->filename); // src->filename
// ss.write_int(src->mode); // src->mode
// ss.write_end_mark(); // ]
// ss.write_str(name); // name
// ss.write_bool(is_generator); // is_generator
// ss.write_begin_mark(); // [
// for(Bytecode bc: codes){
// if(StrName::is_valid(bc.arg)) ss.names.insert(StrName(bc.arg));
// ss.write_bytes(bc);
// }
// ss.write_end_mark(); // ]
// ss.write_begin_mark(); // [
// for(int line: lines){
// ss.write_int(line); // line
// }
// ss.write_end_mark(); // ]
// ss.write_begin_mark(); // [
// for(PyObject* o: consts){
// ss.write_object(vm, o);
// }
// ss.write_end_mark(); // ]
// ss.write_begin_mark(); // [
// for(StrName vn: varnames){
// ss.write_name(vn); // name
// }
// ss.write_end_mark(); // ]
// ss.write_begin_mark(); // [
// for(CodeBlock block: blocks){
// ss.write_bytes(block); // block
// }
// ss.write_end_mark(); // ]
// ss.write_begin_mark(); // [
// for(auto& label: labels.items()){
// ss.write_name(label.first); // label.first
// ss.write_int(label.second); // label.second
// }
// ss.write_end_mark(); // ]
// ss.write_begin_mark(); // [
// for(auto& decl: func_decls){
// ss.write_code(vm, decl->code.get()); // decl->code
// ss.write_begin_mark(); // [
// for(int arg: decl->args) ss.write_int(arg);
// ss.write_end_mark(); // ]
// ss.write_begin_mark(); // [
// for(auto kw: decl->kwargs){
// ss.write_int(kw.key); // kw.key
// ss.write_object(vm, kw.value); // kw.value
// }
// ss.write_end_mark(); // ]
// ss.write_int(decl->starred_arg);
// ss.write_int(decl->starred_kwarg);
// ss.write_bool(decl->nested);
// }
// ss.write_end_mark(); // ]
// }
// Str CodeObject::serialize(VM* vm) const{
// CodeObjectSerializer ss;
// ss.write_code(vm, this);
// return ss.str();
// }
// void CodeObjectSerializer::write_int(i64 v){
// buffer += 'i';
// buffer += std::to_string(v);
// buffer += END;
// }
// void CodeObjectSerializer::write_float(f64 v){
// buffer += 'f';
// buffer += std::to_string(v);
// buffer += END;
// }
// void CodeObjectSerializer::write_str(const Str& v){
// buffer += 's';
// buffer += v.escape(false).str();
// buffer += END;
// }
// void CodeObjectSerializer::write_none(){
// buffer += 'N';
// buffer += END;
// }
// void CodeObjectSerializer::write_ellipsis(){
// buffer += 'E';
// buffer += END;
// }
// void CodeObjectSerializer::write_bool(bool v){
// buffer += 'b';
// buffer += v ? '1' : '0';
// buffer += END;
// }
// void CodeObjectSerializer::write_begin_mark(){
// buffer += '[';
// buffer += END;
// depth++;
// }
// void CodeObjectSerializer::write_name(StrName name){
// PK_ASSERT(StrName::is_valid(name.index));
// buffer += 'n';
// buffer += std::to_string(name.index);
// buffer += END;
// names.insert(name);
// }
// void CodeObjectSerializer::write_end_mark(){
// buffer += ']';
// buffer += END;
// depth--;
// PK_ASSERT(depth >= 0);
// }
// std::string CodeObjectSerializer::str(){
// PK_ASSERT(depth == 0);
// for(auto name: names){
// PK_ASSERT(StrName::is_valid(name.index));
// write_name(name);
// write_str(name.sv());
// }
// return std::move(buffer);
// }
// CodeObjectSerializer::CodeObjectSerializer(){
// write_str(PK_VERSION);
// }
// void CodeObjectSerializer::write_code(VM* vm, const CodeObject* co){
// buffer += '(';
// buffer += END;
// co->write(vm, *this);
// buffer += ')';
// buffer += END;
// }
} // namespace pkpy

5
src/pocketpy.cpp
View File

@ -1557,11 +1557,6 @@ void add_module_dis(VM* vm){
vm->stdout_write(vm->disassemble(code));
return vm->None;
});
// vm->bind_func<1>(mod, "_s", [](VM* vm, ArgsView args) {
// CodeObject_ code = get_code(vm, args[0]);
// return VAR(code->serialize(vm));
// });
}
void add_module_gc(VM* vm){

12
src/vm.cpp
View File

@ -1255,18 +1255,6 @@ void Dict::_probe_1(PyObject *key, bool &ok, int &i) const{
}
}
// void CodeObjectSerializer::write_object(VM *vm, PyObject *obj){
// if(is_int(obj)) write_int(_CAST(i64, obj));
// else if(is_float(obj)) write_float(_CAST(f64, obj));
// else if(is_type(obj, vm->tp_str)) write_str(_CAST(Str&, obj));
// else if(is_type(obj, vm->tp_bool)) write_bool(_CAST(bool, obj));
// else if(obj == vm->None) write_none();
// else if(obj == vm->Ellipsis) write_ellipsis();
// else{
// throw std::runtime_error(fmt(OBJ_NAME(vm->_t(obj)).escape(), " is not serializable"));
// }
// }
void NativeFunc::check_size(VM* vm, ArgsView args) const{
if(args.size() != argc && argc != -1) {
vm->TypeError(fmt("expected ", argc, " arguments, got ", args.size()));