From 56763e05f94d4be6c0301bdb151734b1ee00c3b5 Mon Sep 17 00:00:00 2001 From: blueloveTH Date: Sun, 4 Aug 2024 19:09:50 +0800 Subject: [PATCH] ... --- include/pocketpy/common/memorypool.h | 4 +- include/pocketpy/compiler/compiler.h | 2 +- include/pocketpy/compiler/lexer.h | 10 ++-- include/pocketpy/interpreter/frame.h | 2 +- include/pocketpy/interpreter/gc.h | 24 ++++----- include/pocketpy/interpreter/vm.h | 36 +++++++------- include/pocketpy/objects/base.h | 4 +- include/pocketpy/objects/codeobject.h | 8 +-- include/pocketpy/objects/error.h | 4 +- include/pocketpy/objects/namedict.h | 2 +- include/pocketpy/objects/object.h | 4 +- include/pocketpy/objects/sourcedata.h | 10 ++-- src/common/memorypool.c | 4 +- src/common/sourcedata.c | 18 +++---- src/compiler/compiler.c | 22 ++++----- src/compiler/lexer.c | 68 +++++++++++++------------- src/interpreter/ceval.c | 34 ++++++------- src/interpreter/frame.c | 8 +-- src/interpreter/gc.c | 22 ++++----- src/interpreter/vm.c | 70 +++++++++++++-------------- src/objects/codeobject.c | 8 +-- src/objects/namedict.c | 2 +- src/objects/object.c | 4 +- src/public/cast.c | 2 +- src/public/internal.c | 54 ++++++++++----------- src/public/modules.c | 14 +++--- src/public/py_exception.c | 14 +++--- src/public/py_list.c | 2 +- src/public/py_object.c | 4 +- src/public/py_ops.c | 4 +- src/public/py_slice.c | 4 +- src/public/py_str.c | 8 +-- src/public/py_tuple.c | 4 +- src/public/stack_ops.c | 16 +++--- src/public/values.c | 6 +-- 35 files changed, 251 insertions(+), 251 deletions(-) diff --git a/include/pocketpy/common/memorypool.h b/include/pocketpy/common/memorypool.h index a8cc88f8..481bc814 100644 --- a/include/pocketpy/common/memorypool.h +++ b/include/pocketpy/common/memorypool.h @@ -11,8 +11,8 @@ extern "C" { #define kPoolObjectArenaSize (256*1024) #define kPoolObjectMaxBlocks (kPoolObjectArenaSize / kPoolObjectBlockSize) -void pk_MemoryPools__initialize(); -void pk_MemoryPools__finalize(); +void MemoryPools__initialize(); +void MemoryPools__finalize(); void* PoolExpr_alloc(); void PoolExpr_dealloc(void*); diff --git a/include/pocketpy/compiler/compiler.h b/include/pocketpy/compiler/compiler.h index 33ae8e67..d8a2139e 100644 --- a/include/pocketpy/compiler/compiler.h +++ b/include/pocketpy/compiler/compiler.h @@ -9,7 +9,7 @@ extern "C" { #endif -Error* pk_compile(pk_SourceData_ src, CodeObject* out); +Error* pk_compile(SourceData_ src, CodeObject* out); #ifdef __cplusplus } diff --git a/include/pocketpy/compiler/lexer.h b/include/pocketpy/compiler/lexer.h index b9bea7fc..28c0d3d7 100644 --- a/include/pocketpy/compiler/lexer.h +++ b/include/pocketpy/compiler/lexer.h @@ -10,7 +10,7 @@ extern "C" { #endif -extern const char* pk_TokenSymbols[]; +extern const char* TokenSymbols[]; typedef enum TokenIndex{ TK_EOF, TK_EOL, TK_SOF, @@ -88,11 +88,11 @@ enum Precedence { PREC_HIGHEST, }; -typedef c11_array pk_TokenArray; +typedef c11_array TokenArray; -Error* pk_Lexer__process(pk_SourceData_ src, pk_TokenArray* out_tokens); -Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out_string); -void pk_TokenArray__dtor(pk_TokenArray* self); +Error* Lexer__process(SourceData_ src, TokenArray* out_tokens); +Error* Lexer__process_and_dump(SourceData_ src, c11_string** out_string); +void TokenArray__dtor(TokenArray* self); #define Token__sv(self) (c11_sv){(self)->start, (self)->length} diff --git a/include/pocketpy/interpreter/frame.h b/include/pocketpy/interpreter/frame.h index d6df9c5e..26640227 100644 --- a/include/pocketpy/interpreter/frame.h +++ b/include/pocketpy/interpreter/frame.h @@ -12,7 +12,7 @@ extern "C" { #endif py_TValue* FastLocals__try_get_by_name(py_TValue* locals, const CodeObject* co, py_Name name); -pk_NameDict* FastLocals__to_namedict(py_TValue* locals, const CodeObject* co); +NameDict* FastLocals__to_namedict(py_TValue* locals, const CodeObject* co); typedef struct ValueStack { // We allocate extra PK_VM_STACK_SIZE/128 places to keep `_sp` valid when `is_overflow() == diff --git a/include/pocketpy/interpreter/gc.h b/include/pocketpy/interpreter/gc.h index c4e420d0..88a6f04c 100644 --- a/include/pocketpy/interpreter/gc.h +++ b/include/pocketpy/interpreter/gc.h @@ -5,29 +5,29 @@ extern "C" { #endif -typedef struct pk_ManagedHeap{ +typedef struct ManagedHeap{ c11_vector no_gc; c11_vector gen; int gc_threshold; int gc_counter; - pk_VM* vm; + VM* vm; - void (*gc_on_delete)(pk_VM*, PyObject*); -} pk_ManagedHeap; + void (*gc_on_delete)(VM*, PyObject*); +} ManagedHeap; -void pk_ManagedHeap__ctor(pk_ManagedHeap* self, pk_VM* vm); -void pk_ManagedHeap__dtor(pk_ManagedHeap* self); +void ManagedHeap__ctor(ManagedHeap* self, VM* vm); +void ManagedHeap__dtor(ManagedHeap* self); -void pk_ManagedHeap__collect_if_needed(pk_ManagedHeap* self); -int pk_ManagedHeap__collect(pk_ManagedHeap* self); -int pk_ManagedHeap__sweep(pk_ManagedHeap* self); +void ManagedHeap__collect_if_needed(ManagedHeap* self); +int ManagedHeap__collect(ManagedHeap* self); +int ManagedHeap__sweep(ManagedHeap* self); -PyObject* pk_ManagedHeap__new(pk_ManagedHeap* self, py_Type type, int slots, int udsize); -PyObject* pk_ManagedHeap__gcnew(pk_ManagedHeap* self, py_Type type, int slots, int udsize); +PyObject* ManagedHeap__new(ManagedHeap* self, py_Type type, int slots, int udsize); +PyObject* ManagedHeap__gcnew(ManagedHeap* self, py_Type type, int slots, int udsize); // external implementation -void pk_ManagedHeap__mark(pk_ManagedHeap* self); +void ManagedHeap__mark(ManagedHeap* self); #ifdef __cplusplus } diff --git a/include/pocketpy/interpreter/vm.h b/include/pocketpy/interpreter/vm.h index 230b3831..44aa5ec7 100644 --- a/include/pocketpy/interpreter/vm.h +++ b/include/pocketpy/interpreter/vm.h @@ -10,7 +10,7 @@ extern "C" { #endif -typedef struct pk_TypeInfo { +typedef struct py_TypeInfo { py_Name name; py_Type base; @@ -24,17 +24,17 @@ typedef struct pk_TypeInfo { c11_vector /*T=py_Name*/ annotated_fields; - void (*on_end_subclass)(struct pk_TypeInfo*); // backdoor for enum module + void (*on_end_subclass)(struct py_TypeInfo*); // backdoor for enum module /* Magic Slots */ py_TValue magic[64]; -} pk_TypeInfo; +} py_TypeInfo; -typedef struct pk_VM { +typedef struct VM { Frame* top_frame; - pk_NameDict modules; - c11_vector /*T=pk_TypeInfo*/ types; + NameDict modules; + c11_vector /*T=py_TypeInfo*/ types; py_TValue builtins; // builtins module py_TValue main; // __main__ module @@ -53,15 +53,15 @@ typedef struct pk_VM { FuncDecl_ __dynamic_func_decl; py_TValue __vectorcall_buffer[PK_MAX_CO_VARNAMES]; - pk_ManagedHeap heap; + ManagedHeap heap; ValueStack stack; // put `stack` at the end for better cache locality -} pk_VM; +} VM; -void pk_VM__ctor(pk_VM* self); -void pk_VM__dtor(pk_VM* self); +void VM__ctor(VM* self); +void VM__dtor(VM* self); -void pk_VM__push_frame(pk_VM* self, Frame* frame); -void pk_VM__pop_frame(pk_VM* self); +void VM__push_frame(VM* self, Frame* frame); +void VM__pop_frame(VM* self); bool pk__parse_int_slice(py_Ref slice, int length, int* start, int* stop, int* step); bool pk__normalize_index(int* index, int length); @@ -69,14 +69,14 @@ bool pk__normalize_index(int* index, int length); void pk_list__mark(void* ud, void (*marker)(py_TValue*)); void pk_dict__mark(void* ud, void (*marker)(py_TValue*)); -typedef enum pk_FrameResult { +typedef enum FrameResult { RES_RETURN, RES_CALL, RES_YIELD, RES_ERROR, -} pk_FrameResult; +} FrameResult; -pk_FrameResult pk_VM__run_top_frame(pk_VM* self); +FrameResult VM__run_top_frame(VM* self); py_Type pk_newtype(const char* name, py_Type base, @@ -85,7 +85,7 @@ py_Type pk_newtype(const char* name, bool is_python, bool is_sealed); -pk_FrameResult pk_VM__vectorcall(pk_VM* self, uint16_t argc, uint16_t kwargc, bool opcall); +FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall); const char* pk_opname(Opcode op); @@ -100,9 +100,9 @@ bool pk_callmagic(py_Name name, int argc, py_Ref argv); /// Assumes [a, b] are on the stack, performs a binary op. /// The result is stored in `self->last_retval`. /// The stack remains unchanged. -bool pk_stack_binaryop(pk_VM* self, py_Name op, py_Name rop); +bool pk_stack_binaryop(VM* self, py_Name op, py_Name rop); -void pk_print_stack(pk_VM* self, Frame* frame, Bytecode byte); +void pk_print_stack(VM* self, Frame* frame, Bytecode byte); // type registration void pk_object__register(); diff --git a/include/pocketpy/objects/base.h b/include/pocketpy/objects/base.h index 9686d60d..5260d935 100644 --- a/include/pocketpy/objects/base.h +++ b/include/pocketpy/objects/base.h @@ -14,8 +14,8 @@ extern "C" { #endif typedef struct PyObject PyObject; -typedef struct pk_VM pk_VM; -extern pk_VM* pk_current_vm; +typedef struct VM VM; +extern VM* pk_current_vm; typedef struct py_TValue { py_Type type; diff --git a/include/pocketpy/objects/codeobject.h b/include/pocketpy/objects/codeobject.h index 146711a9..410f5423 100644 --- a/include/pocketpy/objects/codeobject.h +++ b/include/pocketpy/objects/codeobject.h @@ -68,7 +68,7 @@ typedef struct BytecodeEx { } BytecodeEx; typedef struct CodeObject { - pk_SourceData_ src; + SourceData_ src; c11_string* name; c11_vector /*T=Bytecode*/ codes; @@ -88,7 +88,7 @@ typedef struct CodeObject { int end_line; } CodeObject; -void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_sv name); +void CodeObject__ctor(CodeObject* self, SourceData_ src, c11_sv name); void CodeObject__dtor(CodeObject* self); int CodeObject__add_varname(CodeObject* self, py_Name name); void CodeObject__gc_mark(const CodeObject* self); @@ -118,7 +118,7 @@ typedef struct FuncDecl { typedef FuncDecl* FuncDecl_; -FuncDecl_ FuncDecl__rcnew(pk_SourceData_ src, c11_sv name); +FuncDecl_ FuncDecl__rcnew(SourceData_ src, c11_sv name); bool FuncDecl__is_duplicated_arg(const FuncDecl* self, py_Name name); void FuncDecl__add_arg(FuncDecl* self, py_Name name); void FuncDecl__add_kwarg(FuncDecl* self, py_Name name, const py_TValue* value); @@ -139,7 +139,7 @@ typedef struct Function { FuncDecl_ decl; py_TValue module; // weak ref PyObject* clazz; // weak ref - pk_NameDict* closure; // strong ref + NameDict* closure; // strong ref py_CFunction cfunc; // wrapped C function } Function; diff --git a/include/pocketpy/objects/error.h b/include/pocketpy/objects/error.h index 99ec5704..6e7a3dfc 100644 --- a/include/pocketpy/objects/error.h +++ b/include/pocketpy/objects/error.h @@ -12,14 +12,14 @@ extern "C" { #endif typedef struct{ - pk_SourceData_ src; + SourceData_ src; int lineno; char msg[100]; } Error; void py_BaseException__set_lineno(py_Ref, int lineno, const CodeObject* code); int py_BaseException__get_lineno(py_Ref, const CodeObject* code); -void py_BaseException__stpush(py_Ref, pk_SourceData_ src, int lineno, const char* func_name); +void py_BaseException__stpush(py_Ref, SourceData_ src, int lineno, const char* func_name); #ifdef __cplusplus } diff --git a/include/pocketpy/objects/namedict.h b/include/pocketpy/objects/namedict.h index fd2d1b78..a8090625 100644 --- a/include/pocketpy/objects/namedict.h +++ b/include/pocketpy/objects/namedict.h @@ -12,7 +12,7 @@ extern "C" { #define SMALLMAP_T__HEADER #define K uint16_t #define V py_TValue -#define NAME pk_NameDict +#define NAME NameDict #include "pocketpy/xmacros/smallmap.h" #undef SMALLMAP_T__HEADER diff --git a/include/pocketpy/objects/object.h b/include/pocketpy/objects/object.h index ec1d005e..c86c2e0d 100644 --- a/include/pocketpy/objects/object.h +++ b/include/pocketpy/objects/object.h @@ -22,10 +22,10 @@ typedef struct PyObject { // | HEADER | | py_TValue* PyObject__slots(PyObject* self); -pk_NameDict* PyObject__dict(PyObject* self); +NameDict* PyObject__dict(PyObject* self); void* PyObject__userdata(PyObject* self); -#define PK_OBJ_SLOTS_SIZE(slots) ((slots) >= 0 ? sizeof(py_TValue) * (slots) : sizeof(pk_NameDict)) +#define PK_OBJ_SLOTS_SIZE(slots) ((slots) >= 0 ? sizeof(py_TValue) * (slots) : sizeof(NameDict)) PyObject* PyObject__new(py_Type type, int slots, int size); void PyObject__delete(PyObject* self); diff --git a/include/pocketpy/objects/sourcedata.h b/include/pocketpy/objects/sourcedata.h index d1ae0999..6d0ca73e 100644 --- a/include/pocketpy/objects/sourcedata.h +++ b/include/pocketpy/objects/sourcedata.h @@ -10,7 +10,7 @@ extern "C" { #endif -struct pk_SourceData { +struct SourceData { RefCounted rc; enum py_CompileMode mode; bool is_precompiled; @@ -23,17 +23,17 @@ struct pk_SourceData { c11_vector /*T=c11_string* */ _precompiled_tokens; }; -typedef struct pk_SourceData* pk_SourceData_; +typedef struct SourceData* SourceData_; -pk_SourceData_ pk_SourceData__rcnew(const char* source, +SourceData_ SourceData__rcnew(const char* source, const char* filename, enum py_CompileMode mode, bool is_dynamic); -bool pk_SourceData__get_line(const struct pk_SourceData* self, +bool SourceData__get_line(const struct SourceData* self, int lineno, const char** st, const char** ed); -void pk_SourceData__snapshot(const struct pk_SourceData* self, +void SourceData__snapshot(const struct SourceData* self, c11_sbuf* ss, int lineno, const char* cursor, diff --git a/src/common/memorypool.c b/src/common/memorypool.c index 40adb69f..4b01314a 100644 --- a/src/common/memorypool.c +++ b/src/common/memorypool.c @@ -242,13 +242,13 @@ static FixedMemoryPool PoolExpr; static FixedMemoryPool PoolFrame; static MemoryPool PoolObject; -void pk_MemoryPools__initialize(){ +void MemoryPools__initialize(){ FixedMemoryPool__ctor(&PoolExpr, kPoolExprBlockSize, 64); FixedMemoryPool__ctor(&PoolFrame, kPoolFrameBlockSize, 128); MemoryPool__ctor(&PoolObject); } -void pk_MemoryPools__finalize(){ +void MemoryPools__finalize(){ FixedMemoryPool__dtor(&PoolExpr); FixedMemoryPool__dtor(&PoolFrame); MemoryPool__dtor(&PoolObject); diff --git a/src/common/sourcedata.c b/src/common/sourcedata.c index 0cbdd760..2f032dad 100644 --- a/src/common/sourcedata.c +++ b/src/common/sourcedata.c @@ -4,7 +4,7 @@ #include #include -static void pk_SourceData__ctor(struct pk_SourceData* self, +static void SourceData__ctor(struct SourceData* self, const char* source, const char* filename, enum py_CompileMode mode, @@ -31,7 +31,7 @@ static void pk_SourceData__ctor(struct pk_SourceData* self, c11_vector__push(const char*, &self->line_starts, self->source->data); } -static void pk_SourceData__dtor(struct pk_SourceData* self) { +static void SourceData__dtor(struct SourceData* self) { c11_string__delete(self->filename); c11_string__delete(self->source); @@ -43,18 +43,18 @@ static void pk_SourceData__dtor(struct pk_SourceData* self) { c11_vector__dtor(&self->_precompiled_tokens); } -pk_SourceData_ pk_SourceData__rcnew(const char* source, +SourceData_ SourceData__rcnew(const char* source, const char* filename, enum py_CompileMode mode, bool is_dynamic) { - pk_SourceData_ self = malloc(sizeof(struct pk_SourceData)); - pk_SourceData__ctor(self, source, filename, mode, is_dynamic); + SourceData_ self = malloc(sizeof(struct SourceData)); + SourceData__ctor(self, source, filename, mode, is_dynamic); self->rc.count = 1; - self->rc.dtor = (void (*)(void*))pk_SourceData__dtor; + self->rc.dtor = (void (*)(void*))SourceData__dtor; return self; } -bool pk_SourceData__get_line(const struct pk_SourceData* self, +bool SourceData__get_line(const struct SourceData* self, int lineno, const char** st, const char** ed) { @@ -71,7 +71,7 @@ bool pk_SourceData__get_line(const struct pk_SourceData* self, return true; } -void pk_SourceData__snapshot(const struct pk_SourceData* self, +void SourceData__snapshot(const struct SourceData* self, c11_sbuf* ss, int lineno, const char* cursor, @@ -86,7 +86,7 @@ void pk_SourceData__snapshot(const struct pk_SourceData* self, if(!self->is_precompiled) { c11_sbuf__write_char(ss, '\n'); const char *st = NULL, *ed; - if(pk_SourceData__get_line(self, lineno, &st, &ed)) { + if(SourceData__get_line(self, lineno, &st, &ed)) { while(st < ed && isblank(*st)) ++st; if(st < ed) { diff --git a/src/compiler/compiler.c b/src/compiler/compiler.c index 434d32d5..21258cff 100644 --- a/src/compiler/compiler.c +++ b/src/compiler/compiler.c @@ -1435,13 +1435,13 @@ typedef struct PrattRule { const static PrattRule rules[TK__COUNT__]; typedef struct Compiler { - pk_SourceData_ src; // weakref - pk_TokenArray tokens; + SourceData_ src; // weakref + TokenArray tokens; int i; c11_vector /*T=CodeEmitContext*/ contexts; } Compiler; -static void Compiler__ctor(Compiler* self, pk_SourceData_ src, pk_TokenArray tokens) { +static void Compiler__ctor(Compiler* self, SourceData_ src, TokenArray tokens) { self->src = src; self->tokens = tokens; self->i = 0; @@ -1449,7 +1449,7 @@ static void Compiler__ctor(Compiler* self, pk_SourceData_ src, pk_TokenArray tok } static void Compiler__dtor(Compiler* self) { - pk_TokenArray__dtor(&self->tokens); + TokenArray__dtor(&self->tokens); c11__foreach(Ctx, &self->contexts, ctx) Ctx__dtor(ctx); c11_vector__dtor(&self->contexts); } @@ -1470,8 +1470,8 @@ static void Compiler__dtor(Compiler* self) { if(!match(expected)) \ return SyntaxError(self, \ "expected '%s', got '%s'", \ - pk_TokenSymbols[expected], \ - pk_TokenSymbols[curr()->type]); + TokenSymbols[expected], \ + TokenSymbols[curr()->type]); #define consume_end_stmt() \ if(!match_end_stmt(self)) return SyntaxError(self, "expected statement end") @@ -1531,7 +1531,7 @@ static bool match_end_stmt(Compiler* self) { static Error* parse_expression(Compiler* self, int precedence, bool allow_slice) { PrattCallback prefix = rules[curr()->type].prefix; if(!prefix || (curr()->type == TK_COLON && !allow_slice)) { - return SyntaxError(self, "expected an expression, got %s", pk_TokenSymbols[curr()->type]); + return SyntaxError(self, "expected an expression, got %s", TokenSymbols[curr()->type]); } advance(); Error* err; @@ -2782,9 +2782,9 @@ Error* Compiler__compile(Compiler* self, CodeObject* out) { return NULL; } -Error* pk_compile(pk_SourceData_ src, CodeObject* out) { - pk_TokenArray tokens; - Error* err = pk_Lexer__process(src, &tokens); +Error* pk_compile(SourceData_ src, CodeObject* out) { + TokenArray tokens; + Error* err = Lexer__process(src, &tokens); if(err) return err; // Token* data = (Token*)tokens.data; @@ -2792,7 +2792,7 @@ Error* pk_compile(pk_SourceData_ src, CodeObject* out) { // for(int i = 0; i < tokens.count; i++) { // Token* t = data + i; // c11_string* tmp = c11_string__new2(t->start, t->length); - // printf("[%d] %s: %s\n", t->line, pk_TokenSymbols[t->type], tmp->data); + // printf("[%d] %s: %s\n", t->line, TokenSymbols[t->type], tmp->data); // c11_string__delete(tmp); // } diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c index a0cd740a..ea5e776e 100644 --- a/src/compiler/lexer.c +++ b/src/compiler/lexer.c @@ -10,8 +10,8 @@ #define is_raw_string_used(t) ((t) == TK_ID || (t) == TK_LONG) -typedef struct pk_Lexer{ - pk_SourceData_ src; +typedef struct Lexer{ + SourceData_ src; const char* token_start; const char* curr_char; int current_line; @@ -19,7 +19,7 @@ typedef struct pk_Lexer{ c11_vector/*T=Token*/ nexts; c11_vector/*T=int*/ indents; -} pk_Lexer; +} Lexer; typedef struct TokenDeserializer { const char* curr; @@ -37,7 +37,7 @@ double TokenDeserializer__read_float(TokenDeserializer* self, char c); const static TokenValue EmptyTokenValue; -static void pk_Lexer__ctor(pk_Lexer* self, pk_SourceData_ src){ +static void Lexer__ctor(Lexer* self, SourceData_ src){ PK_INCREF(src); self->src = src; self->curr_char = self->token_start = src->source->data; @@ -47,20 +47,20 @@ static void pk_Lexer__ctor(pk_Lexer* self, pk_SourceData_ src){ c11_vector__ctor(&self->indents, sizeof(int)); } -static void pk_Lexer__dtor(pk_Lexer* self){ +static void Lexer__dtor(Lexer* self){ PK_DECREF(self->src); c11_vector__dtor(&self->nexts); c11_vector__dtor(&self->indents); } -static char eatchar(pk_Lexer* self){ +static char eatchar(Lexer* self){ char c = *self->curr_char; assert(c != '\n'); // eatchar() cannot consume a newline self->curr_char++; return c; } -static char eatchar_include_newline(pk_Lexer* self){ +static char eatchar_include_newline(Lexer* self){ char c = *self->curr_char; self->curr_char++; if(c == '\n') { @@ -70,7 +70,7 @@ static char eatchar_include_newline(pk_Lexer* self){ return c; } -static int eat_spaces(pk_Lexer* self){ +static int eat_spaces(Lexer* self){ int count = 0; while(true) { switch(*self->curr_char) { @@ -82,13 +82,13 @@ static int eat_spaces(pk_Lexer* self){ } } -static bool matchchar(pk_Lexer* self, char c){ +static bool matchchar(Lexer* self, char c){ if(*self->curr_char != c) return false; eatchar_include_newline(self); return true; } -static bool match_n_chars(pk_Lexer* self, int n, char c0){ +static bool match_n_chars(Lexer* self, int n, char c0){ const char* c = self->curr_char; for(int i = 0; i < n; i++) { if(*c == '\0') return false; @@ -100,14 +100,14 @@ static bool match_n_chars(pk_Lexer* self, int n, char c0){ return true; } -static void skip_line_comment(pk_Lexer* self){ +static void skip_line_comment(Lexer* self){ while(*self->curr_char) { if(*self->curr_char == '\n') return; eatchar(self); } } -static void add_token_with_value(pk_Lexer* self, TokenIndex type, TokenValue value){ +static void add_token_with_value(Lexer* self, TokenIndex type, TokenValue value){ switch(type) { case TK_LBRACE: case TK_LBRACKET: @@ -142,18 +142,18 @@ static void add_token_with_value(pk_Lexer* self, TokenIndex type, TokenValue val } } -static void add_token(pk_Lexer* self, TokenIndex type){ +static void add_token(Lexer* self, TokenIndex type){ add_token_with_value(self, type, EmptyTokenValue); } -static void add_token_2(pk_Lexer* self, char c, TokenIndex one, TokenIndex two){ +static void add_token_2(Lexer* self, char c, TokenIndex one, TokenIndex two){ if(matchchar(self, c)) add_token(self, two); else add_token(self, one); } -static bool eat_indentation(pk_Lexer* self){ +static bool eat_indentation(Lexer* self){ if(self->brackets_level > 0) return true; int spaces = eat_spaces(self); if(*self->curr_char == '#') skip_line_comment(self); @@ -192,7 +192,7 @@ static bool is_possible_number_char(char c){ } /******************************/ -static Error* SyntaxError(pk_Lexer* self, const char* fmt, ...){ +static Error* SyntaxError(Lexer* self, const char* fmt, ...){ Error* err = malloc(sizeof(Error)); err->src = self->src; PK_INCREF(self->src); @@ -207,7 +207,7 @@ static Error* SyntaxError(pk_Lexer* self, const char* fmt, ...){ return err; } -static Error* eat_name(pk_Lexer* self){ +static Error* eat_name(Lexer* self){ self->curr_char--; while(true) { unsigned char c = *self->curr_char; @@ -247,7 +247,7 @@ static Error* eat_name(pk_Lexer* self){ if(length == 0) return SyntaxError(self, "@id contains invalid char"); c11_sv name = {self->token_start, length}; - const char** KW_BEGIN = pk_TokenSymbols + TK_FALSE; + const char** KW_BEGIN = TokenSymbols + TK_FALSE; int KW_COUNT = TK__COUNT__ - TK_FALSE; #define less(a, b) (c11_sv__cmp2(b, a) > 0) int out; @@ -262,7 +262,7 @@ static Error* eat_name(pk_Lexer* self){ return NULL; } -static Error* eat_string_until(pk_Lexer* self, char quote, bool raw, c11_string** out) { +static Error* eat_string_until(Lexer* self, char quote, bool raw, c11_string** out) { // previous char is quote bool quote3 = match_n_chars(self, 2, quote); c11_sbuf buff; @@ -321,7 +321,7 @@ enum StringType { NORMAL_BYTES }; -static Error* eat_string(pk_Lexer* self, char quote, enum StringType type){ +static Error* eat_string(Lexer* self, char quote, enum StringType type){ c11_string* s; Error* err = eat_string_until(self, quote, type == RAW_STRING, &s); if(err) return err; @@ -336,7 +336,7 @@ static Error* eat_string(pk_Lexer* self, char quote, enum StringType type){ return NULL; } -static Error* eat_number(pk_Lexer* self){ +static Error* eat_number(Lexer* self){ const char* i = self->token_start; while(is_possible_number_char(*i)) i++; @@ -389,7 +389,7 @@ static Error* eat_number(pk_Lexer* self){ return SyntaxError(self, "invalid number literal"); } -static Error* lex_one_token(pk_Lexer* self, bool* eof){ +static Error* lex_one_token(Lexer* self, bool* eof){ *eof = false; while(*self->curr_char) { self->token_start = self->curr_char; @@ -532,7 +532,7 @@ static Error* lex_one_token(pk_Lexer* self, bool* eof){ return NULL; } -static Error* from_precompiled(pk_Lexer* self) { +static Error* from_precompiled(Lexer* self) { TokenDeserializer deserializer; TokenDeserializer__ctor(&deserializer, self->src->source->data); @@ -603,14 +603,14 @@ static Error* from_precompiled(pk_Lexer* self) { return NULL; } -Error* pk_Lexer__process(pk_SourceData_ src, pk_TokenArray* out_tokens){ - pk_Lexer lexer; - pk_Lexer__ctor(&lexer, src); +Error* Lexer__process(SourceData_ src, TokenArray* out_tokens){ + Lexer lexer; + Lexer__ctor(&lexer, src); if(src->is_precompiled) { Error* err = from_precompiled(&lexer); // TODO: set out tokens - pk_Lexer__dtor(&lexer); + Lexer__dtor(&lexer); return err; } // push initial tokens @@ -622,21 +622,21 @@ Error* pk_Lexer__process(pk_SourceData_ src, pk_TokenArray* out_tokens){ while(!eof) { void* err = lex_one_token(&lexer, &eof); if(err){ - pk_Lexer__dtor(&lexer); + Lexer__dtor(&lexer); return err; } } // set out_tokens *out_tokens = c11_vector__submit(&lexer.nexts); - pk_Lexer__dtor(&lexer); + Lexer__dtor(&lexer); return NULL; } -Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out) { +Error* Lexer__process_and_dump(SourceData_ src, c11_string** out) { assert(!src->is_precompiled); - pk_TokenArray nexts; // output tokens - Error* err = pk_Lexer__process(src, &nexts); + TokenArray nexts; // output tokens + Error* err = Lexer__process(src, &nexts); if(err) return err; c11_sbuf ss; @@ -729,7 +729,7 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out) { return NULL; } -void pk_TokenArray__dtor(pk_TokenArray *self){ +void TokenArray__dtor(TokenArray *self){ Token* data = self->data; for(int i=0; icount; i++){ if(data[i].value.index == TokenValue_STR){ @@ -739,7 +739,7 @@ void pk_TokenArray__dtor(pk_TokenArray *self){ c11_array__dtor(self); } -const char* pk_TokenSymbols[] = { +const char* TokenSymbols[] = { "@eof", "@eol", "@sof", "@id", "@num", "@str", "@fstr", "@long", "@bytes", "@imag", "@indent", "@dedent", diff --git a/src/interpreter/ceval.c b/src/interpreter/ceval.c index 47233cf0..a53c1692 100644 --- a/src/interpreter/ceval.c +++ b/src/interpreter/ceval.c @@ -9,7 +9,7 @@ #include "pocketpy/objects/error.h" #include -static bool stack_unpack_sequence(pk_VM* self, uint16_t arg); +static bool stack_unpack_sequence(VM* self, uint16_t arg); static bool format_object(py_Ref obj, c11_sv spec); #define DISPATCH() \ @@ -54,7 +54,7 @@ static bool format_object(py_Ref obj, c11_sv spec); #define vectorcall_opcall(argc, kwargc) \ do { \ - pk_FrameResult res = pk_VM__vectorcall(self, (argc), (kwargc), true); \ + FrameResult res = VM__vectorcall(self, (argc), (kwargc), true); \ switch(res) { \ case RES_RETURN: PUSH(&self->last_retval); break; \ case RES_CALL: frame = self->top_frame; goto __NEXT_FRAME; \ @@ -75,7 +75,7 @@ static bool unpack_dict_to_buffer(py_Ref key, py_Ref val, void* ctx) { return TypeError("keywords must be strings, not '%t'", key->type); } -pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { +FrameResult VM__run_top_frame(VM* self) { Frame* frame = self->top_frame; const Frame* base_frame = frame; @@ -139,7 +139,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { ud->closure = FastLocals__to_namedict(frame->locals, frame->locals_co); py_Name name = py_namev(c11_string__sv(decl->code.name)); // capture itself to allow recursion - pk_NameDict__set(ud->closure, name, *SP()); + NameDict__set(ud->closure, name, *SP()); } SP()++; DISPATCH(); @@ -619,7 +619,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { DISPATCH(); } case OP_CALL: { - pk_ManagedHeap__collect_if_needed(&self->heap); + ManagedHeap__collect_if_needed(&self->heap); vectorcall_opcall(byte.arg & 0xFF, byte.arg >> 8); DISPATCH(); } @@ -684,7 +684,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { } else { py_newnone(&self->last_retval); } - pk_VM__pop_frame(self); + VM__pop_frame(self); if(frame == base_frame) { // [ frameBase<- ] return RES_RETURN; } else { @@ -770,8 +770,8 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { } case OP_POP_IMPORT_STAR: { // [module] - pk_NameDict* dict = PyObject__dict(TOP()->_obj); - py_Ref all = pk_NameDict__try_get(dict, __all__); + NameDict* dict = PyObject__dict(TOP()->_obj); + py_Ref all = NameDict__try_get(dict, __all__); if(all) { int length; py_TValue* p = pk_arrayview(all, &length); @@ -781,7 +781,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { } for(int i = 0; i < length; i++) { py_Name name = py_namev(py_tosv(p + i)); - py_Ref value = pk_NameDict__try_get(dict, name); + py_Ref value = NameDict__try_get(dict, name); if(value == NULL) { ImportError("cannot import name '%n'", name); goto __ERROR; @@ -791,7 +791,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { } } else { for(int i = 0; i < dict->count; i++) { - pk_NameDict_KV* kv = c11__at(pk_NameDict_KV, dict, i); + NameDict_KV* kv = c11__at(NameDict_KV, dict, i); if(!kv->key) continue; c11_sv name = py_name2sv(kv->key); if(name.size == 0 || name.data[0] == '_') continue; @@ -854,10 +854,10 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { if(py_istype(TOP(), tp_type)) { // call on_end_subclass - pk_TypeInfo* ti = c11__at(pk_TypeInfo, &self->types, py_totype(TOP())); + py_TypeInfo* ti = c11__at(py_TypeInfo, &self->types, py_totype(TOP())); if(ti->base != tp_object) { // PyTypeInfo* base_ti = &_all_types[ti->base]; - pk_TypeInfo* base_ti = c11__at(pk_TypeInfo, &self->types, ti->base); + py_TypeInfo* base_ti = c11__at(py_TypeInfo, &self->types, ti->base); if(base_ti->on_end_subclass) base_ti->on_end_subclass(ti); } } @@ -877,7 +877,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { } case OP_ADD_CLASS_ANNOTATION: { py_Type type = py_totype(self->__curr_class); - pk_TypeInfo* ti = c11__at(pk_TypeInfo, &self->types, type); + py_TypeInfo* ti = c11__at(py_TypeInfo, &self->types, type); c11_vector__push(py_Name, &ti->annotated_fields, byte.arg); DISPATCH(); } @@ -970,7 +970,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { } else { // 2. Exception need to be propagated to the upper frame bool is_base_frame_to_be_popped = frame == base_frame; - pk_VM__pop_frame(self); + VM__pop_frame(self); if(self->top_frame == NULL || is_base_frame_to_be_popped) { // propagate to the top level return RES_ERROR; @@ -983,7 +983,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) { return RES_RETURN; } -bool pk_stack_binaryop(pk_VM* self, py_Name op, py_Name rop) { +bool pk_stack_binaryop(VM* self, py_Name op, py_Name rop) { // [a, b] py_Ref magic = py_tpfindmagic(SECOND()->type, op); if(magic) { @@ -1014,7 +1014,7 @@ bool pk_stack_binaryop(pk_VM* self, py_Name op, py_Name rop) { } bool py_binaryop(py_Ref lhs, py_Ref rhs, py_Name op, py_Name rop) { - pk_VM* self = pk_current_vm; + VM* self = pk_current_vm; PUSH(lhs); PUSH(rhs); bool ok = pk_stack_binaryop(self, op, rop); @@ -1022,7 +1022,7 @@ bool py_binaryop(py_Ref lhs, py_Ref rhs, py_Name op, py_Name rop) { return ok; } -static bool stack_unpack_sequence(pk_VM* self, uint16_t arg) { +static bool stack_unpack_sequence(VM* self, uint16_t arg) { int length; py_TValue* p = pk_arrayview(TOP(), &length); if(!p) return TypeError("expected list or tuple to unpack, got '%t'", TOP()->type); diff --git a/src/interpreter/frame.c b/src/interpreter/frame.c index a7c861f5..68a5d5a0 100644 --- a/src/interpreter/frame.c +++ b/src/interpreter/frame.c @@ -14,11 +14,11 @@ py_TValue* FastLocals__try_get_by_name(py_TValue* locals, const CodeObject* co, return &locals[index]; } -pk_NameDict* FastLocals__to_namedict(py_TValue* locals, const CodeObject* co) { - pk_NameDict* dict = pk_NameDict__new(); +NameDict* FastLocals__to_namedict(py_TValue* locals, const CodeObject* co) { + NameDict* dict = NameDict__new(); c11__foreach(c11_smallmap_n2i_KV, &co->varnames_inv, entry) { py_TValue value = locals[entry->value]; - if(!py_isnil(&value)) { pk_NameDict__set(dict, entry->key, value); } + if(!py_isnil(&value)) { NameDict__set(dict, entry->key, value); } } return dict; } @@ -134,6 +134,6 @@ py_TValue* Frame__f_closure_try_get(Frame* self, py_Name name) { // if(self->function == NULL) return NULL; // pkpy::Function* fn = PyObject__as(pkpy::Function, self->function); // if(fn->_closure == nullptr) return nullptr; - // return pk_NameDict__try_get(fn->_closure, name); + // return NameDict__try_get(fn->_closure, name); return NULL; } \ No newline at end of file diff --git a/src/interpreter/gc.c b/src/interpreter/gc.c index 656aeb38..821bf741 100644 --- a/src/interpreter/gc.c +++ b/src/interpreter/gc.c @@ -2,7 +2,7 @@ #include "pocketpy/common/memorypool.h" #include "pocketpy/objects/base.h" -void pk_ManagedHeap__ctor(pk_ManagedHeap *self, pk_VM *vm){ +void ManagedHeap__ctor(ManagedHeap *self, VM *vm){ c11_vector__ctor(&self->no_gc, sizeof(PyObject*)); c11_vector__ctor(&self->gen, sizeof(PyObject*)); @@ -13,7 +13,7 @@ void pk_ManagedHeap__ctor(pk_ManagedHeap *self, pk_VM *vm){ self->gc_on_delete = NULL; } -void pk_ManagedHeap__dtor(pk_ManagedHeap *self){ +void ManagedHeap__dtor(ManagedHeap *self){ for(int i = 0; i < self->gen.count; i++){ PyObject* obj = c11__getitem(PyObject*, &self->gen, i); PyObject__delete(obj); @@ -26,23 +26,23 @@ void pk_ManagedHeap__dtor(pk_ManagedHeap *self){ c11_vector__dtor(&self->gen); } -void pk_ManagedHeap__collect_if_needed(pk_ManagedHeap *self){ +void ManagedHeap__collect_if_needed(ManagedHeap *self){ if(self->gc_counter < self->gc_threshold) return; self->gc_counter = 0; - pk_ManagedHeap__collect(self); + ManagedHeap__collect(self); self->gc_threshold = self->gen.count * 2; if(self->gc_threshold < PK_GC_MIN_THRESHOLD){ self->gc_threshold = PK_GC_MIN_THRESHOLD; } } -int pk_ManagedHeap__collect(pk_ManagedHeap *self){ - pk_ManagedHeap__mark(self); - int freed = pk_ManagedHeap__sweep(self); +int ManagedHeap__collect(ManagedHeap *self){ + ManagedHeap__mark(self); + int freed = ManagedHeap__sweep(self); return freed; } -int pk_ManagedHeap__sweep(pk_ManagedHeap *self){ +int ManagedHeap__sweep(ManagedHeap *self){ c11_vector alive; c11_vector__ctor(&alive, sizeof(PyObject*)); c11_vector__reserve(&alive, self->gen.count / 2); @@ -77,13 +77,13 @@ int pk_ManagedHeap__sweep(pk_ManagedHeap *self){ return freed; } -PyObject* pk_ManagedHeap__new(pk_ManagedHeap *self, py_Type type, int slots, int udsize){ +PyObject* ManagedHeap__new(ManagedHeap *self, py_Type type, int slots, int udsize){ PyObject* obj = PyObject__new(type, slots, udsize); c11_vector__push(PyObject*, &self->no_gc, obj); return obj; } -PyObject* pk_ManagedHeap__gcnew(pk_ManagedHeap *self, py_Type type, int slots, int udsize){ +PyObject* ManagedHeap__gcnew(ManagedHeap *self, py_Type type, int slots, int udsize){ PyObject* obj = PyObject__new(type, slots, udsize); c11_vector__push(PyObject*, &self->gen, obj); self->gc_counter++; @@ -111,7 +111,7 @@ PyObject* PyObject__new(py_Type type, int slots, int size){ if(slots >= 0){ memset(p, 0, slots*sizeof(py_TValue)); }else{ - pk_NameDict__ctor(p); + NameDict__ctor(p); } return self; } diff --git a/src/interpreter/vm.c b/src/interpreter/vm.c index f266df72..5ad9e6af 100644 --- a/src/interpreter/vm.c +++ b/src/interpreter/vm.c @@ -25,19 +25,19 @@ static char* pk_default_import_file(const char* path) { static void pk_default_print(const char* data) { printf("%s", data); } -static void pk_TypeInfo__ctor(pk_TypeInfo* self, +static void py_TypeInfo__ctor(py_TypeInfo* self, py_Name name, py_Type index, py_Type base, py_TValue module) { - memset(self, 0, sizeof(pk_TypeInfo)); + memset(self, 0, sizeof(py_TypeInfo)); self->name = name; self->base = base; // create type object with __dict__ - pk_ManagedHeap* heap = &pk_current_vm->heap; - PyObject* typeobj = pk_ManagedHeap__new(heap, tp_type, -1, sizeof(py_Type)); + ManagedHeap* heap = &pk_current_vm->heap; + PyObject* typeobj = ManagedHeap__new(heap, tp_type, -1, sizeof(py_Type)); *(py_Type*)PyObject__userdata(typeobj) = index; self->self = (py_TValue){ .type = typeobj->type, @@ -49,13 +49,13 @@ static void pk_TypeInfo__ctor(pk_TypeInfo* self, c11_vector__ctor(&self->annotated_fields, sizeof(py_Name)); } -static void pk_TypeInfo__dtor(pk_TypeInfo* self) { c11_vector__dtor(&self->annotated_fields); } +static void py_TypeInfo__dtor(py_TypeInfo* self) { c11_vector__dtor(&self->annotated_fields); } -void pk_VM__ctor(pk_VM* self) { +void VM__ctor(VM* self) { self->top_frame = NULL; - pk_NameDict__ctor(&self->modules); - c11_vector__ctor(&self->types, sizeof(pk_TypeInfo)); + NameDict__ctor(&self->modules); + c11_vector__ctor(&self->types, sizeof(py_TypeInfo)); self->builtins = *py_NIL; self->main = *py_NIL; @@ -71,13 +71,13 @@ void pk_VM__ctor(pk_VM* self) { self->__curr_class = NULL; self->__dynamic_func_decl = NULL; - pk_ManagedHeap__ctor(&self->heap, self); + ManagedHeap__ctor(&self->heap, self); ValueStack__ctor(&self->stack); /* Init Builtin Types */ // 0: unused void* placeholder = c11_vector__emplace(&self->types); - memset(placeholder, 0, sizeof(pk_TypeInfo)); + memset(placeholder, 0, sizeof(py_TypeInfo)); #define validate(t, expr) \ if(t != (expr)) abort() @@ -154,7 +154,7 @@ void pk_VM__ctor(pk_VM* self) { for(int i = 0; i < c11__count_array(public_types); i++) { py_Type t = public_types[i]; - pk_TypeInfo* ti = c11__at(pk_TypeInfo, &self->types, t); + py_TypeInfo* ti = c11__at(py_TypeInfo, &self->types, t); py_setdict(&self->builtins, ti->name, py_tpobject(t)); } @@ -196,24 +196,24 @@ void pk_VM__ctor(pk_VM* self) { self->main = *py_newmodule("__main__"); } -void pk_VM__dtor(pk_VM* self) { +void VM__dtor(VM* self) { if(self->__dynamic_func_decl) { PK_DECREF(self->__dynamic_func_decl); } // destroy all objects - pk_ManagedHeap__dtor(&self->heap); + ManagedHeap__dtor(&self->heap); // clear frames // ... - pk_NameDict__dtor(&self->modules); - c11__foreach(pk_TypeInfo, &self->types, ti) pk_TypeInfo__dtor(ti); + NameDict__dtor(&self->modules); + c11__foreach(py_TypeInfo, &self->types, ti) py_TypeInfo__dtor(ti); c11_vector__dtor(&self->types); ValueStack__clear(&self->stack); } -void pk_VM__push_frame(pk_VM* self, Frame* frame) { +void VM__push_frame(VM* self, Frame* frame) { frame->f_back = self->top_frame; self->top_frame = frame; } -void pk_VM__pop_frame(pk_VM* self) { +void VM__pop_frame(VM* self) { assert(self->top_frame); Frame* frame = self->top_frame; // reset stack pointer @@ -293,9 +293,9 @@ py_Type pk_newtype(const char* name, bool is_sealed) { c11_vector* types = &pk_current_vm->types; py_Type index = types->count; - pk_TypeInfo* ti = c11_vector__emplace(types); - pk_TypeInfo__ctor(ti, py_name(name), index, base, module ? *module : *py_NIL); - if(!dtor && base) { dtor = c11__at(pk_TypeInfo, types, base)->dtor; } + py_TypeInfo* ti = c11_vector__emplace(types); + py_TypeInfo__ctor(ti, py_name(name), index, base, module ? *module : *py_NIL); + if(!dtor && base) { dtor = c11__at(py_TypeInfo, types, base)->dtor; } ti->dtor = dtor; ti->is_python = is_python; ti->is_sealed = is_sealed; @@ -373,7 +373,7 @@ static bool return true; } -pk_FrameResult pk_VM__vectorcall(pk_VM* self, uint16_t argc, uint16_t kwargc, bool opcall) { +FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall) { pk_print_stack(self, self->top_frame, (Bytecode){0}); py_Ref p1 = self->stack.sp - kwargc * 2; @@ -416,8 +416,8 @@ pk_FrameResult pk_VM__vectorcall(pk_VM* self, uint16_t argc, uint16_t kwargc, bo memcpy(argv, self->__vectorcall_buffer, co->nlocals * sizeof(py_TValue)); // submit the call if(!fn->cfunc) { - pk_VM__push_frame(self, Frame__new(co, &fn->module, p0, p0, argv, co)); - return opcall ? RES_CALL : pk_VM__run_top_frame(self); + VM__push_frame(self, Frame__new(co, &fn->module, p0, p0, argv, co)); + return opcall ? RES_CALL : VM__run_top_frame(self); } else { bool ok = fn->cfunc(co->nlocals, argv); self->stack.sp = p0; @@ -440,8 +440,8 @@ pk_FrameResult pk_VM__vectorcall(pk_VM* self, uint16_t argc, uint16_t kwargc, bo // initialize local variables to py_NIL memset(p1, 0, (char*)self->stack.sp - (char*)p1); // submit the call - pk_VM__push_frame(self, Frame__new(co, &fn->module, p0, p0, argv, co)); - return opcall ? RES_CALL : pk_VM__run_top_frame(self); + VM__push_frame(self, Frame__new(co, &fn->module, p0, p0, argv, co)); + return opcall ? RES_CALL : VM__run_top_frame(self); case FuncType_GENERATOR: assert(false); break; @@ -476,7 +476,7 @@ pk_FrameResult pk_VM__vectorcall(pk_VM* self, uint16_t argc, uint16_t kwargc, bo memcpy(self->stack.sp, argv, span * sizeof(py_TValue)); self->stack.sp += span; // [new_f, cls, args..., kwargs...] - if(pk_VM__vectorcall(self, argc, kwargc, false) == RES_ERROR) return RES_ERROR; + if(VM__vectorcall(self, argc, kwargc, false) == RES_ERROR) return RES_ERROR; // by recursively using vectorcall, args and kwargs are consumed // try __init__ @@ -489,7 +489,7 @@ pk_FrameResult pk_VM__vectorcall(pk_VM* self, uint16_t argc, uint16_t kwargc, bo *p0 = *init_f; // __init__ p0[1] = self->last_retval; // self // [__init__, self, args..., kwargs...] - if(pk_VM__vectorcall(self, argc, kwargc, false) == RES_ERROR) return RES_ERROR; + if(VM__vectorcall(self, argc, kwargc, false) == RES_ERROR) return RES_ERROR; *py_retval() = p0[1]; // restore the new instance } // reset the stack @@ -500,7 +500,7 @@ pk_FrameResult pk_VM__vectorcall(pk_VM* self, uint16_t argc, uint16_t kwargc, bo // handle `__call__` overload if(pk_pushmethod(p0, __call__)) { // [__call__, self, args..., kwargs...] - return pk_VM__vectorcall(self, argc, kwargc, opcall); + return VM__vectorcall(self, argc, kwargc, opcall); } TypeError("'%t' object is not callable", p0->type); @@ -509,9 +509,9 @@ pk_FrameResult pk_VM__vectorcall(pk_VM* self, uint16_t argc, uint16_t kwargc, bo /****************************************/ void PyObject__delete(PyObject* self) { - pk_TypeInfo* ti = c11__at(pk_TypeInfo, &pk_current_vm->types, self->type); + py_TypeInfo* ti = c11__at(py_TypeInfo, &pk_current_vm->types, self->type); if(ti->dtor) ti->dtor(PyObject__userdata(self)); - if(self->slots == -1) pk_NameDict__dtor(PyObject__dict(self)); + if(self->slots == -1) NameDict__dtor(PyObject__dict(self)); if(self->gc_is_large) { free(self); } else { @@ -537,9 +537,9 @@ static void mark_object(PyObject* obj) { } if(obj->slots == -1) { - pk_NameDict* dict = PyObject__dict(obj); + NameDict* dict = PyObject__dict(obj); for(int j = 0; j < dict->count; j++) { - pk_NameDict_KV* kv = c11__at(pk_NameDict_KV, dict, j); + NameDict_KV* kv = c11__at(NameDict_KV, dict, j); mark_value(&kv->value); } return; @@ -552,8 +552,8 @@ static void mark_object(PyObject* obj) { } } -void pk_ManagedHeap__mark(pk_ManagedHeap* self) { - pk_VM* vm = self->vm; +void ManagedHeap__mark(ManagedHeap* self) { + VM* vm = self->vm; // mark heap objects for(int i = 0; i < self->no_gc.count; i++) { PyObject* obj = c11__getitem(PyObject*, &self->no_gc, i); @@ -576,7 +576,7 @@ void pk_ManagedHeap__mark(pk_ManagedHeap* self) { } } -void pk_print_stack(pk_VM* self, Frame* frame, Bytecode byte) { +void pk_print_stack(VM* self, Frame* frame, Bytecode byte) { return; if(frame == NULL) return; diff --git a/src/objects/codeobject.c b/src/objects/codeobject.c index 8fd398e7..7862f1ba 100644 --- a/src/objects/codeobject.c +++ b/src/objects/codeobject.c @@ -20,7 +20,7 @@ static void FuncDecl__dtor(FuncDecl* self) { c11_smallmap_n2i__dtor(&self->kw_to_index); } -FuncDecl_ FuncDecl__rcnew(pk_SourceData_ src, c11_sv name) { +FuncDecl_ FuncDecl__rcnew(SourceData_ src, c11_sv name) { FuncDecl* self = malloc(sizeof(FuncDecl)); self->rc.count = 1; self->rc.dtor = (void (*)(void*))FuncDecl__dtor; @@ -94,7 +94,7 @@ FuncDecl_ FuncDecl__build(c11_sv name, py_Ref kwdefaults, // a tuple contains default values c11_sv starred_kwarg, const char* docstring) { - pk_SourceData_ source = pk_SourceData__rcnew("pass", "", EXEC_MODE, false); + SourceData_ source = SourceData__rcnew("pass", "", EXEC_MODE, false); FuncDecl_ decl = FuncDecl__rcnew(source, name); for(int i = 0; i < argc; i++) { FuncDecl__add_arg(decl, py_namev(args[i])); @@ -111,7 +111,7 @@ FuncDecl_ FuncDecl__build(c11_sv name, return decl; } -void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_sv name) { +void CodeObject__ctor(CodeObject* self, SourceData_ src, c11_sv name) { self->src = src; PK_INCREF(src); self->name = c11_string__new2(name.data, name.size); @@ -179,5 +179,5 @@ int CodeObject__add_varname(CodeObject* self, py_Name name) { void Function__dtor(Function* self) { PK_DECREF(self->decl); - if(self->closure) pk_NameDict__delete(self->closure); + if(self->closure) NameDict__delete(self->closure); } \ No newline at end of file diff --git a/src/objects/namedict.c b/src/objects/namedict.c index 2c170f49..b8ba304b 100644 --- a/src/objects/namedict.c +++ b/src/objects/namedict.c @@ -3,6 +3,6 @@ #define SMALLMAP_T__SOURCE #define K uint16_t #define V py_TValue -#define NAME pk_NameDict +#define NAME NameDict #include "pocketpy/xmacros/smallmap.h" #undef SMALLMAP_T__SOURCE diff --git a/src/objects/object.c b/src/objects/object.c index 15365a3f..1e104aed 100644 --- a/src/objects/object.c +++ b/src/objects/object.c @@ -4,9 +4,9 @@ void* PyObject__userdata(PyObject* self) { return self->flex + PK_OBJ_SLOTS_SIZE(self->slots); } -pk_NameDict* PyObject__dict(PyObject* self) { +NameDict* PyObject__dict(PyObject* self) { assert(self->slots == -1); - return (pk_NameDict*)(self->flex); + return (NameDict*)(self->flex); } py_TValue* PyObject__slots(PyObject* self) { diff --git a/src/public/cast.c b/src/public/cast.c index 788a1704..c27b8e8f 100644 --- a/src/public/cast.c +++ b/src/public/cast.c @@ -49,7 +49,7 @@ bool py_checktype(py_Ref self, py_Type type) { bool py_isinstance(py_Ref obj, py_Type type) { return py_issubclass(obj->type, type); } bool py_issubclass(py_Type derived, py_Type base) { - pk_TypeInfo* types = pk_current_vm->types.data; + py_TypeInfo* types = pk_current_vm->types.data; do { if(derived == base) return true; derived = types[derived].base; diff --git a/src/public/internal.c b/src/public/internal.c index cc16b862..a2f32d9b 100644 --- a/src/public/internal.c +++ b/src/public/internal.c @@ -9,18 +9,18 @@ #include "pocketpy/compiler/compiler.h" #include -pk_VM* pk_current_vm; +VM* pk_current_vm; py_GlobalRef py_True; py_GlobalRef py_False; py_GlobalRef py_None; py_GlobalRef py_NIL; -static pk_VM pk_default_vm; -static pk_VM* pk_all_vm[16]; +static VM pk_default_vm; +static VM* pk_all_vm[16]; void py_initialize() { - pk_MemoryPools__initialize(); + MemoryPools__initialize(); py_Name__initialize(); pk_current_vm = pk_all_vm[0] = &pk_default_vm; @@ -35,28 +35,28 @@ void py_initialize() { py_False = &_False; py_None = &_None; py_NIL = &_NIL; - pk_VM__ctor(&pk_default_vm); + VM__ctor(&pk_default_vm); } void py_finalize() { for(int i = 1; i < 16; i++) { - pk_VM* vm = pk_all_vm[i]; + VM* vm = pk_all_vm[i]; if(vm) { - pk_VM__dtor(vm); + VM__dtor(vm); free(vm); } } - pk_VM__dtor(&pk_default_vm); + VM__dtor(&pk_default_vm); pk_current_vm = NULL; py_Name__finalize(); - pk_MemoryPools__finalize(); + MemoryPools__finalize(); } void py_switchvm(int index) { if(index < 0 || index >= 16) c11__abort("invalid vm index"); if(!pk_all_vm[index]) { - pk_all_vm[index] = malloc(sizeof(pk_VM)); - pk_VM__ctor(pk_all_vm[index]); + pk_all_vm[index] = malloc(sizeof(VM)); + VM__ctor(pk_all_vm[index]); } pk_current_vm = pk_all_vm[index]; } @@ -184,9 +184,9 @@ static void disassemble(CodeObject* co) { } bool py_exec(const char* source, const char* filename, enum py_CompileMode mode, py_Ref module) { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; CodeObject co; - pk_SourceData_ src = pk_SourceData__rcnew(source, filename, mode, false); + SourceData_ src = SourceData__rcnew(source, filename, mode, false); Error* err = pk_compile(src, &co); if(err) { py_exception("SyntaxError", err->msg); @@ -201,8 +201,8 @@ bool py_exec(const char* source, const char* filename, enum py_CompileMode mode, if(!module) module = &vm->main; Frame* frame = Frame__new(&co, module, NULL, vm->stack.sp, vm->stack.sp, &co); - pk_VM__push_frame(vm, frame); - pk_FrameResult res = pk_VM__run_top_frame(vm); + VM__push_frame(vm, frame); + FrameResult res = VM__run_top_frame(vm); CodeObject__dtor(&co); PK_DECREF(src); if(res == RES_ERROR) return false; @@ -225,8 +225,8 @@ bool py_call(py_Ref f, int argc, py_Ref argv) { bool py_callmethod(py_Ref self, py_Name name, int argc, py_Ref argv) { return -1; } bool py_vectorcall(uint16_t argc, uint16_t kwargc) { - pk_VM* vm = pk_current_vm; - return pk_VM__vectorcall(vm, argc, kwargc, false) != RES_ERROR; + VM* vm = pk_current_vm; + return VM__vectorcall(vm, argc, kwargc, false) != RES_ERROR; } py_Ref py_retval() { return &pk_current_vm->last_retval; } @@ -262,7 +262,7 @@ bool pk_pushmethod(py_StackRef self, py_Name name) { break; case tp_classmethod: self[0] = *py_getslot(cls_var, 0); - self[1] = c11__getitem(pk_TypeInfo, &pk_current_vm->types, type).self; + self[1] = c11__getitem(py_TypeInfo, &pk_current_vm->types, type).self; break; default: c11__unreachedable(); } @@ -274,7 +274,7 @@ bool pk_pushmethod(py_StackRef self, py_Name name) { py_Ref py_tpfindmagic(py_Type t, py_Name name) { assert(py_ismagicname(name)); - pk_TypeInfo* types = (pk_TypeInfo*)pk_current_vm->types.data; + py_TypeInfo* types = (py_TypeInfo*)pk_current_vm->types.data; do { py_Ref f = &types[t].magic[name]; if(!py_isnil(f)) return f; @@ -284,7 +284,7 @@ py_Ref py_tpfindmagic(py_Type t, py_Name name) { } py_Ref py_tpfindname(py_Type t, py_Name name) { - pk_TypeInfo* types = (pk_TypeInfo*)pk_current_vm->types.data; + py_TypeInfo* types = (py_TypeInfo*)pk_current_vm->types.data; do { py_Ref res = py_getdict(&types[t].self, name); if(res) return res; @@ -295,20 +295,20 @@ py_Ref py_tpfindname(py_Type t, py_Name name) { py_Ref py_tpmagic(py_Type type, py_Name name) { assert(py_ismagicname(name)); - pk_VM* vm = pk_current_vm; - return &c11__at(pk_TypeInfo, &vm->types, type)->magic[name]; + VM* vm = pk_current_vm; + return &c11__at(py_TypeInfo, &vm->types, type)->magic[name]; } py_Ref py_tpobject(py_Type type) { assert(type); - pk_VM* vm = pk_current_vm; - return &c11__at(pk_TypeInfo, &vm->types, type)->self; + VM* vm = pk_current_vm; + return &c11__at(py_TypeInfo, &vm->types, type)->self; } const char* py_tpname(py_Type type) { if(!type) return "nil"; - pk_VM* vm = pk_current_vm; - py_Name name = c11__at(pk_TypeInfo, &vm->types, type)->name; + VM* vm = pk_current_vm; + py_Name name = c11__at(py_TypeInfo, &vm->types, type)->name; return py_name2str(name); } @@ -325,7 +325,7 @@ bool pk_callmagic(py_Name name, int argc, py_Ref argv) { } bool StopIteration() { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; assert(!vm->is_stopiteration); // flag is already set vm->is_stopiteration = true; return false; diff --git a/src/public/modules.c b/src/public/modules.c index 65216ce8..732f84c1 100644 --- a/src/public/modules.c +++ b/src/public/modules.c @@ -7,13 +7,13 @@ #include "pocketpy/common/_generated.h" py_Ref py_getmodule(const char* path) { - pk_VM* vm = pk_current_vm; - return pk_NameDict__try_get(&vm->modules, py_name(path)); + VM* vm = pk_current_vm; + return NameDict__try_get(&vm->modules, py_name(path)); } py_Ref py_newmodule(const char* path) { - pk_ManagedHeap* heap = &pk_current_vm->heap; - PyObject* obj = pk_ManagedHeap__new(heap, tp_module, -1, 0); + ManagedHeap* heap = &pk_current_vm->heap; + PyObject* obj = ManagedHeap__new(heap, tp_module, -1, 0); py_Ref r0 = py_pushtmp(); py_Ref r1 = py_pushtmp(); @@ -44,9 +44,9 @@ py_Ref py_newmodule(const char* path) { // we do not allow override in order to avoid memory leak // it is because Module objects are not garbage collected py_Name path_name = py_name(path); - bool exists = pk_NameDict__contains(&pk_current_vm->modules, path_name); + bool exists = NameDict__contains(&pk_current_vm->modules, path_name); if(exists) c11__abort("module '%s' already exists", path); - pk_NameDict__set(&pk_current_vm->modules, path_name, *r0); + NameDict__set(&pk_current_vm->modules, path_name, *r0); py_shrink(2); return py_getmodule(path); @@ -55,7 +55,7 @@ py_Ref py_newmodule(const char* path) { int py_import(const char* path_cstr) { // printf("importing %s\n", path_cstr); - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; c11_sv path = {path_cstr, strlen(path_cstr)}; if(path.size == 0) return ValueError("empty module name"); diff --git a/src/public/py_exception.c b/src/public/py_exception.c index f92f5a23..9786fb29 100644 --- a/src/public/py_exception.c +++ b/src/public/py_exception.c @@ -8,7 +8,7 @@ #include "pocketpy/common/sstream.h" typedef struct BaseExceptionFrame { - pk_SourceData_ src; + SourceData_ src; int lineno; c11_string* name; } BaseExceptionFrame; @@ -31,7 +31,7 @@ int py_BaseException__get_lineno(py_Ref self, const CodeObject* code) { return ud->lineno_backup; } -void py_BaseException__stpush(py_Ref self, pk_SourceData_ src, int lineno, const char* func_name) { +void py_BaseException__stpush(py_Ref self, SourceData_ src, int lineno, const char* func_name) { BaseException* ud = py_touserdata(self); if(ud->stacktrace.count >= 7) return; BaseExceptionFrame* frame = c11_vector__emplace(&ud->stacktrace); @@ -111,12 +111,12 @@ py_Type pk_Exception__register() { ////////////////////////////////////////////////// bool py_checkexc() { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; return !py_isnil(&vm->curr_exception); } void py_clearexc(py_StackRef p0) { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; vm->last_retval = *py_NIL; vm->curr_exception = *py_NIL; vm->is_stopiteration = false; @@ -133,7 +133,7 @@ void py_printexc() { } char* py_formatexc() { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; if(py_isnil(&vm->curr_exception)) return NULL; c11_sbuf ss; c11_sbuf__ctor(&ss); @@ -144,7 +144,7 @@ char* py_formatexc() { for(int i = ud->stacktrace.count - 1; i >= 0; i--) { BaseExceptionFrame* frame = c11__at(BaseExceptionFrame, &ud->stacktrace, i); - pk_SourceData__snapshot(frame->src, + SourceData__snapshot(frame->src, &ss, frame->lineno, NULL, @@ -191,7 +191,7 @@ bool py_exception(const char* name, const char* fmt, ...) { bool py_raise(py_Ref exc) { assert(py_isinstance(exc, tp_BaseException)); - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; vm->curr_exception = *exc; return false; } diff --git a/src/public/py_list.c b/src/public/py_list.c index 40566897..4f169ddf 100644 --- a/src/public/py_list.c +++ b/src/public/py_list.c @@ -354,7 +354,7 @@ static bool list__insert(int argc, py_Ref argv) { static int lt_with_key(py_TValue* a, py_TValue* b, py_TValue* key) { if(!key) return py_less(a, b); - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; // project a py_push(key); py_pushnil(); diff --git a/src/public/py_object.c b/src/public/py_object.c index 7bf22f92..5d6046ec 100644 --- a/src/public/py_object.c +++ b/src/public/py_object.c @@ -5,7 +5,7 @@ static bool object__new__(int argc, py_Ref argv) { if(argc == 0) return TypeError("object.__new__(): not enough arguments"); py_Type cls = py_totype(py_arg(0)); - pk_TypeInfo* ti = c11__at(pk_TypeInfo, &pk_current_vm->types, cls); + py_TypeInfo* ti = c11__at(py_TypeInfo, &pk_current_vm->types, cls); if(!ti->is_python) { return TypeError("object.__new__(%t) is not safe, use %t.__new__()", cls, cls); } @@ -63,7 +63,7 @@ static bool type__new__(int argc, py_Ref argv) { static bool type__base__getter(int argc, py_Ref argv) { PY_CHECK_ARGC(1); py_Type type = py_totype(argv); - pk_TypeInfo* ti = c11__at(pk_TypeInfo, &pk_current_vm->types, type); + py_TypeInfo* ti = c11__at(py_TypeInfo, &pk_current_vm->types, type); py_assign(py_retval(), py_tpobject(ti->base)); return true; } diff --git a/src/public/py_ops.c b/src/public/py_ops.c index ef617caa..23ec4507 100644 --- a/src/public/py_ops.c +++ b/src/public/py_ops.c @@ -45,7 +45,7 @@ int py_bool(py_Ref val) { bool py_hash(py_Ref val, int64_t* out) { py_Type t = val->type; - pk_TypeInfo* types = (pk_TypeInfo*)pk_current_vm->types.data; + py_TypeInfo* types = (py_TypeInfo*)pk_current_vm->types.data; do { py_Ref _hash = &types[t].magic[__hash__]; if(py_isnone(_hash)) break; @@ -68,7 +68,7 @@ bool py_iter(py_Ref val) { } int py_next(py_Ref val) { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; vm->is_stopiteration = false; py_Ref tmp = py_tpfindmagic(val->type, __next__); if(!tmp) return TypeError("'%t' object is not an iterator", val->type); diff --git a/src/public/py_slice.c b/src/public/py_slice.c index 738c0a8b..0f31a736 100644 --- a/src/public/py_slice.c +++ b/src/public/py_slice.c @@ -6,8 +6,8 @@ #include "pocketpy/interpreter/vm.h" void py_newslice(py_Ref out) { - pk_VM* vm = pk_current_vm; - PyObject* obj = pk_ManagedHeap__gcnew(&vm->heap, tp_slice, 3, 0); + VM* vm = pk_current_vm; + PyObject* obj = ManagedHeap__gcnew(&vm->heap, tp_slice, 3, 0); out->type = tp_slice; out->is_ptr = true; out->_obj = obj; diff --git a/src/public/py_str.c b/src/public/py_str.c index 04bea8fd..45178943 100644 --- a/src/public/py_str.c +++ b/src/public/py_str.c @@ -9,9 +9,9 @@ void py_newstr(py_Ref out, const char* data) { py_newstrn(out, data, strlen(data)); } void py_newstrn(py_Ref out, const char* data, int size) { - pk_ManagedHeap* heap = &pk_current_vm->heap; + ManagedHeap* heap = &pk_current_vm->heap; int total_size = sizeof(c11_string) + size + 1; - PyObject* obj = pk_ManagedHeap__gcnew(heap, tp_str, 0, total_size); + PyObject* obj = ManagedHeap__gcnew(heap, tp_str, 0, total_size); c11_string* ud = PyObject__userdata(obj); c11_string__ctor2(ud, data, size); out->type = tp_str; @@ -20,9 +20,9 @@ void py_newstrn(py_Ref out, const char* data, int size) { } unsigned char* py_newbytes(py_Ref out, int size) { - pk_ManagedHeap* heap = &pk_current_vm->heap; + ManagedHeap* heap = &pk_current_vm->heap; // 4 bytes size + data - PyObject* obj = pk_ManagedHeap__gcnew(heap, tp_bytes, 0, sizeof(c11_bytes) + size); + PyObject* obj = ManagedHeap__gcnew(heap, tp_bytes, 0, sizeof(c11_bytes) + size); c11_bytes* ud = PyObject__userdata(obj); ud->size = size; out->type = tp_bytes; diff --git a/src/public/py_tuple.c b/src/public/py_tuple.c index b961162e..344d4d1c 100644 --- a/src/public/py_tuple.c +++ b/src/public/py_tuple.c @@ -6,8 +6,8 @@ #include "pocketpy/interpreter/vm.h" void py_newtuple(py_Ref out, int n) { - pk_VM* vm = pk_current_vm; - PyObject* obj = pk_ManagedHeap__gcnew(&vm->heap, tp_tuple, n, 0); + VM* vm = pk_current_vm; + PyObject* obj = ManagedHeap__gcnew(&vm->heap, tp_tuple, n, 0); out->type = tp_tuple; out->is_ptr = true; out->_obj = obj; diff --git a/src/public/stack_ops.c b/src/public/stack_ops.c index 04d9477a..741aae3d 100644 --- a/src/public/stack_ops.c +++ b/src/public/stack_ops.c @@ -11,7 +11,7 @@ void py_setreg(int i, py_Ref val) { pk_current_vm->reg[i] = *val; } py_Ref py_getdict(py_Ref self, py_Name name) { assert(self && self->is_ptr); if(!py_ismagicname(name) || self->type != tp_type) { - return pk_NameDict__try_get(PyObject__dict(self->_obj), name); + return NameDict__try_get(PyObject__dict(self->_obj), name); } else { py_Type* ud = py_touserdata(self); py_Ref slot = py_tpmagic(*ud, name); @@ -22,7 +22,7 @@ py_Ref py_getdict(py_Ref self, py_Name name) { void py_setdict(py_Ref self, py_Name name, py_Ref val) { assert(self && self->is_ptr); if(!py_ismagicname(name) || self->type != tp_type) { - pk_NameDict__set(PyObject__dict(self->_obj), name, *val); + NameDict__set(PyObject__dict(self->_obj), name, *val); } else { py_Type* ud = py_touserdata(self); *py_tpmagic(*ud, name) = *val; @@ -37,7 +37,7 @@ py_TmpRef py_emplacedict(py_Ref self, py_Name name){ bool py_deldict(py_Ref self, py_Name name) { assert(self && self->is_ptr); if(!py_ismagicname(name) || self->type != tp_type) { - return pk_NameDict__del(PyObject__dict(self->_obj), name); + return NameDict__del(PyObject__dict(self->_obj), name); } else { py_Type* ud = py_touserdata(self); @@ -67,27 +67,27 @@ py_Ref py_peek(int i) { } void py_pop() { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; vm->stack.sp--; } void py_shrink(int n) { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; vm->stack.sp -= n; } void py_push(py_Ref src) { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; *vm->stack.sp++ = *src; } void py_pushnil() { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; py_newnil(vm->stack.sp++); } py_Ref py_pushtmp() { - pk_VM* vm = pk_current_vm; + VM* vm = pk_current_vm; py_newnil(vm->stack.sp++); return py_peek(-1); } \ No newline at end of file diff --git a/src/public/values.c b/src/public/values.c index 4b7b1cc5..e9c88728 100644 --- a/src/public/values.c +++ b/src/public/values.c @@ -84,7 +84,7 @@ py_Name snprintf(buffer, sizeof(buffer), "def %s: pass", sig); // fn(a, b, *c, d=1) -> None CodeObject code; - pk_SourceData_ source = pk_SourceData__rcnew(buffer, "", EXEC_MODE, false); + SourceData_ source = SourceData__rcnew(buffer, "", EXEC_MODE, false); Error* err = pk_compile(source, &code); if(err || code.func_decls.count != 1) { c11__abort("py_newfunction(): invalid signature '%s'", sig); @@ -102,8 +102,8 @@ py_Name } void* py_newobject(py_Ref out, py_Type type, int slots, int udsize) { - pk_ManagedHeap* heap = &pk_current_vm->heap; - PyObject* obj = pk_ManagedHeap__gcnew(heap, type, slots, udsize); + ManagedHeap* heap = &pk_current_vm->heap; + PyObject* obj = ManagedHeap__gcnew(heap, type, slots, udsize); out->type = type; out->is_ptr = true; out->_obj = obj;