Embedded/pikapython
1
0
Fork 0
mirror of https://gitee.com/Lyon1998/pikapython.git synced 2025-02-05 17:28:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

update branket_deepth in parser

Browse Source
This commit is contained in:
lyon1998 2022-04-03 12:23:15 +08:00
parent 03ced778f9
commit 631906dee1
2 changed files with 45 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
src/PikaParser.c
View File

@ -39,7 +39,9 @@ char* AST_toPikaASM(AST* ast, Args* outBuffs);
char* Lexer_getTokens(Args* outBuffs, char* stmt); char* Lexer_getTokens(Args* outBuffs, char* stmt);
int32_t AST_deinit(AST* ast); int32_t AST_deinit(AST* ast);
char* Parser_multiLineToAsm(Args* outBuffs, char* multiLine); char* Parser_multiLineToAsm(Args* outBuffs, char* multiLine);
uint8_t Lexer_isContain(char* tokens, enum TokenType token_type, char* pyload); uint8_t Parser_isContainToken(char* tokens,
enum TokenType token_type,
char* pyload);
void ParserState_init(struct ParserState* ps); void ParserState_init(struct ParserState* ps);
void ParserState_parse(struct ParserState* ps, char* stmt); void ParserState_parse(struct ParserState* ps, char* stmt);
void ParserState_deinit(struct ParserState* ps); void ParserState_deinit(struct ParserState* ps);
@ -47,7 +49,7 @@ void ParserState_beforeIter(struct ParserState* ps);
void ParserState_iterStart(struct ParserState* ps); void ParserState_iterStart(struct ParserState* ps);
void ParserState_iterEnd(struct ParserState* ps); void ParserState_iterEnd(struct ParserState* ps);
uint16_t Lexer_getTokenSize(char* tokens) { uint16_t Parser_getTokenSize(char* tokens) {
if (strEqu("", tokens)) { if (strEqu("", tokens)) {
return 0; return 0;
} }
@ -59,24 +61,15 @@ char* strsPopTokenWithSkip_byStr(Args* outBuffs,
char* str, char* str,
char skipStart, char skipStart,
char skipEnd) { char skipEnd) {
uint8_t token_index_get = 0; uint8_t divider_index = 0;
uint8_t branket_deepth = 0;
Arg* keeped_arg = arg_setStr(NULL, "", ""); Arg* keeped_arg = arg_setStr(NULL, "", "");
Arg* poped_arg = arg_setStr(NULL, "", ""); Arg* poped_arg = arg_setStr(NULL, "", "");
{ {
uint8_t token_index = 0;
ParserState_forEachToken(ps, stmts) { ParserState_forEachToken(ps, stmts) {
ParserState_iterStart(&ps); ParserState_iterStart(&ps);
token_index++; if (ps.branket_deepth == 0) {
if (strEqu(ps.token1.pyload, "(")) {
branket_deepth++;
}
if (strEqu(ps.token1.pyload, ")")) {
branket_deepth--;
}
if (branket_deepth == 0) {
if (strEqu(str, ps.token1.pyload)) { if (strEqu(str, ps.token1.pyload)) {
token_index_get = token_index; divider_index = ps.iter_index;
} }
} }
ParserState_iterEnd(&ps); ParserState_iterEnd(&ps);
@ -84,14 +77,12 @@ char* strsPopTokenWithSkip_byStr(Args* outBuffs,
ParserState_deinit(&ps); ParserState_deinit(&ps);
} }
{ {
uint8_t token_index = 0;
ParserState_forEachToken(ps, stmts) { ParserState_forEachToken(ps, stmts) {
ParserState_iterStart(&ps); ParserState_iterStart(&ps);
token_index++; if (ps.iter_index < divider_index) {
if (token_index < token_index_get) {
poped_arg = arg_strAppend(poped_arg, ps.token1.pyload); poped_arg = arg_strAppend(poped_arg, ps.token1.pyload);
} }
if (token_index > token_index_get) { if (ps.iter_index > divider_index) {
keeped_arg = arg_strAppend(keeped_arg, ps.token1.pyload); keeped_arg = arg_strAppend(keeped_arg, ps.token1.pyload);
} }
ParserState_iterEnd(&ps); ParserState_iterEnd(&ps);
@ -110,7 +101,7 @@ char* strsGetCleanCmd(Args* outBuffs, char* cmd) {
int32_t size = strGetSize(cmd); int32_t size = strGetSize(cmd);
Args buffs = {0}; Args buffs = {0};
char* tokens = Lexer_getTokens(&buffs, cmd); char* tokens = Lexer_getTokens(&buffs, cmd);
uint16_t token_size = Lexer_getTokenSize(tokens); uint16_t token_size = Parser_getTokenSize(tokens);
char* strOut = args_getBuff(outBuffs, size); char* strOut = args_getBuff(outBuffs, size);
int32_t iOut = 0; int32_t iOut = 0;
for (uint16_t i = 0; i < token_size; i++) { for (uint16_t i = 0; i < token_size; i++) {
@ -261,7 +252,7 @@ uint8_t Parser_checkIsDirect(char* str) {
Args buffs = {0}; Args buffs = {0};
char* tokens = Lexer_getTokens(&buffs, str); char* tokens = Lexer_getTokens(&buffs, str);
uint8_t res = 0; uint8_t res = 0;
if (Lexer_isContain(tokens, TOKEN_operator, "=")) { if (Parser_isContainToken(tokens, TOKEN_operator, "=")) {
res = 1; res = 1;
goto exit; goto exit;
} }
@ -531,27 +522,29 @@ exit:
return tokens; return tokens;
} }
char* Lexer_popToken(Args* buffs_p, char* tokens) { char* Parser_popToken(Args* buffs_p, char* tokens) {
return strsPopToken(buffs_p, tokens, 0x1F); return strsPopToken(buffs_p, tokens, 0x1F);
} }
enum TokenType Lexer_getTokenType(char* token) { enum TokenType Token_getType(char* token) {
return (enum TokenType)token[0]; return (enum TokenType)token[0];
} }
char* Lexer_getTokenPyload(char* token) { char* Token_getPyload(char* token) {
return (char*)((uintptr_t)token + 1); return (char*)((uintptr_t)token + 1);
} }
uint8_t Lexer_isContain(char* tokens, enum TokenType token_type, char* pyload) { uint8_t Parser_isContainToken(char* tokens,
enum TokenType token_type,
char* pyload) {
Args buffs = {0}; Args buffs = {0};
char* tokens_buff = strsCopy(&buffs, tokens); char* tokens_buff = strsCopy(&buffs, tokens);
uint8_t res = 0; uint8_t res = 0;
uint16_t token_size = Lexer_getTokenSize(tokens); uint16_t token_size = Parser_getTokenSize(tokens);
for (int i = 0; i < token_size; i++) { for (int i = 0; i < token_size; i++) {
char* token = Lexer_popToken(&buffs, tokens_buff); char* token = Parser_popToken(&buffs, tokens_buff);
if (token_type == Lexer_getTokenType(token)) { if (token_type == Token_getType(token)) {
if (strEqu(Lexer_getTokenPyload(token), pyload)) { if (strEqu(Token_getPyload(token), pyload)) {
res = 1; res = 1;
goto exit; goto exit;
} }
@ -571,7 +564,8 @@ char* Lexer_getOperator(Args* outBuffs, char* stmt) {
"&", "^", "|", "<", "<=", ">", ">=", "!=", "==", "%=", "&", "^", "|", "<", "<=", ">", ">=", "!=", "==", "%=",
"/=", "//=", "-=", "+=", "*=", "**=", " not ", " and ", " or "}; "/=", "//=", "-=", "+=", "*=", "**=", " not ", " and ", " or "};
for (uint32_t i = 0; i < sizeof(operators) / 6; i++) { for (uint32_t i = 0; i < sizeof(operators) / 6; i++) {
if (Lexer_isContain(tokens, TOKEN_operator, (char*)operators[i])) { if (Parser_isContainToken(tokens, TOKEN_operator,
(char*)operators[i])) {
operator= strsCopy(&buffs, (char*)operators[i]); operator= strsCopy(&buffs, (char*)operators[i]);
} }
} }
@ -598,26 +592,33 @@ char* Lexer_getOperator(Args* outBuffs, char* stmt) {
const char void_str[] = ""; const char void_str[] = "";
void LexToken_update(struct LexToken* lex_token) { void LexToken_update(struct LexToken* lex_token) {
lex_token->type = Lexer_getTokenType(lex_token->token); lex_token->type = Token_getType(lex_token->token);
if (lex_token->type == TOKEN_strEnd) { if (lex_token->type == TOKEN_strEnd) {
lex_token->pyload = (char*)void_str; lex_token->pyload = (char*)void_str;
} else { } else {
lex_token->pyload = Lexer_getTokenPyload(lex_token->token); lex_token->pyload = Token_getPyload(lex_token->token);
} }
} }
void ParserState_iterStart(struct ParserState* ps) { void ParserState_iterStart(struct ParserState* ps) {
ps->iter_index++;
ps->iter_buffs = New_strBuff(); ps->iter_buffs = New_strBuff();
/* token1 is the last token */ /* token1 is the last token */
ps->token1.token = strsCopy(ps->iter_buffs, arg_getStr(ps->last_token)); ps->token1.token = strsCopy(ps->iter_buffs, arg_getStr(ps->last_token));
/* token2 is the next token */ /* token2 is the next token */
ps->token2.token = Lexer_popToken(ps->iter_buffs, ps->tokens); ps->token2.token = Parser_popToken(ps->iter_buffs, ps->tokens);
/* store last token */ /* store last token */
arg_deinit(ps->last_token); arg_deinit(ps->last_token);
ps->last_token = arg_setStr(NULL, "", ps->token2.token); ps->last_token = arg_setStr(NULL, "", ps->token2.token);
LexToken_update(&ps->token1); LexToken_update(&ps->token1);
LexToken_update(&ps->token2); LexToken_update(&ps->token2);
if (strEqu(ps->token1.pyload, "(")) {
ps->branket_deepth++;
}
if (strEqu(ps->token1.pyload, ")")) {
ps->branket_deepth--;
}
} }
void LexToken_init(struct LexToken* lt) { void LexToken_init(struct LexToken* lt) {
@ -629,6 +630,8 @@ void LexToken_init(struct LexToken* lt) {
void ParserState_init(struct ParserState* ps) { void ParserState_init(struct ParserState* ps) {
ps->tokens = NULL; ps->tokens = NULL;
ps->length = 0; ps->length = 0;
ps->iter_index = 0;
ps->branket_deepth = 0;
ps->last_token = NULL; ps->last_token = NULL;
ps->iter_buffs = NULL; ps->iter_buffs = NULL;
ps->buffs_p = New_strBuff(); ps->buffs_p = New_strBuff();
@ -649,14 +652,14 @@ void ParserState_deinit(struct ParserState* ps) {
void ParserState_parse(struct ParserState* ps, char* stmt) { void ParserState_parse(struct ParserState* ps, char* stmt) {
ps->tokens = Lexer_getTokens(ps->buffs_p, stmt); ps->tokens = Lexer_getTokens(ps->buffs_p, stmt);
ps->length = Lexer_getTokenSize(ps->tokens); ps->length = Parser_getTokenSize(ps->tokens);
} }
void ParserState_beforeIter(struct ParserState* ps) { void ParserState_beforeIter(struct ParserState* ps) {
/* clear first token */ /* clear first token */
Lexer_popToken(ps->buffs_p, ps->tokens); Parser_popToken(ps->buffs_p, ps->tokens);
ps->last_token = ps->last_token =
arg_setStr(NULL, "", Lexer_popToken(ps->buffs_p, ps->tokens)); arg_setStr(NULL, "", Parser_popToken(ps->buffs_p, ps->tokens));
} }
char* Parser_solveBranckets(Args* outBuffs, char* Parser_solveBranckets(Args* outBuffs,
@ -676,7 +679,7 @@ char* Parser_solveBranckets(Args* outBuffs,
} }
char* tokens = Lexer_getTokens(&buffs, content); char* tokens = Lexer_getTokens(&buffs, content);
/* exit when no '[' ']' */ /* exit when no '[' ']' */
if (!Lexer_isContain(tokens, TOKEN_devider, "[")) { if (!Parser_isContainToken(tokens, TOKEN_devider, "[")) {
/* not contain '[', return origin */ /* not contain '[', return origin */
arg_deinit(right_arg); arg_deinit(right_arg);
if (strEqu(mode, "right")) { if (strEqu(mode, "right")) {
@ -773,16 +776,16 @@ uint8_t Parser_solveSelfOperator(Args* outbuffs,
char* operator=(char*) _operator; char* operator=(char*) _operator;
char* tokens = Lexer_getTokens(&buffs, stmt); char* tokens = Lexer_getTokens(&buffs, stmt);
uint8_t is_right = 0; uint8_t is_right = 0;
if (Lexer_isContain(tokens, TOKEN_operator, "+=")) { if (Parser_isContainToken(tokens, TOKEN_operator, "+=")) {
operator[0] = '+'; operator[0] = '+';
} }
if (Lexer_isContain(tokens, TOKEN_operator, "-=")) { if (Parser_isContainToken(tokens, TOKEN_operator, "-=")) {
operator[0] = '-'; operator[0] = '-';
} }
if (Lexer_isContain(tokens, TOKEN_operator, "*=")) { if (Parser_isContainToken(tokens, TOKEN_operator, "*=")) {
operator[0] = '*'; operator[0] = '*';
} }
if (Lexer_isContain(tokens, TOKEN_operator, "/=")) { if (Parser_isContainToken(tokens, TOKEN_operator, "/=")) {
operator[0] = '/'; operator[0] = '/';
} }
/* not found self operator */ /* not found self operator */

2
src/PikaParser.h
View File

@ -65,6 +65,8 @@ struct LexToken {
struct ParserState { struct ParserState {
char* tokens; char* tokens;
uint16_t length; uint16_t length;
uint16_t iter_index;
uint8_t branket_deepth;
struct LexToken token1; struct LexToken token1;
struct LexToken token2; struct LexToken token2;
Arg* last_token; Arg* last_token;