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

...

Browse Source
This commit is contained in:
blueloveTH 2024-08-04 19:09:50 +08:00
parent cd9a9f7119
commit 56763e05f9
35 changed files with 251 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/pocketpy/common/memorypool.h
View File

@ -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*);

2
include/pocketpy/compiler/compiler.h
View File

@ -9,7 +9,7 @@
extern "C" {
#endif
Error* pk_compile(pk_SourceData_ src, CodeObject* out);
Error* pk_compile(SourceData_ src, CodeObject* out);
#ifdef __cplusplus
}

10
include/pocketpy/compiler/lexer.h
View File

@ -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}

2
include/pocketpy/interpreter/frame.h
View File

@ -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() ==

24
include/pocketpy/interpreter/gc.h
View File

@ -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
}

36
include/pocketpy/interpreter/vm.h
View File

@ -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();

4
include/pocketpy/objects/base.h
View File

@ -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;

8
include/pocketpy/objects/codeobject.h
View File

@ -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;

4
include/pocketpy/objects/error.h
View File

@ -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
}

2
include/pocketpy/objects/namedict.h
View File

@ -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

4
include/pocketpy/objects/object.h
View File

@ -22,10 +22,10 @@ typedef struct PyObject {
// | HEADER | <dict> | <userdata>
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);

10
include/pocketpy/objects/sourcedata.h
View File

@ -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,

4
src/common/memorypool.c
View File

@ -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);

18
src/common/sourcedata.c
View File

@ -4,7 +4,7 @@
#include <stdlib.h>
#include <string.h>
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) {

22
src/compiler/compiler.c
View File

@ -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);
// }

68
src/compiler/lexer.c
View File

@ -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; i<self->count; 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",

34
src/interpreter/ceval.c
View File

@ -9,7 +9,7 @@
#include "pocketpy/objects/error.h"
#include <stdbool.h>
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);

8
src/interpreter/frame.c
View File

@ -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;
}

22
src/interpreter/gc.c
View File

@ -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;
}

70
src/interpreter/vm.c
View File

@ -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;

8
src/objects/codeobject.c
View File

@ -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", "<bind>", EXEC_MODE, false);
SourceData_ source = SourceData__rcnew("pass", "<bind>", 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);
}

2
src/objects/namedict.c
View File

@ -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

4
src/objects/object.c
View File

@ -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) {

2
src/public/cast.c
View File

@ -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;

54
src/public/internal.c
View File

@ -9,18 +9,18 @@
#include "pocketpy/compiler/compiler.h"
#include <stdint.h>
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;

14
src/public/modules.c
View File

@ -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");

14
src/public/py_exception.c
View File

@ -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;
}

2
src/public/py_list.c
View File

@ -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();

4
src/public/py_object.c
View File

@ -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;
}

4
src/public/py_ops.c
View File

@ -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);

4
src/public/py_slice.c
View File

@ -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;

8
src/public/py_str.c
View File

@ -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;

4
src/public/py_tuple.c
View File

@ -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;

16
src/public/stack_ops.c
View File

@ -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);
}

6
src/public/values.c
View File

@ -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, "<bind>", EXEC_MODE, false);
SourceData_ source = SourceData__rcnew(buffer, "<bind>", 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;