Skip to content

Commit 0b7e19e

Browse files
pikasTechpikasTech
committed
parser_lines2AST passed
format for parser_lines2BackendCode
1 parent 62d1d40 commit 0b7e19e

3 files changed

Lines changed: 88 additions & 70 deletions

File tree

‎port/linux/package/googletest/googletest/test/googletest-param-test-invalid-name2-test.py‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
}
99

1010
TEST(parser, NEW) {
11-
AST* ast = parser_line2Ast((char*)"add(a,b)", NULL);
11+
AST* ast = parser_line2AST((char*)"add(a,b)", NULL);
1212
Args* buffs = New_strBuff();
1313
char* pikaAsm = AST_toPikaAsm(ast, buffs);
1414
printf("%s", pikaAsm);
@@ -18,7 +18,7 @@
1818
}
1919

2020
TEST(parser, add_a_b) {
21-
AST* ast = parser_line2Ast((char*)"add( a , b)", NULL);
21+
AST* ast = parser_line2AST((char*)"add( a , b)", NULL);
2222
Args* buffs = New_strBuff();
2323
char* pikaAsm = AST_toPikaAsm(ast, buffs);
2424
printf("%s", pikaAsm);
@@ -33,7 +33,7 @@
3333
}
3434

3535
TEST(parser, add_a_b_c) {
36-
AST* ast = parser_line2Ast((char*)"d = add(add(a,b) , c)", NULL);
36+
AST* ast = parser_line2AST((char*)"d = add(add(a,b) , c)", NULL);
3737
Args* buffs = New_strBuff();
3838
char* pikaAsm = AST_toPikaAsm(ast, buffs);
3939
printf("%s", pikaAsm);
@@ -52,7 +52,7 @@
5252

5353
TEST(parser, method1) {
5454
AST* ast =
55-
parser_line2Ast((char*)"d.p = a.add(b.add(a,se.b) , pmw.c)", NULL);
55+
parser_line2AST((char*)"d.p = a.add(b.add(a,se.b) , pmw.c)", NULL);
5656
Args* buffs = New_strBuff();
5757
char* pikaAsm = AST_toPikaAsm(ast, buffs);
5858
printf("%s", pikaAsm);

‎src/PikaParser.c‎

Lines changed: 70 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -1923,12 +1923,8 @@ const char control_keywords[][9] = {"break", "continue"};
19231923
/* normal keyward */
19241924
const char normal_keywords[][7] = {"while", "if", "elif"};
19251925

1926-
AST* _line2Ast(char* line, BlockState* blockState) {
1927-
Stack s;
1928-
stack_init(&s);
1929-
if (blockState->stack == NULL) {
1930-
blockState->stack = &s;
1931-
}
1926+
AST* parser_line2AST(Parser* self, char* line) {
1927+
BlockState* blockState = &self->blockState;
19321928
/* line is not exist */
19331929
if (line == NULL) {
19341930
return NULL;
@@ -2173,29 +2169,24 @@ AST* _line2Ast(char* line, BlockState* blockState) {
21732169
ast = AST_parseStmt(ast, stmt);
21742170
goto exit;
21752171
exit:
2176-
stack_deinit(&s);
21772172
strsDeinit(&buffs);
21782173
return ast;
21792174
}
21802175

21812176
static AST* line2Ast_withBlockDeepth(char* line, int block_deepth) {
2182-
BlockState block = {
2183-
.deepth = block_deepth,
2184-
.stack = NULL,
2185-
};
2186-
return _line2Ast(line, &block);
2177+
Parser* parser = New_parser();
2178+
parser->blockState.deepth = block_deepth;
2179+
AST* ast = parser_line2AST(parser, line);
2180+
parser_deinit(parser);
2181+
return ast;
21872182
}
21882183

21892184
int AST_getBlockDeepthNow(AST* ast) {
21902185
return obj_getInt(ast, "blockDeepth");
21912186
}
21922187

21932188
AST* line2Ast(char* line) {
2194-
BlockState block = {
2195-
.deepth = 0,
2196-
.stack = NULL,
2197-
};
2198-
return _line2Ast(line, &block);
2189+
return line2Ast_withBlockDeepth(line, 0);
21992190
}
22002191

22012192
static char* Suger_import_as(Args* out_buffs, char* line) {
@@ -2453,18 +2444,18 @@ static char* Parser_linePreProcess(Args* outbuffs, char* line) {
24532444
return line;
24542445
}
24552446

2456-
char* parser_line2Asm(Parser* self, char* line) {
2457-
char* ASM = NULL;
2447+
char* parser_line2BackendCode(Parser* self, char* line) {
2448+
char* sOut = NULL;
24582449
AST* ast = NULL;
24592450
uint8_t line_num = 0;
24602451
/* pre process */
2461-
line = Parser_linePreProcess(&self->buffs, line);
2452+
line = Parser_linePreProcess(&self->lineBuffs, line);
24622453
if (NULL == line) {
24632454
/* preprocess error */
24642455
goto exit;
24652456
}
24662457
if (strEqu("@annontation", line)) {
2467-
ASM = "";
2458+
sOut = "";
24682459
goto exit;
24692460
}
24702461
/*
@@ -2473,21 +2464,22 @@ char* parser_line2Asm(Parser* self, char* line) {
24732464
*/
24742465
line_num = strCountSign(line, '\n') + 1;
24752466
for (int i = 0; i < line_num; i++) {
2476-
char* single_line = strsPopToken(&self->buffs, &line, '\n');
2467+
char* single_line = strsPopToken(&self->lineBuffs, &line, '\n');
24772468
/* parse line to AST */
2478-
ast = _line2Ast(single_line, &self->blockState);
2469+
ast = parser_line2AST(self, single_line);
24792470
/* gen ASM from AST */
2480-
if (ASM == NULL) {
2481-
ASM = AST_genAsm(ast, &self->buffs);
2471+
char* sNew = self->astBeckend(self, ast);
2472+
if (sOut == NULL) {
2473+
sOut = sNew;
24822474
} else {
2483-
ASM = strsAppend(&self->buffs, ASM, AST_genAsm(ast, &self->buffs));
2475+
sOut = strsAppend(&self->lineBuffs, sOut, sNew);
24842476
}
24852477
if (NULL != ast) {
24862478
AST_deinit(ast);
24872479
}
24882480
}
24892481
exit:
2490-
return ASM;
2482+
return sOut;
24912483
}
24922484

24932485
static int Parser_isVoidLine(char* line) {
@@ -2523,20 +2515,17 @@ static uint8_t Parser_checkIsMultiComment(char* line, uint8_t* pbIsOneLine) {
25232515
return bIsMultiComment;
25242516
}
25252517

2526-
static char* _Parser_linesToBytesOrAsm(Args* outBuffs,
2527-
ByteCodeFrame* bytecode_frame,
2528-
char* sPyLines) {
2529-
Parser* parser = New_parser();
2530-
Arg* aAsm = arg_newStr("");
2518+
static char* parser_lines2BackendCode(Parser* self, char* sPyLines) {
2519+
Arg* aBackendCode = arg_newStr("");
25312520
uint32_t uLinesOffset = 0;
25322521
uint16_t uLinesNum = strCountSign(sPyLines, '\n') + 1;
25332522
uint16_t uLinesIndex = 0;
25342523
uint8_t bIsInMultiComment = 0;
25352524
uint8_t bIsOneLineMultiComment = 0;
25362525
Arg* aLineConnection = arg_newStr("");
25372526
uint8_t bIsLineConnection = 0;
2538-
char* sOutASM = NULL;
2539-
char* sSingleASM = NULL;
2527+
char* sOut = NULL;
2528+
char* sBackendCode = NULL;
25402529
uint32_t uLineSize = 0;
25412530
/* parse each line */
25422531
while (1) {
@@ -2552,15 +2541,15 @@ static char* _Parser_linesToBytesOrAsm(Args* outBuffs,
25522541

25532542
/* get single line by pop multiline */
25542543
sLineOrigin =
2555-
strsGetFirstToken(&parser->buffs, sPyLines + uLinesOffset, '\n');
2544+
strsGetFirstToken(&self->lineBuffs, sPyLines + uLinesOffset, '\n');
25562545

2557-
sLine = strsCopy(&parser->buffs, sLineOrigin);
2546+
sLine = strsCopy(&self->lineBuffs, sLineOrigin);
25582547

25592548
/* line connection */
25602549
if (bIsLineConnection) {
25612550
bIsLineConnection = 0;
25622551
aLineConnection = arg_strAppend(aLineConnection, sLine);
2563-
sLine = strsCopy(&parser->buffs, arg_getStr(aLineConnection));
2552+
sLine = strsCopy(&self->lineBuffs, arg_getStr(aLineConnection));
25642553
/* reflash the line_connection_arg */
25652554
arg_deinit(aLineConnection);
25662555
aLineConnection = arg_newStr("");
@@ -2597,9 +2586,9 @@ static char* _Parser_linesToBytesOrAsm(Args* outBuffs,
25972586
}
25982587

25992588
/* support Tab */
2600-
sLine = strsReplace(&parser->buffs, sLine, "\t", " ");
2589+
sLine = strsReplace(&self->lineBuffs, sLine, "\t", " ");
26012590
/* remove \r */
2602-
sLine = strsReplace(&parser->buffs, sLine, "\r", "");
2591+
sLine = strsReplace(&self->lineBuffs, sLine, "\r", "");
26032592

26042593
/* check auto connection */
26052594
Cursor_forEach(c, sLine) {
@@ -2618,60 +2607,60 @@ static char* _Parser_linesToBytesOrAsm(Args* outBuffs,
26182607

26192608
/* branket match failed */
26202609
if (c.branket_deepth != 0) {
2621-
sSingleASM = NULL;
2610+
sBackendCode = NULL;
26222611
goto parse_after;
26232612
}
26242613

26252614
parse_line:
26262615
/* parse single Line to Asm */
2627-
sSingleASM = parser_line2Asm(parser, sLine);
2616+
sBackendCode = parser_line2BackendCode(self, sLine);
26282617
parse_after:
2629-
if (NULL == sSingleASM) {
2630-
sOutASM = NULL;
2618+
if (NULL == sBackendCode) {
2619+
sOut = NULL;
26312620
pika_platform_printf(
26322621
"----------[%d]----------\r\n%s\r\n-------------------------"
26332622
"\r\n",
26342623
uLinesIndex, sLine);
2635-
strsDeinit(&parser->buffs);
2624+
strsDeinit(&self->lineBuffs);
26362625
goto exit;
26372626
}
26382627

2639-
if (NULL == bytecode_frame) {
2640-
/* store ASM */
2641-
aAsm = arg_strAppend(aAsm, sSingleASM);
2642-
} else if (NULL == outBuffs) {
2628+
if (self->isGenBytecode) {
26432629
/* store ByteCode */
2644-
byteCodeFrame_appendFromAsm(bytecode_frame, sSingleASM);
2630+
byteCodeFrame_appendFromAsm(self->bytecode_frame, sBackendCode);
2631+
} else {
2632+
/* store ASM */
2633+
aBackendCode = arg_strAppend(aBackendCode, sBackendCode);
26452634
}
26462635

26472636
next_line:
26482637
if (uLinesIndex < uLinesNum) {
26492638
uLineSize = strGetSize(sLineOrigin);
26502639
uLinesOffset = uLinesOffset + uLineSize + 1;
26512640
}
2652-
strsDeinit(&parser->buffs);
2641+
strsDeinit(&self->lineBuffs);
26532642

26542643
/* exit when finished */
26552644
if (uLinesIndex >= uLinesNum + 1) {
26562645
break;
26572646
}
26582647
}
2659-
if (NULL != outBuffs) {
2660-
/* load stored ASM */
2661-
sOutASM = strsCopy(outBuffs, arg_getStr(aAsm));
2648+
if (self->isGenBytecode) {
2649+
/* generate bytecode success */
2650+
sOut = (char*)1;
26622651
} else {
2663-
sOutASM = (char*)1;
2652+
/* load stored ASM */
2653+
sOut = strsCopy(&self->genBuffs, arg_getStr(aBackendCode));
26642654
}
26652655
goto exit;
26662656
exit:
2667-
if (NULL != aAsm) {
2668-
arg_deinit(aAsm);
2657+
if (NULL != aBackendCode) {
2658+
arg_deinit(aBackendCode);
26692659
}
26702660
if (NULL != aLineConnection) {
26712661
arg_deinit(aLineConnection);
26722662
}
2673-
parser_deinit(parser);
2674-
return sOutASM;
2663+
return sOut;
26752664
};
26762665

26772666
PIKA_RES pika_lines2Bytes(ByteCodeFrame* bf, char* py_lines) {
@@ -2682,15 +2671,29 @@ PIKA_RES pika_lines2Bytes(ByteCodeFrame* bf, char* py_lines) {
26822671
" Note: Please check PIKA_BYTECODE_ONLY_ENABLE config.\r\n");
26832672
return PIKA_RES_ERR_SYNTAX_ERROR;
26842673
#else
2685-
if (1 == (uintptr_t)_Parser_linesToBytesOrAsm(NULL, bf, py_lines)) {
2674+
Parser* parser = New_parser();
2675+
parser->isGenBytecode = PIKA_TRUE;
2676+
parser->bytecode_frame = bf;
2677+
if (1 == (uintptr_t)parser_lines2BackendCode(parser, py_lines)) {
2678+
parser_deinit(parser);
26862679
return PIKA_RES_OK;
26872680
}
2681+
parser_deinit(parser);
26882682
return PIKA_RES_ERR_SYNTAX_ERROR;
26892683
#endif
26902684
}
26912685

26922686
char* pika_lines2Asm(Args* outBuffs, char* multi_line) {
2693-
return _Parser_linesToBytesOrAsm(outBuffs, NULL, multi_line);
2687+
Parser* parser = New_parser();
2688+
parser->isGenBytecode = PIKA_FALSE;
2689+
char* sAsm = parser_lines2BackendCode(parser, multi_line);
2690+
if (NULL == sAsm) {
2691+
parser_deinit(parser);
2692+
return NULL;
2693+
}
2694+
sAsm = strsCopy(outBuffs, sAsm);
2695+
parser_deinit(parser);
2696+
return sAsm;
26942697
}
26952698

26962699
char* pika_file2Asm(Args* outBuffs, char* filename) {
@@ -3101,6 +3104,10 @@ char* AST_genAsm(AST* oAST, Args* outBuffs) {
31013104
return sPikaAsm;
31023105
}
31033106

3107+
char* parser_Ast2Asm(Parser* self, AST* ast) {
3108+
return AST_genAsm(ast, &self->lineBuffs);
3109+
}
3110+
31043111
int32_t AST_deinit(AST* ast) {
31053112
return obj_deinit(ast);
31063113
}
@@ -3226,13 +3233,16 @@ Parser* New_parser(void) {
32263233
Parser* self = (Parser*)pikaMalloc(sizeof(Parser));
32273234
pika_platform_memset(self, 0, sizeof(Parser));
32283235
self->blockState.stack = pikaMalloc(sizeof(Stack));
3236+
/* generate asm as default */
3237+
self->astBeckend = parser_Ast2Asm;
32293238
pika_platform_memset(self->blockState.stack, 0, sizeof(Stack));
32303239
stack_init(self->blockState.stack);
32313240
return self;
32323241
}
32333242

32343243
int parser_deinit(Parser* self) {
32353244
stack_deinit(self->blockState.stack);
3245+
strsDeinit(&self->genBuffs);
32363246
pikaFree(self->blockState.stack, sizeof(Stack));
32373247
pikaFree(self, sizeof(Parser));
32383248
return 0;

‎src/PikaParser.h‎

Lines changed: 14 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -79,15 +79,21 @@ typedef struct GenRule {
7979
char* val;
8080
} GenRule;
8181

82-
typedef struct AstBlockInfo {
82+
typedef struct BlockState {
8383
Stack* stack;
8484
int deepth;
8585
} BlockState;
8686

87-
typedef struct Parser {
88-
Args buffs;
87+
typedef struct Parser Parser;
88+
typedef char* (*parser_AstBeckend)(Parser* self, AST* ast);
89+
struct Parser {
90+
Args lineBuffs;
91+
Args genBuffs;
8992
BlockState blockState;
90-
} Parser;
93+
parser_AstBeckend astBeckend;
94+
PIKA_BOOL isGenBytecode;
95+
ByteCodeFrame* bytecode_frame;
96+
};
9197

9298
typedef struct LexToken LexToken;
9399
struct LexToken {
@@ -117,10 +123,12 @@ char* pika_file2Asm(Args* outBuffs, char* filename);
117123
char* pika_lines2Asm(Args* outBuffs, char* multiLine);
118124
char* pika_lines2Array(char* lines);
119125
char* pika_line2Asm(Args* buffs_p, char* line, Stack* blockStack);
126+
AST* parser_line2AST(Parser* self, char* line);
127+
char* parser_Ast2Asm(Parser* self, AST* ast);
128+
AST* line2Ast(char* line);
120129

121130
PIKA_RES pika_lines2Bytes(ByteCodeFrame* bf, char* py_lines);
122-
char* parser_line2Asm(Parser* self, char* line);
123-
AST* line2Ast(char* line);
131+
char* parser_line2BackendCode(Parser* self, char* line);
124132

125133
Parser* New_parser(void);
126134
int parser_deinit(Parser* parser);

0 commit comments

Comments
 (0)