Zxc200611/pocketpy
1
0
Fork 0
mirror of https://github.com/pocketpy/pocketpy synced 2026-08-05 05:37:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix bugs

Browse Source
This commit is contained in:
blueloveTH 2026-07-27 03:18:48 +08:00
parent acc4f4104b
commit a06e6ac6ba
2 changed files with 63 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/compiler/lexer.c
View File

@ -189,8 +189,8 @@ static Error* LexerError(Lexer* self, const char* fmt, ...) {
err->src = self->src; err->src = self->src;
PK_INCREF(self->src); PK_INCREF(self->src);
err->lineno = self->current_line; err->lineno = self->current_line;
const char* end = self->src->source->data + self->src->source->size; const char* p_end = self->src->source->data + self->src->source->size;
if(self->curr_char <= end && *self->curr_char == '\n') { err->lineno--; } if(self->curr_char <= p_end && *self->curr_char == '\n') { err->lineno--; }
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
vsnprintf(err->msg, sizeof(err->msg), fmt, args); vsnprintf(err->msg, sizeof(err->msg), fmt, args);
@ -282,9 +282,16 @@ static Error* _eat_string(Lexer* self, c11_sbuf* buff, char quote, enum StringTy
case 'b': c11_sbuf__write_char(buff, '\b'); break; case 'b': c11_sbuf__write_char(buff, '\b'); break;
case 'f': c11_sbuf__write_char(buff, '\f'); break; case 'f': c11_sbuf__write_char(buff, '\f'); break;
case 'v': c11_sbuf__write_char(buff, '\v'); break; case 'v': c11_sbuf__write_char(buff, '\v'); break;
// Special case for the often used \0 while we don't have full support for octal literals. // Special case for the often used \0 while we don't have full support for octal
// literals.
case '0': c11_sbuf__write_char(buff, '\0'); break; case '0': c11_sbuf__write_char(buff, '\0'); break;
case 'x': { case 'x': {
// check there are at least 2 chars can read
const char* p_end = self->src->source->data + self->src->source->size;
if(p_end - self->curr_char < 2) {
return LexerError(self, "invalid hex escape");
}
char hex[3] = {eatchar(self), eatchar(self), '\0'}; char hex[3] = {eatchar(self), eatchar(self), '\0'};
int code; int code;
if(sscanf(hex, "%x", &code) != 1 || code > 0xFF) { if(sscanf(hex, "%x", &code) != 1 || code > 0xFF) {

97
src/interpreter/vm.c
View File

@ -713,53 +713,62 @@ void ManagedHeap__mark(ManagedHeap* self) {
} }
} }
void* ud = PyObject__userdata(obj); if(obj->type > tp_object) {
switch(obj->type) { // NOTE: `defaultdict` -> `dict` -> `object`
case tp_list: { // NOTE: native types must extend from `object`.
List* self = ud; py_TypeInfo* ti = pk_typeinfo(obj->type);
for(int i = 0; i < self->length; i++) { while(ti->base != tp_object) {
py_TValue* val = c11__at(py_TValue, self, i); ti = ti->base_ti;
pk__mark_value(val); }
void* ud = PyObject__userdata(obj);
switch(ti->index) {
case tp_list: {
List* self = ud;
for(int i = 0; i < self->length; i++) {
py_TValue* val = c11__at(py_TValue, self, i);
pk__mark_value(val);
}
break;
} }
break; case tp_dict: {
} Dict* self = ud;
case tp_dict: { for(int i = 0; i < self->entries.length; i++) {
Dict* self = ud; DictEntry* entry = c11__at(DictEntry, &self->entries, i);
for(int i = 0; i < self->entries.length; i++) { if(py_isnil(&entry->key)) continue;
DictEntry* entry = c11__at(DictEntry, &self->entries, i); pk__mark_value(&entry->key);
if(py_isnil(&entry->key)) continue; pk__mark_value(&entry->val);
pk__mark_value(&entry->key); }
pk__mark_value(&entry->val); break;
} }
break; case tp_generator: {
} Generator* self = ud;
case tp_generator: { if(self->frame) Frame__gc_mark(self->frame, p_stack);
Generator* self = ud; break;
if(self->frame) Frame__gc_mark(self->frame, p_stack); }
break; case tp_function: {
} function__gc_mark(ud, p_stack);
case tp_function: { break;
function__gc_mark(ud, p_stack); }
break; case tp_BaseException: {
} BaseException* self = ud;
case tp_BaseException: { pk__mark_value(&self->args);
BaseException* self = ud; pk__mark_value(&self->inner_exc);
pk__mark_value(&self->args); c11__foreach(BaseExceptionFrame, &self->stacktrace, frame) {
pk__mark_value(&self->inner_exc); pk__mark_value(&frame->locals);
c11__foreach(BaseExceptionFrame, &self->stacktrace, frame) { pk__mark_value(&frame->globals);
pk__mark_value(&frame->locals); }
pk__mark_value(&frame->globals); break;
}
case tp_code: {
CodeObject* self = ud;
CodeObject__gc_mark(self, p_stack);
break;
}
case tp_chunked_array2d: {
c11_chunked_array2d__mark(ud, p_stack);
break;
} }
break;
}
case tp_code: {
CodeObject* self = ud;
CodeObject__gc_mark(self, p_stack);
break;
}
case tp_chunked_array2d: {
c11_chunked_array2d__mark(ud, p_stack);
break;
} }
} }
} }