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

remove unused code

Browse Source
This commit is contained in:
blueloveTH 2024-11-13 10:51:54 +08:00
parent 05e1de4101
commit 2f96054a4e
7 changed files with 69 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/pocketpy/common/vector.h
View File

@ -1,21 +1,11 @@
#pragma once #pragma once
#include "pocketpy/common/algorithm.h"
#include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdbool.h>
#include <assert.h> #include <assert.h>
#include <string.h>
#include <stdbool.h>
typedef struct c11_array { #include "algorithm.h"
void* data;
int length;
int elem_size;
} c11_array;
void c11_array__ctor(c11_array* self, int elem_size, int length);
void c11_array__dtor(c11_array* self);
c11_array c11_array__copy(const c11_array* self);
typedef struct c11_vector { typedef struct c11_vector {
void* data; void* data;
@ -31,7 +21,7 @@ void c11_vector__reserve(c11_vector* self, int capacity);
void c11_vector__clear(c11_vector* self); void c11_vector__clear(c11_vector* self);
void* c11_vector__emplace(c11_vector* self); void* c11_vector__emplace(c11_vector* self);
bool c11_vector__contains(const c11_vector* self, void* elem); bool c11_vector__contains(const c11_vector* self, void* elem);
c11_array c11_vector__submit(c11_vector* self); void* c11_vector__submit(c11_vector* self, int* length);
#define c11__getitem(T, self, index) (((T*)(self)->data)[index]) #define c11__getitem(T, self, index) (((T*)(self)->data)[index])
#define c11__setitem(T, self, index, value) ((T*)(self)->data)[index] = value; #define c11__setitem(T, self, index, value) ((T*)(self)->data)[index] = value;

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

@ -84,9 +84,6 @@ enum Precedence {
PREC_HIGHEST, PREC_HIGHEST,
}; };
typedef c11_array TokenArray; Error* Lexer__process(SourceData_ src, Token** out_tokens, int* out_length);
Error* Lexer__process(SourceData_ src, TokenArray* out_tokens);
void TokenArray__dtor(TokenArray* self);
#define Token__sv(self) (c11_sv){(self)->start, (self)->length} #define Token__sv(self) (c11_sv){(self)->start, (self)->length}

4
include/pocketpy/config.h
View File

@ -1,10 +1,10 @@
#pragma once #pragma once
// clang-format off // clang-format off
#define PK_VERSION "2.0.1" #define PK_VERSION "2.0.2"
#define PK_VERSION_MAJOR 2 #define PK_VERSION_MAJOR 2
#define PK_VERSION_MINOR 0 #define PK_VERSION_MINOR 0
#define PK_VERSION_PATCH 1 #define PK_VERSION_PATCH 2
/*************** feature settings ***************/ /*************** feature settings ***************/

6
src/common/sstream.c
View File

@ -140,9 +140,9 @@ void c11_sbuf__write_ptr(c11_sbuf* self, void* p) {
c11_string* c11_sbuf__submit(c11_sbuf* self) { c11_string* c11_sbuf__submit(c11_sbuf* self) {
c11_vector__push(char, &self->data, '\0'); c11_vector__push(char, &self->data, '\0');
c11_array arr = c11_vector__submit(&self->data); int arr_length;
c11_string* retval = arr.data; c11_string* retval = c11_vector__submit(&self->data, &arr_length);
retval->size = arr.length - sizeof(c11_string) - 1; retval->size = arr_length - sizeof(c11_string) - 1;
return retval; return retval;
} }

27
src/common/vector.c
View File

@ -3,24 +3,6 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
void c11_array__ctor(c11_array* self, int elem_size, int length){
self->data = malloc(elem_size * length);
self->length = length;
self->elem_size = elem_size;
}
void c11_array__dtor(c11_array* self){
free(self->data);
self->data = NULL;
self->length = 0;
}
c11_array c11_array__copy(const c11_array* self){
c11_array retval;
c11_array__ctor(&retval, self->elem_size, self->length);
memcpy(retval.data, self->data, self->elem_size * self->length);
return retval;
}
void c11_vector__ctor(c11_vector* self, int elem_size){ void c11_vector__ctor(c11_vector* self, int elem_size){
self->data = NULL; self->data = NULL;
@ -71,12 +53,9 @@ bool c11_vector__contains(const c11_vector *self, void *elem){
return false; return false;
} }
c11_array c11_vector__submit(c11_vector* self){ void* c11_vector__submit(c11_vector* self, int* length){
c11_array retval = { void* retval = self->data;
.data = self->data, *length = self->length;
.length = self->length,
.elem_size = self->elem_size
};
self->data = NULL; self->data = NULL;
self->length = 0; self->length = 0;
self->capacity = 0; self->capacity = 0;

91
src/compiler/compiler.c
View File

@ -445,23 +445,26 @@ static DictItemExpr* DictItemExpr__new(int line) {
// ListExpr, DictExpr, SetExpr, TupleExpr // ListExpr, DictExpr, SetExpr, TupleExpr
typedef struct SequenceExpr { typedef struct SequenceExpr {
EXPR_COMMON_HEADER EXPR_COMMON_HEADER
c11_array /*T=Expr* */ items; Expr** items;
int itemCount;
Opcode opcode; Opcode opcode;
} SequenceExpr; } SequenceExpr;
static void SequenceExpr__emit_(Expr* self_, Ctx* ctx) { static void SequenceExpr__emit_(Expr* self_, Ctx* ctx) {
SequenceExpr* self = (SequenceExpr*)self_; SequenceExpr* self = (SequenceExpr*)self_;
for(int i = 0; i < self->items.length; i++) { for(int i = 0; i < self->itemCount; i++) {
Expr* item = c11__getitem(Expr*, &self->items, i); Expr* item = self->items[i];
vtemit_(item, ctx); vtemit_(item, ctx);
} }
Ctx__emit_(ctx, self->opcode, self->items.length, self->line); Ctx__emit_(ctx, self->opcode, self->itemCount, self->line);
} }
void SequenceExpr__dtor(Expr* self_) { void SequenceExpr__dtor(Expr* self_) {
SequenceExpr* self = (SequenceExpr*)self_; SequenceExpr* self = (SequenceExpr*)self_;
c11__foreach(Expr*, &self->items, e) vtdelete(*e); for(int i = 0; i < self->itemCount; i++) {
c11_array__dtor(&self->items); vtdelete(self->items[i]);
}
free(self->items);
} }
bool TupleExpr__emit_store(Expr* self_, Ctx* ctx) { bool TupleExpr__emit_store(Expr* self_, Ctx* ctx) {
@ -469,8 +472,8 @@ bool TupleExpr__emit_store(Expr* self_, Ctx* ctx) {
// TOS is an iterable // TOS is an iterable
// items may contain StarredExpr, we should check it // items may contain StarredExpr, we should check it
int starred_i = -1; int starred_i = -1;
for(int i = 0; i < self->items.length; i++) { for(int i = 0; i < self->itemCount; i++) {
Expr* e = c11__getitem(Expr*, &self->items, i); Expr* e = self->items[i];
if(e->vt->is_starred) { if(e->vt->is_starred) {
if(((StarredExpr*)e)->level > 0) { if(((StarredExpr*)e)->level > 0) {
if(starred_i == -1) if(starred_i == -1)
@ -483,24 +486,24 @@ bool TupleExpr__emit_store(Expr* self_, Ctx* ctx) {
if(starred_i == -1) { if(starred_i == -1) {
Bytecode* prev = c11__at(Bytecode, &ctx->co->codes, ctx->co->codes.length - 1); Bytecode* prev = c11__at(Bytecode, &ctx->co->codes, ctx->co->codes.length - 1);
if(prev->op == OP_BUILD_TUPLE && prev->arg == self->items.length) { if(prev->op == OP_BUILD_TUPLE && prev->arg == self->itemCount) {
// build tuple and unpack it is meaningless // build tuple and unpack it is meaningless
Ctx__revert_last_emit_(ctx); Ctx__revert_last_emit_(ctx);
} else { } else {
Ctx__emit_(ctx, OP_UNPACK_SEQUENCE, self->items.length, self->line); Ctx__emit_(ctx, OP_UNPACK_SEQUENCE, self->itemCount, self->line);
} }
} else { } else {
// starred assignment target must be in a tuple // starred assignment target must be in a tuple
if(self->items.length == 1) return false; if(self->itemCount == 1) return false;
// starred assignment target must be the last one (differ from cpython) // starred assignment target must be the last one (differ from cpython)
if(starred_i != self->items.length - 1) return false; if(starred_i != self->itemCount - 1) return false;
// a,*b = [1,2,3] // a,*b = [1,2,3]
// stack is [1,2,3] -> [1,[2,3]] // stack is [1,2,3] -> [1,[2,3]]
Ctx__emit_(ctx, OP_UNPACK_EX, self->items.length - 1, self->line); Ctx__emit_(ctx, OP_UNPACK_EX, self->itemCount - 1, self->line);
} }
// do reverse emit // do reverse emit
for(int i = self->items.length - 1; i >= 0; i--) { for(int i = self->itemCount - 1; i >= 0; i--) {
Expr* e = c11__getitem(Expr*, &self->items, i); Expr* e = self->items[i];
bool ok = vtemit_store(e, ctx); bool ok = vtemit_store(e, ctx);
if(!ok) return false; if(!ok) return false;
} }
@ -509,8 +512,9 @@ bool TupleExpr__emit_store(Expr* self_, Ctx* ctx) {
bool TupleExpr__emit_del(Expr* self_, Ctx* ctx) { bool TupleExpr__emit_del(Expr* self_, Ctx* ctx) {
SequenceExpr* self = (SequenceExpr*)self_; SequenceExpr* self = (SequenceExpr*)self_;
c11__foreach(Expr*, &self->items, e) { for(int i = 0; i < self->itemCount; i++) {
bool ok = vtemit_del(*e, ctx); Expr* e = self->items[i];
bool ok = vtemit_del(e, ctx);
if(!ok) return false; if(!ok) return false;
} }
return true; return true;
@ -522,7 +526,8 @@ static SequenceExpr* SequenceExpr__new(int line, const ExprVt* vt, int count, Op
self->vt = vt; self->vt = vt;
self->line = line; self->line = line;
self->opcode = opcode; self->opcode = opcode;
c11_array__ctor(&self->items, sizeof(Expr*), count); self->items = malloc(sizeof(Expr*) * count);
self->itemCount = count;
return self; return self;
} }
@ -1295,29 +1300,41 @@ const static PrattRule rules[TK__COUNT__];
typedef struct Compiler { typedef struct Compiler {
SourceData_ src; // weakref SourceData_ src; // weakref
TokenArray tokens;
int i; Token* tokens;
int tokens_length;
int i; // current token index
c11_vector /*T=CodeEmitContext*/ contexts; c11_vector /*T=CodeEmitContext*/ contexts;
} Compiler; } Compiler;
static void Compiler__ctor(Compiler* self, SourceData_ src, TokenArray tokens) { static void Compiler__ctor(Compiler* self, SourceData_ src, Token* tokens, int tokens_length) {
self->src = src; self->src = src;
self->tokens = tokens; self->tokens = tokens;
self->tokens_length = tokens_length;
self->i = 0; self->i = 0;
c11_vector__ctor(&self->contexts, sizeof(Ctx)); c11_vector__ctor(&self->contexts, sizeof(Ctx));
} }
static void Compiler__dtor(Compiler* self) { static void Compiler__dtor(Compiler* self) {
TokenArray__dtor(&self->tokens); // free tokens
for(int i = 0; i < self->tokens_length; i++) {
if(self->tokens[i].value.index == TokenValue_STR) {
// free internal string
c11_string__delete(self->tokens[i].value._str);
}
}
free(self->tokens);
// free contexts
c11__foreach(Ctx, &self->contexts, ctx) Ctx__dtor(ctx); c11__foreach(Ctx, &self->contexts, ctx) Ctx__dtor(ctx);
c11_vector__dtor(&self->contexts); c11_vector__dtor(&self->contexts);
} }
/**************************************/ /**************************************/
#define tk(i) c11__at(Token, &self->tokens, i) #define tk(i) (&self->tokens[i])
#define prev() tk(self->i - 1) #define prev() (&self->tokens[self->i - 1])
#define curr() tk(self->i) #define curr() (&self->tokens[self->i])
#define next() tk(self->i + 1) #define next() (&self->tokens[self->i + 1])
#define advance() self->i++ #define advance() self->i++
#define mode() self->src->mode #define mode() self->src->mode
@ -1347,7 +1364,7 @@ Error* SyntaxError(Compiler* self, const char* fmt, ...) {
Error* err = malloc(sizeof(Error)); Error* err = malloc(sizeof(Error));
err->src = self->src; err->src = self->src;
PK_INCREF(self->src); PK_INCREF(self->src);
Token* t = self->i == self->tokens.length ? prev() : curr(); Token* t = self->i == self->tokens_length ? prev() : curr();
err->lineno = t->line; err->lineno = t->line;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
@ -1424,8 +1441,7 @@ static Error* EXPR_TUPLE_ALLOW_SLICE(Compiler* self, bool allow_slice) {
// pop `count` expressions from the stack and merge them into a TupleExpr // pop `count` expressions from the stack and merge them into a TupleExpr
SequenceExpr* e = TupleExpr__new(prev()->line, count); SequenceExpr* e = TupleExpr__new(prev()->line, count);
for(int i = count - 1; i >= 0; i--) { for(int i = count - 1; i >= 0; i--) {
Expr* item = Ctx__s_popx(ctx()); e->items[i] = Ctx__s_popx(ctx());
c11__setitem(Expr*, &e->items, i, item);
} }
Ctx__s_push(ctx(), (Expr*)e); Ctx__s_push(ctx(), (Expr*)e);
return NULL; return NULL;
@ -1450,8 +1466,7 @@ static Error* EXPR_VARS(Compiler* self) {
if(count > 1) { if(count > 1) {
SequenceExpr* e = TupleExpr__new(prev()->line, count); SequenceExpr* e = TupleExpr__new(prev()->line, count);
for(int i = count - 1; i >= 0; i--) { for(int i = count - 1; i >= 0; i--) {
Expr* item = Ctx__s_popx(ctx()); e->items[i] = Ctx__s_popx(ctx());
c11__setitem(Expr*, &e->items, i, item);
} }
Ctx__s_push(ctx(), (Expr*)e); Ctx__s_push(ctx(), (Expr*)e);
} }
@ -1556,8 +1571,7 @@ static Error* exprFString(Compiler* self) {
if(match(TK_FSTR_END)) { if(match(TK_FSTR_END)) {
SequenceExpr* e = FStringExpr__new(line, count); SequenceExpr* e = FStringExpr__new(line, count);
for(int i = count - 1; i >= 0; i--) { for(int i = count - 1; i >= 0; i--) {
Expr* item = Ctx__s_popx(ctx()); e->items[i] = Ctx__s_popx(ctx());
c11__setitem(Expr*, &e->items, i, item);
} }
Ctx__s_push(ctx(), (Expr*)e); Ctx__s_push(ctx(), (Expr*)e);
return NULL; return NULL;
@ -1790,7 +1804,7 @@ static Error* exprList(Compiler* self) {
consume(TK_RBRACKET); consume(TK_RBRACKET);
SequenceExpr* e = ListExpr__new(line, count); SequenceExpr* e = ListExpr__new(line, count);
for(int i = count - 1; i >= 0; i--) { for(int i = count - 1; i >= 0; i--) {
c11__setitem(Expr*, &e->items, i, Ctx__s_popx(ctx())); e->items[i] = Ctx__s_popx(ctx());
} }
Ctx__s_push(ctx(), (Expr*)e); Ctx__s_push(ctx(), (Expr*)e);
return NULL; return NULL;
@ -1836,7 +1850,7 @@ static Error* exprMap(Compiler* self) {
se = SetExpr__new(line, count); se = SetExpr__new(line, count);
} }
for(int i = count - 1; i >= 0; i--) { for(int i = count - 1; i >= 0; i--) {
c11__setitem(Expr*, &se->items, i, Ctx__s_popx(ctx())); se->items[i] = Ctx__s_popx(ctx());
} }
Ctx__s_push(ctx(), (Expr*)se); Ctx__s_push(ctx(), (Expr*)se);
return NULL; return NULL;
@ -2766,8 +2780,9 @@ Error* Compiler__compile(Compiler* self, CodeObject* out) {
} }
Error* pk_compile(SourceData_ src, CodeObject* out) { Error* pk_compile(SourceData_ src, CodeObject* out) {
TokenArray tokens; Token* tokens;
Error* err = Lexer__process(src, &tokens); int tokens_length;
Error* err = Lexer__process(src, &tokens, &tokens_length);
if(err) return err; if(err) return err;
#if 0 #if 0
@ -2791,7 +2806,7 @@ Error* pk_compile(SourceData_ src, CodeObject* out) {
#endif #endif
Compiler compiler; Compiler compiler;
Compiler__ctor(&compiler, src, tokens); Compiler__ctor(&compiler, src, tokens, tokens_length);
CodeObject__ctor(out, src, c11_string__sv(src->filename)); CodeObject__ctor(out, src, c11_string__sv(src->filename));
err = Compiler__compile(&compiler, out); err = Compiler__compile(&compiler, out);
if(err) { if(err) {

100
src/compiler/lexer.c
View File

@ -18,19 +18,6 @@ typedef struct Lexer {
c11_vector /*T=int*/ indents; c11_vector /*T=int*/ indents;
} Lexer; } Lexer;
typedef struct TokenDeserializer {
const char* curr;
const char* source;
} TokenDeserializer;
void TokenDeserializer__ctor(TokenDeserializer* self, const char* source);
bool TokenDeserializer__match_char(TokenDeserializer* self, char c);
c11_sv TokenDeserializer__read_string(TokenDeserializer* self, char c);
c11_string* TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c);
int TokenDeserializer__read_count(TokenDeserializer* self);
int64_t TokenDeserializer__read_uint(TokenDeserializer* self, char c);
double TokenDeserializer__read_float(TokenDeserializer* self, char c);
const static TokenValue EmptyTokenValue; const static TokenValue EmptyTokenValue;
static Error* lex_one_token(Lexer* self, bool* eof, bool is_fstring); static Error* lex_one_token(Lexer* self, bool* eof, bool is_fstring);
@ -186,7 +173,7 @@ static bool eat_indentation(Lexer* self) {
static bool is_possible_number_char(char c) { static bool is_possible_number_char(char c) {
switch(c) { switch(c) {
// clang-format off // clang-format off
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
@ -593,7 +580,7 @@ static Error* lex_one_token(Lexer* self, bool* eof, bool is_fstring) {
return NULL; return NULL;
} }
Error* Lexer__process(SourceData_ src, TokenArray* out_tokens) { Error* Lexer__process(SourceData_ src, Token** out_tokens, int* out_length) {
Lexer lexer; Lexer lexer;
Lexer__ctor(&lexer, src); Lexer__ctor(&lexer, src);
@ -612,20 +599,12 @@ Error* Lexer__process(SourceData_ src, TokenArray* out_tokens) {
} }
} }
// set out_tokens // set out_tokens
*out_tokens = c11_vector__submit(&lexer.nexts); *out_tokens = c11_vector__submit(&lexer.nexts, out_length);
Lexer__dtor(&lexer); Lexer__dtor(&lexer);
return NULL; return NULL;
} }
void TokenArray__dtor(TokenArray* self) {
Token* data = self->data;
for(int i = 0; i < self->length; i++) {
if(data[i].value.index == TokenValue_STR) { c11_string__delete(data[i].value._str); }
}
c11_array__dtor(self);
}
const char* TokenSymbols[] = { const char* TokenSymbols[] = {
"@eof", "@eof",
"@eol", "@eol",
@ -729,76 +708,3 @@ const char* TokenSymbols[] = {
"yield", "yield",
}; };
void TokenDeserializer__ctor(TokenDeserializer* self, const char* source) {
self->curr = source;
self->source = source;
}
bool TokenDeserializer__match_char(TokenDeserializer* self, char c) {
if(*self->curr == c) {
self->curr++;
return true;
}
return false;
}
c11_sv TokenDeserializer__read_string(TokenDeserializer* self, char c) {
const char* start = self->curr;
while(*self->curr != c)
self->curr++;
c11_sv retval = {start, (int)(self->curr - start)};
self->curr++; // skip the delimiter
return retval;
}
c11_string* TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c) {
c11_sv sv = TokenDeserializer__read_string(self, c);
const char* s = sv.data;
c11_sbuf ss;
c11_sbuf__ctor(&ss);
for(int i = 0; i < sv.size; i += 2) {
char c = 0;
if(s[i] >= '0' && s[i] <= '9')
c += s[i] - '0';
else if(s[i] >= 'a' && s[i] <= 'f')
c += s[i] - 'a' + 10;
else
assert(false);
c <<= 4;
if(s[i + 1] >= '0' && s[i + 1] <= '9')
c += s[i + 1] - '0';
else if(s[i + 1] >= 'a' && s[i + 1] <= 'f')
c += s[i + 1] - 'a' + 10;
else
assert(false);
c11_sbuf__write_char(&ss, c);
}
return c11_sbuf__submit(&ss);
}
int TokenDeserializer__read_count(TokenDeserializer* self) {
assert(*self->curr == '=');
self->curr++;
return TokenDeserializer__read_uint(self, '\n');
}
int64_t TokenDeserializer__read_uint(TokenDeserializer* self, char c) {
int64_t out = 0;
while(*self->curr != c) {
out = out * 10 + (*self->curr - '0');
self->curr++;
}
self->curr++; // skip the delimiter
return out;
}
double TokenDeserializer__read_float(TokenDeserializer* self, char c) {
c11_sv sv = TokenDeserializer__read_string(self, c);
// TODO: optimize this
c11_string* nullterm = c11_string__new2(sv.data, sv.size);
char* end;
double retval = strtod(nullterm->data, &end);
c11_string__delete(nullterm);
assert(*end == 0);
return retval;
}