From dbd75615d940f00cf99b789f9ca4ba77b517fb1c Mon Sep 17 00:00:00 2001 From: blueloveTH Date: Thu, 20 Jun 2024 00:27:07 +0800 Subject: [PATCH] some rename --- include/pocketpy/compiler/lexer.h | 22 ++++++++++----------- src/compiler/lexer.c | 20 +++++++++---------- src/compiler/lexer.cpp | 32 +++++++++++++++---------------- 3 files changed, 37 insertions(+), 37 deletions(-) diff --git a/include/pocketpy/compiler/lexer.h b/include/pocketpy/compiler/lexer.h index c3b49306..4b2416b5 100644 --- a/include/pocketpy/compiler/lexer.h +++ b/include/pocketpy/compiler/lexer.h @@ -9,12 +9,12 @@ extern "C" { extern const char* pk_TokenSymbols[]; -typedef struct pkpy_TokenDeserializer { +typedef struct pk_TokenDeserializer { const char* curr; const char* source; -} pkpy_TokenDeserializer; +} pk_TokenDeserializer; -enum TokenIndex{ +typedef enum TokenIndex{ TK_EOF, TK_EOL, TK_SOF, TK_ID, TK_NUM, TK_STR, TK_FSTR, TK_LONG, TK_BYTES, TK_IMAG, TK_INDENT, TK_DEDENT, @@ -37,15 +37,15 @@ enum TokenIndex{ TK_TRY, TK_WHILE, TK_WITH, TK_YIELD, /***************/ TK__COUNT__ -}; +} TokenIndex; -void pkpy_TokenDeserializer__ctor(pkpy_TokenDeserializer* self, const char* source); -bool pkpy_TokenDeserializer__match_char(pkpy_TokenDeserializer* self, char c); -c11_string pkpy_TokenDeserializer__read_string(pkpy_TokenDeserializer* self, char c); -pkpy_Str pkpy_TokenDeserializer__read_string_from_hex(pkpy_TokenDeserializer* self, char c); -int pkpy_TokenDeserializer__read_count(pkpy_TokenDeserializer* self); -int64_t pkpy_TokenDeserializer__read_uint(pkpy_TokenDeserializer* self, char c); -double pkpy_TokenDeserializer__read_float(pkpy_TokenDeserializer* self, char c); +void pk_TokenDeserializer__ctor(pk_TokenDeserializer* self, const char* source); +bool pk_TokenDeserializer__match_char(pk_TokenDeserializer* self, char c); +c11_string pk_TokenDeserializer__read_string(pk_TokenDeserializer* self, char c); +pkpy_Str pk_TokenDeserializer__read_string_from_hex(pk_TokenDeserializer* self, char c); +int pk_TokenDeserializer__read_count(pk_TokenDeserializer* self); +int64_t pk_TokenDeserializer__read_uint(pk_TokenDeserializer* self, char c); +double pk_TokenDeserializer__read_float(pk_TokenDeserializer* self, char c); #ifdef __cplusplus } diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c index 6db8486e..8a90e1f4 100644 --- a/src/compiler/lexer.c +++ b/src/compiler/lexer.c @@ -27,12 +27,12 @@ const char* pk_TokenSymbols[] = { "try", "while", "with", "yield", }; -void pkpy_TokenDeserializer__ctor(pkpy_TokenDeserializer* self, const char* source){ +void pk_TokenDeserializer__ctor(pk_TokenDeserializer* self, const char* source){ self->curr = source; self->source = source; } -bool pkpy_TokenDeserializer__match_char(pkpy_TokenDeserializer* self, char c){ +bool pk_TokenDeserializer__match_char(pk_TokenDeserializer* self, char c){ if(*self->curr == c) { self->curr++; return true; @@ -40,7 +40,7 @@ bool pkpy_TokenDeserializer__match_char(pkpy_TokenDeserializer* self, char c){ return false; } -c11_string pkpy_TokenDeserializer__read_string(pkpy_TokenDeserializer* self, char c){ +c11_string pk_TokenDeserializer__read_string(pk_TokenDeserializer* self, char c){ const char* start = self->curr; while(*self->curr != c) self->curr++; @@ -49,8 +49,8 @@ c11_string pkpy_TokenDeserializer__read_string(pkpy_TokenDeserializer* self, cha return retval; } -pkpy_Str pkpy_TokenDeserializer__read_string_from_hex(pkpy_TokenDeserializer* self, char c){ - c11_string sv = pkpy_TokenDeserializer__read_string(self, c); +pkpy_Str pk_TokenDeserializer__read_string_from_hex(pk_TokenDeserializer* self, char c){ + c11_string sv = pk_TokenDeserializer__read_string(self, c); const char* s = sv.data; char* buffer = (char*)malloc(sv.size / 2 + 1); for(int i = 0; i < sv.size; i += 2) { @@ -79,13 +79,13 @@ pkpy_Str pkpy_TokenDeserializer__read_string_from_hex(pkpy_TokenDeserializer* se }; } -int pkpy_TokenDeserializer__read_count(pkpy_TokenDeserializer* self){ +int pk_TokenDeserializer__read_count(pk_TokenDeserializer* self){ assert(*self->curr == '='); self->curr++; - return pkpy_TokenDeserializer__read_uint(self, '\n'); + return pk_TokenDeserializer__read_uint(self, '\n'); } -int64_t pkpy_TokenDeserializer__read_uint(pkpy_TokenDeserializer* self, char c){ +int64_t pk_TokenDeserializer__read_uint(pk_TokenDeserializer* self, char c){ int64_t out = 0; while(*self->curr != c) { out = out * 10 + (*self->curr - '0'); @@ -95,8 +95,8 @@ int64_t pkpy_TokenDeserializer__read_uint(pkpy_TokenDeserializer* self, char c){ return out; } -double pkpy_TokenDeserializer__read_float(pkpy_TokenDeserializer* self, char c){ - c11_string sv = pkpy_TokenDeserializer__read_string(self, c); +double pk_TokenDeserializer__read_float(pk_TokenDeserializer* self, char c){ + c11_string sv = pk_TokenDeserializer__read_string(self, c); pkpy_Str nullterm; pkpy_Str__ctor2(&nullterm, sv.data, sv.size); char* end; diff --git a/src/compiler/lexer.cpp b/src/compiler/lexer.cpp index 79a93ba5..754d5cad 100644 --- a/src/compiler/lexer.cpp +++ b/src/compiler/lexer.cpp @@ -533,34 +533,34 @@ Error* Lexer::run() noexcept{ } Error* Lexer::from_precompiled() noexcept{ - pkpy_TokenDeserializer deserializer; - pkpy_TokenDeserializer__ctor(&deserializer, pkpy_Str__data(&src->source)); + pk_TokenDeserializer deserializer; + pk_TokenDeserializer__ctor(&deserializer, pkpy_Str__data(&src->source)); deserializer.curr += 5; // skip "pkpy:" - c11_string version = pkpy_TokenDeserializer__read_string(&deserializer, '\n'); + c11_string version = pk_TokenDeserializer__read_string(&deserializer, '\n'); if(c11_string__cmp3(version, PK_VERSION) != 0) { return SyntaxError("precompiled version mismatch"); } - if(pkpy_TokenDeserializer__read_uint(&deserializer, '\n') != (i64)src->mode){ + if(pk_TokenDeserializer__read_uint(&deserializer, '\n') != (i64)src->mode){ return SyntaxError("precompiled mode mismatch"); } - int count = pkpy_TokenDeserializer__read_count(&deserializer); + int count = pk_TokenDeserializer__read_count(&deserializer); c11_vector* precompiled_tokens = &src->_precompiled_tokens; for(int i = 0; i < count; i++) { - c11_string item = pkpy_TokenDeserializer__read_string(&deserializer, '\n'); + c11_string item = pk_TokenDeserializer__read_string(&deserializer, '\n'); pkpy_Str copied_item; pkpy_Str__ctor2(&copied_item, item.data, item.size); c11_vector__push(pkpy_Str, precompiled_tokens, copied_item); } - count = pkpy_TokenDeserializer__read_count(&deserializer); + count = pk_TokenDeserializer__read_count(&deserializer); for(int i = 0; i < count; i++) { Token t; - t.type = (TokenIndex)pkpy_TokenDeserializer__read_uint(&deserializer, ','); + t.type = (TokenIndex)pk_TokenDeserializer__read_uint(&deserializer, ','); if(is_raw_string_used(t.type)) { - i64 index = pkpy_TokenDeserializer__read_uint(&deserializer, ','); + i64 index = pk_TokenDeserializer__read_uint(&deserializer, ','); pkpy_Str* p = c11__at(pkpy_Str, precompiled_tokens, index); t.start = pkpy_Str__data(p); t.length = c11__getitem(pkpy_Str, precompiled_tokens, index).size; @@ -569,28 +569,28 @@ Error* Lexer::from_precompiled() noexcept{ t.length = 0; } - if(pkpy_TokenDeserializer__match_char(&deserializer, ',')) { + if(pk_TokenDeserializer__match_char(&deserializer, ',')) { t.line = nexts.back().line; } else { - t.line = (int)pkpy_TokenDeserializer__read_uint(&deserializer, ','); + t.line = (int)pk_TokenDeserializer__read_uint(&deserializer, ','); } - if(pkpy_TokenDeserializer__match_char(&deserializer, ',')) { + if(pk_TokenDeserializer__match_char(&deserializer, ',')) { t.brackets_level = nexts.back().brackets_level; } else { - t.brackets_level = (int)pkpy_TokenDeserializer__read_uint(&deserializer, ','); + t.brackets_level = (int)pk_TokenDeserializer__read_uint(&deserializer, ','); } char type = (*deserializer.curr++); // read_char switch(type) { case 'I': - t.value = pkpy_TokenDeserializer__read_uint(&deserializer, '\n'); + t.value = pk_TokenDeserializer__read_uint(&deserializer, '\n'); break; case 'F': - t.value = pkpy_TokenDeserializer__read_float(&deserializer, '\n'); + t.value = pk_TokenDeserializer__read_float(&deserializer, '\n'); break; case 'S': { - pkpy_Str res = pkpy_TokenDeserializer__read_string_from_hex(&deserializer, '\n'); + pkpy_Str res = pk_TokenDeserializer__read_string_from_hex(&deserializer, '\n'); t.value = Str(std::move(res)); } break; default: