From 18014ab01db8c6c8f22017bdbe9a3f8659967e65 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B8=82=E5=B7=9D=20=E7=9C=9F=E4=B8=80?= Date: Thu, 13 Jan 2022 17:13:34 +0900 Subject: [PATCH] =?UTF-8?q?do=20=E6=96=87=E3=81=AE=E5=AE=9F=E8=A3=85?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 13 +- src/lib/tp_compiler/tp_compiler.h | 26 +- src/lib/tp_compiler/tp_compiler.vcxproj | 5 +- .../tp_compiler/tp_compiler.vcxproj.filters | 3 + .../tp_compiler/tp_init_symbol_table.c | 48 ++- src/lib/tp_compiler/tp_compiler/tp_test.c | 28 ++ src/lib/tp_compiler/tp_compiler_parse_tree.h | 21 +- .../tp_compiler_semantic_analysis.h | 75 +++-- src/lib/tp_compiler/tp_compiler_wasm.h | 5 +- .../tp_make_parse_tree/tp_make_parse_tree.c | 7 +- .../tp_make_parse_tree/tp_parser_statement.c | 189 ++++++++++-- .../tp_make_token/tp_preprocessor.c | 33 +++ .../tp_make_wasm/tp_make_wasm_body_C.c | 5 +- .../tp_make_wasm/tp_make_wasm_body_C_expr.c | 30 +- .../tp_make_wasm_body_C_statements.c | 70 ++++- .../tp_make_wasm/tp_make_wasm_body_expr.c | 2 +- .../tp_make_wasm/tp_make_wasm_disasm.c | 11 +- .../tp_make_wasm/tp_make_wasm_opcode.c | 7 +- .../tp_make_x64_code/tp_make_x64_code.c | 39 +-- .../tp_make_x64_code/tp_make_x64_code_body.c | 19 +- .../tp_make_C_IR_declarations.c | 27 +- .../tp_make_C_IR_declarator.c | 3 +- .../tp_make_C_IR_direct_declarator.c | 35 +-- .../tp_semantic_analysis/tp_make_C_IR_expr.c | 67 ++++- .../tp_make_C_IR_expr_cond.c | 3 +- .../tp_make_C_IR_expr_one_op.c | 9 +- .../tp_make_C_IR_expr_postfix.c | 21 +- .../tp_make_C_IR_expr_primary.c | 3 +- .../tp_make_C_IR_expr_two_op_arithmetic.c | 18 +- .../tp_make_C_IR_expr_two_op_bit.c | 9 +- .../tp_make_C_IR_expr_two_op_logical.c | 6 +- .../tp_make_C_IR_expr_two_op_other.c | 102 ++++++- .../tp_make_C_IR_external_declarations.c | 3 +- .../tp_make_C_IR_function_definition.c | 40 +-- .../tp_make_C_IR_initializer.c | 3 +- .../tp_make_C_IR_statements.c | 151 ++++++---- .../tp_make_C_IR_statements_expr.c | 13 +- .../tp_make_C_IR_statements_iteration.c | 279 ++++++++++++++++++ .../tp_make_C_IR_statements_jump.c | 24 +- .../tp_make_C_IR_translation_unit.c | 14 +- .../tp_semantic_analysis.c | 2 +- src/tenpoku-dev/tenpoku-dev.vcxproj | 4 +- 42 files changed, 1145 insertions(+), 327 deletions(-) create mode 100644 src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_iteration.c diff --git a/README.md b/README.md index 35f2024..49a0324 100644 --- a/README.md +++ b/README.md @@ -36,9 +36,18 @@ C:\>echo.>PE_COFF-master.zip:Zone.Identifier ## 開発環境 -* Visual Studio Community 2019 +* Visual Studio Community 2022 + +Windows SDK and developer tools - Windows app development +https://developer.microsoft.com/en-us/windows/downloads/ + +Visual Studio Older Downloads +https://visualstudio.microsoft.com/vs/older-downloads/ + +Download the Windows Driver Kit (WDK) - Windows drivers | Microsoft Docs https://docs.microsoft.com/en-us/windows-hardware/drivers/download-the-wdk -* 64 ビット版 Windows 10 + +* 64 ビット版 Windows 10 / 11 ## ビルド方法 diff --git a/src/lib/tp_compiler/tp_compiler.h b/src/lib/tp_compiler/tp_compiler.h index 7773ec5..d2be751 100644 --- a/src/lib/tp_compiler/tp_compiler.h +++ b/src/lib/tp_compiler/tp_compiler.h @@ -381,7 +381,9 @@ bool tp_print_parse_tree_grammer( ); TP_PARSE_TREE* tp_parse_translation_unit(TP_SYMBOL_TABLE* symbol_table); -TP_PARSE_TREE* tp_parse_statement(TP_SYMBOL_TABLE* symbol_table); +TP_PARSE_TREE* tp_parse_statement( + TP_SYMBOL_TABLE* symbol_table, TP_PARSE_WRAP_CONTEXT parse_wrap_context +); TP_PARSE_TREE* tp_parse_compound_statement(TP_SYMBOL_TABLE* symbol_table); TP_PARSE_TREE* tp_parse_expression(TP_SYMBOL_TABLE* symbol_table); TP_PARSE_TREE* tp_parse_constant_expression(TP_SYMBOL_TABLE* symbol_table); @@ -506,6 +508,11 @@ bool tp_make_C_IR_expression_statement( TP_PARSE_TREE* parse_tree, TP_GRAMMER_CONTEXT grammer_context, TP_C_OBJECT* c_object ); +bool tp_make_C_IR_iteration_statement( + TP_SYMBOL_TABLE* symbol_table, + TP_PARSE_TREE* parse_tree, TP_GRAMMER_CONTEXT grammer_context, + TP_C_OBJECT* c_object +); bool tp_make_C_IR_jump_statement( TP_SYMBOL_TABLE* symbol_table, TP_PARSE_TREE* parse_tree, TP_GRAMMER_CONTEXT grammer_context, @@ -692,7 +699,8 @@ bool tp_make_wasm_C_expression( bool tp_make_wasm_C_iteration_statement_do( TP_SYMBOL_TABLE* symbol_table, uint8_t* entry_point_symbol, TP_WASM_MODULE_SECTION* section, TP_C_OBJECT* c_object, - TP_C_TYPE_ITERATION_STATEMENT_DO* type_iteration_statement_do + TP_C_TYPE_ITERATION_STATEMENT_DO* type_iteration_statement_do, + TP_C_TYPE* type_return, uint32_t parameter_num, TP_C_TYPE_FUNCTION_F_PARAM* parameter ); bool tp_make_wasm_C_jump_statement_return( TP_SYMBOL_TABLE* symbol_table, uint8_t* entry_point_symbol, @@ -833,7 +841,10 @@ uint32_t tp_make_i64_store_code( uint32_t tp_make_i32_const_code(uint8_t* buffer, size_t offset, int32_t value); uint32_t tp_make_i64_const_code(uint8_t* buffer, size_t offset, int64_t value); -// Comparison operators +// Comparison operators(i32) +uint32_t tp_make_i32_ne_code(uint8_t* buffer, size_t offset); + +// Comparison operators(i64) uint32_t tp_make_i64_ne_code(uint8_t* buffer, size_t offset); // Numeric operators(i32) @@ -963,7 +974,14 @@ uint32_t tp_encode_i64_const_code( TP_WASM_RELOCATION* wasm_relocation, int64_t value, bool* status ); -// Comparison operators +// Comparison operators(i32) + +uint32_t tp_encode_i32_ne_code( + TP_SYMBOL_TABLE* symbol_table, uint8_t* x64_code_buffer, uint32_t x64_code_offset, + TP_WASM_RELOCATION* wasm_relocation, TP_WASM_STACK_ELEMENT* op1, TP_WASM_STACK_ELEMENT* op2 +); + +// Comparison operators(i64) uint32_t tp_encode_i64_ne_code( TP_SYMBOL_TABLE* symbol_table, uint8_t* x64_code_buffer, uint32_t x64_code_offset, diff --git a/src/lib/tp_compiler/tp_compiler.vcxproj b/src/lib/tp_compiler/tp_compiler.vcxproj index d52fd77..8ff5f2f 100644 --- a/src/lib/tp_compiler/tp_compiler.vcxproj +++ b/src/lib/tp_compiler/tp_compiler.vcxproj @@ -91,6 +91,7 @@ + @@ -121,7 +122,7 @@ StaticLibrary true - v142 + v143 Unicode false @@ -151,6 +152,8 @@ true ProgramDatabase MultiThreadedDebugDLL + stdcpp20 + stdc17 Windows diff --git a/src/lib/tp_compiler/tp_compiler.vcxproj.filters b/src/lib/tp_compiler/tp_compiler.vcxproj.filters index 82fffff..0324b63 100644 --- a/src/lib/tp_compiler/tp_compiler.vcxproj.filters +++ b/src/lib/tp_compiler/tp_compiler.vcxproj.filters @@ -318,6 +318,9 @@ ソース ファイル\tp_make_parse_tree + + ソース ファイル\tp_semantic_analysis + diff --git a/src/lib/tp_compiler/tp_compiler/tp_init_symbol_table.c b/src/lib/tp_compiler/tp_compiler/tp_init_symbol_table.c index c4347cd..ee2e718 100644 --- a/src/lib/tp_compiler/tp_compiler/tp_init_symbol_table.c +++ b/src/lib/tp_compiler/tp_compiler/tp_init_symbol_table.c @@ -513,7 +513,7 @@ void tp_free_memory_and_file(TP_SYMBOL_TABLE** symbol_table) rsize_t token_pos = (*symbol_table)->member_tp_token_pos; - for (rsize_t i = 0; token_pos > i; ++i){ + for (rsize_t i = (((*symbol_table)->member_is_int_calc_compiler) ? 0 : 2); token_pos > i; ++i){ if (token[i].member_string){ @@ -798,12 +798,16 @@ static void free_c_type(TP_SYMBOL_TABLE* symbol_table, TP_C_TYPE** c_type) return; } - // C compiler: type - TP_C_TYPE_COMPOUND_STATEMENT* compound_statement = NULL; + TP_C_TYPE_COMPOUND_STATEMENT* type_compound_statement = NULL; switch ((*c_type)->member_type){ + case TP_C_TYPE_TYPE_NONE: + break; case TP_C_TYPE_TYPE_BASIC: break; + case TP_C_TYPE_TYPE_STRUCT: + TP_PUT_LOG_MSG_ICE(symbol_table); + break; case TP_C_TYPE_TYPE_FUNCTION:{ TP_C_TYPE_FUNCTION* function = &((*c_type)->member_body.member_type_function); @@ -835,7 +839,7 @@ static void free_c_type(TP_SYMBOL_TABLE* symbol_table, TP_C_TYPE** c_type) TP_FREE(symbol_table, &(function->member_c_return_type), sizeof(TP_C_TYPE)); - compound_statement = &(function->member_function_body); + type_compound_statement = &(function->member_function_body); goto compound_statement; } case TP_C_TYPE_TYPE_FUNCTION_PARAM:{ @@ -846,17 +850,20 @@ static void free_c_type(TP_SYMBOL_TABLE* symbol_table, TP_C_TYPE** c_type) TP_FREE(symbol_table, type_param, sizeof(TP_C_TYPE)); break; } + case TP_C_TYPE_TYPE_POINTER: + TP_PUT_LOG_MSG_ICE(symbol_table); + break; case TP_C_TYPE_TYPE_NULL_STATEMENT: break; case TP_C_TYPE_TYPE_COMPOUND_STATEMENT:{ - compound_statement = &((*c_type)->member_body.member_type_compound_statement); + type_compound_statement = &((*c_type)->member_body.member_type_compound_statement); compound_statement: ; - TP_C_OBJECT** c_object_local = compound_statement->member_statement_body; + TP_C_OBJECT** c_object_local = type_compound_statement->member_statement_body; if (c_object_local){ - rsize_t c_object_local_pos = compound_statement->member_statement_body_pos; + rsize_t c_object_local_pos = type_compound_statement->member_statement_body_pos; for (rsize_t i = 0; c_object_local_pos > i; ++i){ @@ -866,7 +873,7 @@ static void free_c_type(TP_SYMBOL_TABLE* symbol_table, TP_C_TYPE** c_type) } } - TP_FREE2(symbol_table, &c_object_local, compound_statement->member_statement_body_size); + TP_FREE2(symbol_table, &c_object_local, type_compound_statement->member_statement_body_size); } break; } @@ -876,10 +883,20 @@ static void free_c_type(TP_SYMBOL_TABLE* symbol_table, TP_C_TYPE** c_type) &((*c_type)->member_body.member_type_declaration_statement.member_declaration); free_c_type(symbol_table, type_declaration); TP_FREE(symbol_table, type_declaration, sizeof(TP_C_TYPE)); -// break; + free_c_expr(symbol_table, c_type); + break; } case TP_C_TYPE_TYPE_EXPRESSION_STATEMENT: -// break; + free_c_expr(symbol_table, c_type); + break; + case TP_C_TYPE_TYPE_ITERATION_STATEMENT_DO:{ + + TP_C_OBJECT** statement = + &((*c_type)->member_body.member_type_iteration_statement_do.member_statement); + tp_free_c_object(symbol_table, statement); + free_c_expr(symbol_table, c_type); + break; + } case TP_C_TYPE_TYPE_JUMP_STATEMENT_RETURN: free_c_expr(symbol_table, c_type); break; @@ -917,6 +934,17 @@ static void free_c_expr(TP_SYMBOL_TABLE* symbol_table, TP_C_TYPE** c_type) ); break; } + case TP_C_TYPE_TYPE_ITERATION_STATEMENT_DO:{ + + TP_C_TYPE_ITERATION_STATEMENT_DO* type_iteration_statement_do = + &(c_type_body->member_type_iteration_statement_do); + + TP_FREE( + symbol_table, &(type_iteration_statement_do->member_c_expr), + type_iteration_statement_do->member_c_expr_size + ); + break; + } case TP_C_TYPE_TYPE_JUMP_STATEMENT_RETURN:{ TP_C_TYPE_JUMP_STATEMENT_RETURN* type_jump_statement_return = diff --git a/src/lib/tp_compiler/tp_compiler/tp_test.c b/src/lib/tp_compiler/tp_compiler/tp_test.c index 440f057..296eb97 100644 --- a/src/lib/tp_compiler/tp_compiler/tp_test.c +++ b/src/lib/tp_compiler/tp_compiler/tp_test.c @@ -321,6 +321,34 @@ TEST_CASE_TABLE tp_C_test_case_table[] = { " return calc_body(g_value1 = (1 + 2) * 3, value2, g_value3, 51);\n" "}\n", 202 }, + // No.29 + { "int calc(void)\n" + "{\n" + " int v = 3;\n" + " int w = 3;\n" + "\n" + " do{\n" + " v = v - 1;\n" + " do w = w - 1; while (w);\n" + " }while (v);\n" + "\n" + " return v;\n" + "}\n", 0 }, + + // No.30 + { "int calc(void)\n" + "{\n" + " int v = 0;\n" + "\n" + " do{\n" + " v = v + 1;\n" + " int w = 0;\n" + " do w = w + 1; while (w != 3);\n" + " }while (v != 3);\n" + "\n" + " return v;\n" + "}\n", 3 }, + { NULL, 0 } }; diff --git a/src/lib/tp_compiler/tp_compiler_parse_tree.h b/src/lib/tp_compiler/tp_compiler_parse_tree.h index 307f0cd..839683d 100644 --- a/src/lib/tp_compiler/tp_compiler_parse_tree.h +++ b/src/lib/tp_compiler/tp_compiler_parse_tree.h @@ -221,11 +221,11 @@ #define IS_END_OF_TOKEN(token) ((NULL == (token)) || ((token) && (TP_SYMBOL_NULL == (token)->member_symbol))) #define MAKE_PARSE_SUBTREE(symbol_table, grammer, ...) \ - tp_make_parse_subtree( \ - (symbol_table), (grammer), \ - (TP_PARSE_TREE_ELEMENT[]){ __VA_ARGS__ }, \ - sizeof((TP_PARSE_TREE_ELEMENT[]){ __VA_ARGS__ }) / sizeof(TP_PARSE_TREE_ELEMENT) \ - ) + tp_make_parse_subtree( \ + (symbol_table), (grammer), \ + (TP_PARSE_TREE_ELEMENT[]){ __VA_ARGS__ }, \ + sizeof((TP_PARSE_TREE_ELEMENT[]){ __VA_ARGS__ }) / sizeof(TP_PARSE_TREE_ELEMENT) \ + ) #define TP_TREE_TOKEN(token) (TP_PARSE_TREE_ELEMENT){ \ .member_type = TP_PARSE_TREE_TYPE_TOKEN, \ .member_body.member_tp_token = (token) \ @@ -246,9 +246,11 @@ typedef enum TP_PARSE_TREE_TYPE_ TP_PARSE_TREE_TYPE_NODE }TP_PARSE_TREE_TYPE; +typedef struct tp_parse_tree_ TP_PARSE_TREE; + typedef union tp_parse_tree_element_union_{ TP_TOKEN* member_tp_token; // NOTE: member_token must not free memory. - struct tp_parse_tree_* member_child; + TP_PARSE_TREE* member_child; }TP_PARSE_TREE_ELEMENT_UNION; typedef struct tp_parse_tree_element_{ @@ -256,6 +258,11 @@ typedef struct tp_parse_tree_element_{ TP_PARSE_TREE_ELEMENT_UNION member_body; }TP_PARSE_TREE_ELEMENT; +typedef enum TP_PARSE_WRAP_CONTEXT_{ + TP_PARSE_NONE_WRAP_COMPOUND_STATEMENT = 0, + TP_PARSE_WRAP_COMPOUND_STATEMENT +}TP_PARSE_WRAP_CONTEXT; + typedef enum TP_PARSE_TREE_GRAMMER_ { TP_PARSE_TREE_GRAMMER_NULL = 0, @@ -836,8 +843,6 @@ typedef enum TP_PARSE_TREE_GRAMMER_ TP_PARSE_TREE_GRAMMER_NUM }TP_PARSE_TREE_GRAMMER; -typedef struct tp_c_object_ TP_C_OBJECT; - typedef struct tp_parse_tree_{ TP_PARSE_TREE_GRAMMER member_grammer; size_t member_element_num; diff --git a/src/lib/tp_compiler/tp_compiler_semantic_analysis.h b/src/lib/tp_compiler/tp_compiler_semantic_analysis.h index 66393de..8a9645b 100644 --- a/src/lib/tp_compiler/tp_compiler_semantic_analysis.h +++ b/src/lib/tp_compiler/tp_compiler_semantic_analysis.h @@ -17,6 +17,8 @@ typedef enum register_object_type_{ UNDEFINED_REGISTER_OBJECT, }REGISTER_OBJECT_TYPE; +typedef struct tp_c_object_ TP_C_OBJECT; + typedef struct register_object_{ REGISTER_OBJECT_TYPE member_register_object_type; // Use int_calc_compiler. @@ -72,6 +74,31 @@ typedef struct register_object_hash_{ #define TP_C_SCOPE_C_OBJECT_SIZE_ALLOCATE_UNIT 32 #define TP_C_SCOPE_STACK_SIZE_ALLOCATE_UNIT 32 +#define TP_C_INHERIT_ATTR_TO_C_OBJECT_FROM_C_OBJECT(dst_obj, src_obj) \ + (dst_obj)->member_function_parameter_attr = (src_obj)->member_function_parameter_attr; \ + (dst_obj)->member_function_parameter_num_attr = (src_obj)->member_function_parameter_num_attr; \ + (dst_obj)->member_c_return_type_attr = (src_obj)->member_c_return_type_attr; + +#define TP_C_INHERIT_ATTR_TO_COMPOUND_STATEMENT_FROM_C_OBJECT(dst_cs, src_obj) \ + (dst_cs)->member_function_parameter_attr = (src_obj)->member_function_parameter_attr; \ + (dst_cs)->member_function_parameter_num_attr = (src_obj)->member_function_parameter_num_attr; \ + (dst_cs)->member_c_return_type_attr = (src_obj)->member_c_return_type_attr; + +#define TP_C_INHERIT_ATTR_TO_C_OBJECT_FROM_COMPOUND_STATEMENT(dst_obj, src_cs) \ + (dst_obj)->member_function_parameter_attr = (src_cs)->member_function_parameter_attr; \ + (dst_obj)->member_function_parameter_num_attr = (src_cs)->member_function_parameter_num_attr; \ + (dst_obj)->member_c_return_type_attr = (src_cs)->member_c_return_type_attr; + +#define TP_C_INHERIT_ATTR_TO_COMPOUND_STATEMENT_FROM_COMPOUND_STATEMENT(dst_cs, src_cs) \ + (dst_cs)->member_function_parameter_attr = (src_cs)->member_function_parameter_attr; \ + (dst_cs)->member_function_parameter_num_attr = (src_cs)->member_function_parameter_num_attr; \ + (dst_cs)->member_c_return_type_attr = (src_cs)->member_c_return_type_attr; + +#define TP_C_INHERIT_ATTR_TO_FUNCTION_BODY_FROM_C_OBJECT(dst_fb, src_obj) \ + (dst_fb)->member_function_parameter_attr = (src_obj)->member_function_parameter_attr; \ + (dst_fb)->member_function_parameter_num_attr = (src_obj)->member_function_parameter_num_attr; \ + (dst_fb)->member_c_return_type_attr = (src_obj)->member_c_return_type_attr; + typedef enum TP_GRAMMER_CONTEXT_{ TP_GRAMMER_CONTEXT_NULL = 0, TP_GRAMMER_CONTEXT_TRANSLATION_UNIT, @@ -125,18 +152,6 @@ typedef struct tp_c_scope_{ typedef enum TP_C_EXPR_KIND_{ TP_C_EXPR_KIND_IDENTIFIER_NULL, -// Control flow operators - // ToDo: -/* -#define TP_WASM_OPCODE_LOOP 0x03 // sig: block_type -#define TP_WASM_OPCODE_END 0x0b -#define TP_WASM_OPCODE_BR_IF 0x0d // relative_depth: varuint32 - */ - -// Proprietary specification : Value operators(pseudo opcode) - // ToDo: -//#define TP_WASM_OPCODE_LOOP_LABEL 0xff03 - // Call operators TP_C_EXPR_KIND_CALL_INDIRECT_RIP, TP_C_EXPR_KIND_I32_RETURN, @@ -172,9 +187,11 @@ typedef enum TP_C_EXPR_KIND_{ TP_C_EXPR_KIND_I64_CONST, TP_C_EXPR_KIND_STRING_LITERAL, -// Comparison operators - // ToDo: -//#define TP_WASM_OPCODE_I64_NE 0x52 // op1 != op2 +// Comparison operators(i32) + TP_C_EXPR_KIND_I32_NE, // op1 != op2 + +// Comparison operators(i64) + TP_C_EXPR_KIND_I64_NE, // op1 != op2 // Numeric operators(i32) TP_C_EXPR_KIND_I32_ADD, @@ -403,10 +420,10 @@ typedef struct tp_c_type_array_{ typedef struct tp_c_function_f_param_ TP_C_TYPE_FUNCTION_F_PARAM; typedef struct tp_c_type_compound_statement_{ - // NOTE: member_function_parameter must not free memory. - TP_C_TYPE_FUNCTION_F_PARAM* member_function_parameter; - uint32_t member_function_parameter_num; - TP_C_TYPE* member_c_return_type; // NOTE: member_c_return_type must not free memory. + // NOTE: member_function_parameter_attr must not free memory. + TP_C_TYPE_FUNCTION_F_PARAM* member_function_parameter_attr; + uint32_t member_function_parameter_num_attr; + TP_C_TYPE* member_c_return_type_attr; // NOTE: member_c_return_type_attr must not free memory. TP_C_OBJECT** member_statement_body; rsize_t member_statement_body_pos; rsize_t member_statement_body_size; @@ -415,18 +432,18 @@ typedef struct tp_c_type_compound_statement_{ typedef struct tp_c_type_labeled_statement_label_{ // labeled-statement -> identifier : statement TP_TOKEN* member_identifier; // NOTE: member_token must not free memory. - TP_C_TYPE* member_statement; + TP_C_OBJECT* member_statement; }TP_C_TYPE_LABELED_STATEMENT_LABEL; typedef struct tp_c_type_labeled_statement_case_{ // case constant-expression : statement TP_PARSE_TREE* member_constant_expression; // NOTE: member_constant_expression must not free memory. - TP_C_TYPE* member_statement; + TP_C_OBJECT* member_statement; }TP_C_TYPE_LABELED_STATEMENT_CASE; typedef struct tp_c_type_labeled_statement_default_{ // default : statement - TP_C_TYPE* member_statement; + TP_C_OBJECT* member_statement; }TP_C_TYPE_LABELED_STATEMENT_DEFAULT; typedef struct tp_c_type_declaration_statement_{ @@ -453,8 +470,8 @@ typedef struct tp_c_type_expression_statement_{ typedef struct tp_c_type_selection_statement_if_{ // if ( expression ) statement (else statement)? TP_PARSE_TREE* member_expression; // NOTE: member_expression must not free memory. - TP_C_TYPE* member_statement; - TP_C_TYPE* member_statement_else; + TP_C_OBJECT* member_statement; + TP_C_OBJECT* member_statement_else; // expression TP_C_EXPR* member_c_expr; @@ -465,7 +482,7 @@ typedef struct tp_c_type_selection_statement_if_{ typedef struct tp_c_type_selection_statement_switch_{ // switch ( expression ) statement TP_PARSE_TREE* member_expression; // NOTE: member_expression must not free memory. - TP_C_TYPE* member_statement; + TP_C_OBJECT* member_statement; // expression TP_C_EXPR* member_c_expr; @@ -476,7 +493,7 @@ typedef struct tp_c_type_selection_statement_switch_{ typedef struct tp_c_type_iteration_statement_while_{ // while ( expression ) statement TP_PARSE_TREE* member_expression; // NOTE: member_expression must not free memory. - TP_C_TYPE* member_statement; + TP_C_OBJECT* member_statement; // expression TP_C_EXPR* member_c_expr; @@ -486,7 +503,7 @@ typedef struct tp_c_type_iteration_statement_while_{ typedef struct tp_c_type_iteration_statement_do_{ // do statement while ( expression ) ; - TP_C_TYPE* member_statement; + TP_C_OBJECT* member_statement; TP_PARSE_TREE* member_expression; // NOTE: member_expression must not free memory. // expression @@ -500,7 +517,7 @@ typedef struct tp_c_type_iteration_statement_for_{ TP_PARSE_TREE* member_expression1; // NOTE: member_expression1 must not free memory. TP_PARSE_TREE* member_expression2; // NOTE: member_expression2 must not free memory. TP_PARSE_TREE* member_expression3; // NOTE: member_expression3 must not free memory. - TP_C_TYPE* member_statement; + TP_C_OBJECT* member_statement; // expression1 TP_C_EXPR* member_c_expr1; @@ -544,7 +561,7 @@ typedef struct tp_c_type_iteration_statement_for_decl_{ TP_C_TYPE_DECLARATION_STATEMENT member_declaration; TP_PARSE_TREE* member_expression2; // NOTE: member_expression2 must not free memory. TP_PARSE_TREE* member_expression3; // NOTE: member_expression3 must not free memory. - TP_C_TYPE* member_statement; + TP_C_OBJECT* member_statement; // expression2 TP_C_EXPR* member_c_expr2; diff --git a/src/lib/tp_compiler/tp_compiler_wasm.h b/src/lib/tp_compiler/tp_compiler_wasm.h index e3ced7e..72f5945 100644 --- a/src/lib/tp_compiler/tp_compiler_wasm.h +++ b/src/lib/tp_compiler/tp_compiler_wasm.h @@ -460,7 +460,10 @@ typedef struct TP_WASM_RELOCATION_{ #define TP_WASM_OPCODE_I32_CONST 0x41 // value: varint32 #define TP_WASM_OPCODE_I64_CONST 0x42 // value: varint64 -// Comparison operators +// Comparison operators(i32) +#define TP_WASM_OPCODE_I32_NE 0x47 // op1 != op2 + +// Comparison operators(i64) #define TP_WASM_OPCODE_I64_NE 0x52 // op1 != op2 // Numeric operators(i32) diff --git a/src/lib/tp_compiler/tp_make_parse_tree/tp_make_parse_tree.c b/src/lib/tp_compiler/tp_make_parse_tree/tp_make_parse_tree.c index 2ea5684..ea9fd60 100644 --- a/src/lib/tp_compiler/tp_make_parse_tree/tp_make_parse_tree.c +++ b/src/lib/tp_compiler/tp_make_parse_tree/tp_make_parse_tree.c @@ -55,6 +55,8 @@ bool tp_make_parse_tree(TP_SYMBOL_TABLE* symbol_table) }else{ // C compiler + TP_POS(symbol_table) += 2; // virtual_token: { } + tmp_program = tp_parse_translation_unit(symbol_table); } @@ -378,7 +380,8 @@ TP_PARSE_TREE* tp_make_parse_subtree( TP_SYMBOL_TABLE* symbol_table, TP_PARSE_TREE_GRAMMER grammer, TP_PARSE_TREE_ELEMENT* parse_tree_element, size_t parse_tree_element_num) { - TP_PARSE_TREE* parse_subtree = (TP_PARSE_TREE*)TP_CALLOC(symbol_table, 1, sizeof(TP_PARSE_TREE)); + TP_PARSE_TREE* parse_subtree = + (TP_PARSE_TREE*)TP_CALLOC(symbol_table, 1, sizeof(TP_PARSE_TREE)); if (NULL == parse_subtree){ @@ -538,7 +541,7 @@ static bool dump_parse_tree_main(TP_SYMBOL_TABLE* symbol_table, TP_PARSE_TREE* p fprintf(write_file, "%sTP_PARSE_TREE_TYPE_NODE\n", indent_string); if ( ! dump_parse_tree_main( - symbol_table, (TP_PARSE_TREE*)parse_tree_element[i].member_body.member_child, indent_level + 1)){ + symbol_table, parse_tree_element[i].member_body.member_child, indent_level + 1)){ TP_PUT_LOG_MSG_TRACE(symbol_table); diff --git a/src/lib/tp_compiler/tp_make_parse_tree/tp_parser_statement.c b/src/lib/tp_compiler/tp_make_parse_tree/tp_parser_statement.c index 7b51b90..d25c010 100644 --- a/src/lib/tp_compiler/tp_make_parse_tree/tp_parser_statement.c +++ b/src/lib/tp_compiler/tp_make_parse_tree/tp_parser_statement.c @@ -38,6 +38,9 @@ // return expression? ; static TP_PARSE_TREE* parse_labeled_statement(TP_SYMBOL_TABLE* symbol_table); +static TP_PARSE_TREE* wrap_compound_statement( + TP_SYMBOL_TABLE* symbol_table, TP_PARSE_TREE* statement +); static TP_PARSE_TREE* parse_block_item_list(TP_SYMBOL_TABLE* symbol_table); static TP_PARSE_TREE* parse_block_item(TP_SYMBOL_TABLE* symbol_table); static TP_PARSE_TREE* parse_expression_statement(TP_SYMBOL_TABLE* symbol_table); @@ -54,7 +57,8 @@ static TP_PARSE_TREE* parse_iteration_statement_do(TP_SYMBOL_TABLE* symbol_table static TP_PARSE_TREE* parse_iteration_statement_for(TP_SYMBOL_TABLE* symbol_table, TP_TOKEN* tmp_for); static TP_PARSE_TREE* parse_jump_statement(TP_SYMBOL_TABLE* symbol_table); -TP_PARSE_TREE* tp_parse_statement(TP_SYMBOL_TABLE* symbol_table) +TP_PARSE_TREE* tp_parse_statement( + TP_SYMBOL_TABLE* symbol_table, TP_PARSE_WRAP_CONTEXT parse_wrap_context) { // Grammer: statement -> labeled-statement | // compound-statement | expression-statement | selection-statement | @@ -67,11 +71,27 @@ TP_PARSE_TREE* tp_parse_statement(TP_SYMBOL_TABLE* symbol_table) if (tmp_labeled_statement){ - return MAKE_PARSE_SUBTREE( + TP_PARSE_TREE* tmp_statement = MAKE_PARSE_SUBTREE( symbol_table, TP_PARSE_TREE_GRAMMER_C_STATEMENT_1, TP_TREE_NODE(tmp_labeled_statement) ); + + if (tmp_statement){ + + if (TP_PARSE_WRAP_COMPOUND_STATEMENT == parse_wrap_context){ + + return wrap_compound_statement(symbol_table, tmp_statement); + }else{ + + return tmp_statement; + } + }else{ + + tp_free_parse_subtree(symbol_table, &tmp_labeled_statement); + TP_POS(symbol_table) = backup_token_position; + return NULL; + } } TP_POS(symbol_table) = backup_token_position; @@ -99,11 +119,27 @@ TP_PARSE_TREE* tp_parse_statement(TP_SYMBOL_TABLE* symbol_table) if (tmp_expression_statement){ - return MAKE_PARSE_SUBTREE( + TP_PARSE_TREE* tmp_statement = MAKE_PARSE_SUBTREE( symbol_table, TP_PARSE_TREE_GRAMMER_C_STATEMENT_3, TP_TREE_NODE(tmp_expression_statement) ); + + if (tmp_statement){ + + if (TP_PARSE_WRAP_COMPOUND_STATEMENT == parse_wrap_context){ + + return wrap_compound_statement(symbol_table, tmp_statement); + }else{ + + return tmp_statement; + } + }else{ + + tp_free_parse_subtree(symbol_table, &tmp_expression_statement); + TP_POS(symbol_table) = backup_token_position; + return NULL; + } } TP_POS(symbol_table) = backup_token_position; @@ -115,11 +151,21 @@ TP_PARSE_TREE* tp_parse_statement(TP_SYMBOL_TABLE* symbol_table) if (tmp_selection_statement){ - return MAKE_PARSE_SUBTREE( + TP_PARSE_TREE* tmp_statement = MAKE_PARSE_SUBTREE( symbol_table, TP_PARSE_TREE_GRAMMER_C_STATEMENT_4, TP_TREE_NODE(tmp_selection_statement) ); + + if (tmp_statement){ + + return wrap_compound_statement(symbol_table, tmp_statement); + }else{ + + tp_free_parse_subtree(symbol_table, &tmp_selection_statement); + TP_POS(symbol_table) = backup_token_position; + return NULL; + } } TP_POS(symbol_table) = backup_token_position; @@ -131,11 +177,21 @@ TP_PARSE_TREE* tp_parse_statement(TP_SYMBOL_TABLE* symbol_table) if (tmp_iteration_statement){ - return MAKE_PARSE_SUBTREE( + TP_PARSE_TREE* tmp_statement = MAKE_PARSE_SUBTREE( symbol_table, TP_PARSE_TREE_GRAMMER_C_STATEMENT_5, TP_TREE_NODE(tmp_iteration_statement) ); + + if (tmp_statement){ + + return wrap_compound_statement(symbol_table, tmp_statement); + }else{ + + tp_free_parse_subtree(symbol_table, &tmp_iteration_statement); + TP_POS(symbol_table) = backup_token_position; + return NULL; + } } TP_POS(symbol_table) = backup_token_position; @@ -147,11 +203,27 @@ TP_PARSE_TREE* tp_parse_statement(TP_SYMBOL_TABLE* symbol_table) if (tmp_jump_statement){ - return MAKE_PARSE_SUBTREE( + TP_PARSE_TREE* tmp_statement = MAKE_PARSE_SUBTREE( symbol_table, TP_PARSE_TREE_GRAMMER_C_STATEMENT_6, TP_TREE_NODE(tmp_jump_statement) ); + + if (tmp_statement){ + + if (TP_PARSE_WRAP_COMPOUND_STATEMENT == parse_wrap_context){ + + return wrap_compound_statement(symbol_table, tmp_statement); + }else{ + + return tmp_statement; + } + }else{ + + tp_free_parse_subtree(symbol_table, &tmp_jump_statement); + TP_POS(symbol_table) = backup_token_position; + return NULL; + } } TP_POS(symbol_table) = backup_token_position; @@ -241,7 +313,9 @@ static TP_PARSE_TREE* parse_labeled_statement(TP_SYMBOL_TABLE* symbol_table) ++TP_POS(symbol_table); - tmp_statement = tp_parse_statement(symbol_table); + tmp_statement = tp_parse_statement( + symbol_table, TP_PARSE_NONE_WRAP_COMPOUND_STATEMENT + ); if (tmp_statement){ @@ -290,7 +364,8 @@ static TP_PARSE_TREE* parse_labeled_statement(TP_SYMBOL_TABLE* symbol_table) ++TP_POS(symbol_table); - if (tmp_statement = tp_parse_statement(symbol_table)){ + if (tmp_statement = tp_parse_statement( + symbol_table, TP_PARSE_NONE_WRAP_COMPOUND_STATEMENT)){ return MAKE_PARSE_SUBTREE( symbol_table, @@ -342,7 +417,8 @@ static TP_PARSE_TREE* parse_labeled_statement(TP_SYMBOL_TABLE* symbol_table) ++TP_POS(symbol_table); - if (tmp_statement = tp_parse_statement(symbol_table)){ + if (tmp_statement = tp_parse_statement( + symbol_table, TP_PARSE_NONE_WRAP_COMPOUND_STATEMENT)){ return MAKE_PARSE_SUBTREE( symbol_table, @@ -373,6 +449,71 @@ static TP_PARSE_TREE* parse_labeled_statement(TP_SYMBOL_TABLE* symbol_table) return NULL; } +static TP_PARSE_TREE* wrap_compound_statement( + TP_SYMBOL_TABLE* symbol_table, TP_PARSE_TREE* statement) +{ + // compound-statement -> { block-item-list } + // + // block-item-list -> block-item + // + // block-item -> statement + + TP_PARSE_TREE* tmp_block_item1 = NULL; + TP_PARSE_TREE* tmp_block_item_list = NULL; + TP_PARSE_TREE* tmp_statement = NULL; + + if (statement){ + + // Grammer: block-item -> statement + tmp_block_item1 = MAKE_PARSE_SUBTREE( + symbol_table, + TP_PARSE_TREE_GRAMMER_BLOCK_ITEM_2, + TP_TREE_NODE(statement) + ); + + if (tmp_block_item1){ + + // Grammer: block-item-list -> block-item + tmp_block_item_list = MAKE_PARSE_SUBTREE( + symbol_table, + TP_PARSE_TREE_GRAMMER_BLOCK_ITEM_LIST_2, + TP_TREE_NODE(tmp_block_item1) + ); + + if (tmp_block_item_list){ + + TP_TOKEN* tmp_left_curly_bracket = &(symbol_table->member_tp_token[0]); + TP_TOKEN* tmp_right_curly_bracket = &(symbol_table->member_tp_token[1]); + + // Grammer: compound-statement -> { block-item-list } + tmp_statement = MAKE_PARSE_SUBTREE( + symbol_table, + TP_PARSE_TREE_GRAMMER_COMPOUND_STATEMENT_1, + TP_TREE_TOKEN(tmp_left_curly_bracket), + TP_TREE_NODE(tmp_block_item_list), + TP_TREE_TOKEN(tmp_right_curly_bracket) + ); + + if (tmp_statement){ + + // Grammer: statement -> compound-statement + return MAKE_PARSE_SUBTREE( + symbol_table, + TP_PARSE_TREE_GRAMMER_C_STATEMENT_2, + TP_TREE_NODE(tmp_statement), + ); + } + } + } + } + + tp_free_parse_subtree(symbol_table, &tmp_block_item1); + tp_free_parse_subtree(symbol_table, &tmp_block_item_list); + tp_free_parse_subtree(symbol_table, &tmp_statement); + + return NULL; +} + static TP_PARSE_TREE* parse_block_item_list(TP_SYMBOL_TABLE* symbol_table) { TP_TOKEN* backup_token_position = TP_POS(symbol_table); @@ -444,7 +585,9 @@ static TP_PARSE_TREE* parse_block_item(TP_SYMBOL_TABLE* symbol_table) // Grammer: block-item -> statement { - TP_PARSE_TREE* tmp_statement = tp_parse_statement(symbol_table); + TP_PARSE_TREE* tmp_statement = tp_parse_statement( + symbol_table, TP_PARSE_NONE_WRAP_COMPOUND_STATEMENT + ); if (tmp_statement){ @@ -585,7 +728,9 @@ static TP_PARSE_TREE* parse_selection_statement_if( ++TP_POS(symbol_table); - tmp_statement1 = tp_parse_statement(symbol_table); + tmp_statement1 = tp_parse_statement( + symbol_table, TP_PARSE_WRAP_COMPOUND_STATEMENT + ); if (tmp_statement1){ @@ -595,7 +740,9 @@ static TP_PARSE_TREE* parse_selection_statement_if( ++TP_POS(symbol_table); - tmp_statement2 = tp_parse_statement(symbol_table); + tmp_statement2 = tp_parse_statement( + symbol_table, TP_PARSE_WRAP_COMPOUND_STATEMENT + ); if (tmp_statement2){ @@ -689,7 +836,9 @@ static TP_PARSE_TREE* parse_selection_statement_switch( ++TP_POS(symbol_table); - tmp_statement = tp_parse_statement(symbol_table); + tmp_statement = tp_parse_statement( + symbol_table, TP_PARSE_WRAP_COMPOUND_STATEMENT + ); if (tmp_statement){ @@ -774,7 +923,7 @@ static TP_PARSE_TREE* parse_iteration_statement(TP_SYMBOL_TABLE* symbol_table) ++TP_POS(symbol_table); TP_PARSE_TREE* tmp_iteration_statement_do - = parse_iteration_statement_while(symbol_table, tmp_do); + = parse_iteration_statement_do(symbol_table, tmp_do); if (tmp_iteration_statement_do){ @@ -795,7 +944,7 @@ static TP_PARSE_TREE* parse_iteration_statement(TP_SYMBOL_TABLE* symbol_table) ++TP_POS(symbol_table); TP_PARSE_TREE* tmp_iteration_statement_for - = parse_iteration_statement_while(symbol_table, tmp_for); + = parse_iteration_statement_for(symbol_table, tmp_for); if (tmp_iteration_statement_for){ @@ -834,7 +983,9 @@ static TP_PARSE_TREE* parse_iteration_statement_while(TP_SYMBOL_TABLE* symbol_ta ++TP_POS(symbol_table); - tmp_statement = tp_parse_statement(symbol_table); + tmp_statement = tp_parse_statement( + symbol_table, TP_PARSE_WRAP_COMPOUND_STATEMENT + ); if (tmp_statement){ @@ -890,7 +1041,8 @@ static TP_PARSE_TREE* parse_iteration_statement_do(TP_SYMBOL_TABLE* symbol_table TP_PARSE_TREE* tmp_statement = NULL; TP_PARSE_TREE* tmp_expression = NULL; - if (tmp_statement = tp_parse_statement(symbol_table)){ + if (tmp_statement = tp_parse_statement( + symbol_table, TP_PARSE_WRAP_COMPOUND_STATEMENT)){ TP_TOKEN* tmp_while = TP_POS(symbol_table); @@ -1035,7 +1187,8 @@ static TP_PARSE_TREE* parse_iteration_statement_for(TP_SYMBOL_TABLE* symbol_tabl ++TP_POS(symbol_table); - if (tmp_statement = tp_parse_statement(symbol_table)){ + if (tmp_statement = tp_parse_statement( + symbol_table, TP_PARSE_WRAP_COMPOUND_STATEMENT)){ if (tmp_expression1 && tmp_expression2 && tmp_expression3){ diff --git a/src/lib/tp_compiler/tp_make_token/tp_preprocessor.c b/src/lib/tp_compiler/tp_make_token/tp_preprocessor.c index 61c2d98..fdbb052 100644 --- a/src/lib/tp_compiler/tp_make_token/tp_preprocessor.c +++ b/src/lib/tp_compiler/tp_make_token/tp_preprocessor.c @@ -217,6 +217,39 @@ static bool concat_string_literal(TP_SYMBOL_TABLE* symbol_table, TP_TOKEN* prev_ static bool convert_pp_token_to_token(TP_SYMBOL_TABLE* symbol_table, TP_INPUT_FILE* input_file) { + if (false == symbol_table->member_is_int_calc_compiler){ + + TP_TOKEN virtual_token = global_pp_token_template; + + virtual_token.member_file = "insert virtual_token(1).", + virtual_token.member_symbol = TP_SYMBOL_PUNCTUATOR; + virtual_token.member_symbol_kind = TP_SYMBOL_KIND_LEFT_CURLY_BRACKET; + virtual_token.member_string = "{"; + virtual_token.member_string_length = 1; + + if ( ! append_token(symbol_table, &virtual_token)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + + symbol_table->member_is_error_abort = true; + + return false; + } + + virtual_token.member_file = "insert virtual_token(2).", + virtual_token.member_symbol_kind = TP_SYMBOL_KIND_RIGHT_CURLY_BRACKET; + virtual_token.member_string = "}"; + + if ( ! append_token(symbol_table, &virtual_token)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + + symbol_table->member_is_error_abort = true; + + return false; + } + } + for (rsize_t i = 0; input_file->member_tp_pp_token_pos > i; ++i){ TP_TOKEN* token = &(input_file->member_tp_pp_token[i]); diff --git a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C.c b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C.c index 7ad53e2..1a6397e 100644 --- a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C.c +++ b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C.c @@ -167,7 +167,7 @@ bool tp_make_wasm_C_body( symbol_table, entry_point_symbol, section, c_object, &(c_object->member_type.member_body.member_type_compound_statement), - NULL, NULL, NULL, NULL, parameter_num, parameter, NULL)){ + NULL, NULL, type_return, NULL, parameter_num, parameter, NULL)){ TP_PUT_LOG_MSG_TRACE(symbol_table); return false; @@ -203,7 +203,8 @@ bool tp_make_wasm_C_body( symbol_table, entry_point_symbol, section, c_object, &(c_object->member_type.member_body. - member_type_iteration_statement_do))){ + member_type_iteration_statement_do), + type_return, parameter_num, parameter)){ TP_PUT_LOG_MSG_TRACE(symbol_table); return false; diff --git a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C_expr.c b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C_expr.c index 1f736f8..68f0e44 100644 --- a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C_expr.c +++ b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C_expr.c @@ -108,6 +108,14 @@ bool tp_make_wasm_C_expression( c_expr_pos = type_expression_statement->member_c_expr_pos; break; } + case TP_C_TYPE_TYPE_ITERATION_STATEMENT_DO:{ + + TP_C_TYPE_ITERATION_STATEMENT_DO* type_iteration_statement_do = + &(c_type_body->member_type_iteration_statement_do); + c_expr = type_iteration_statement_do->member_c_expr; + c_expr_pos = type_iteration_statement_do->member_c_expr_pos; + break; + } case TP_C_TYPE_TYPE_JUMP_STATEMENT_RETURN:{ TP_C_TYPE_JUMP_STATEMENT_RETURN* type_jump_statement_return = @@ -607,7 +615,23 @@ bool tp_make_wasm_C_expression( TP_PUT_LOG_MSG_ICE(symbol_table); goto fail; - // Comparison operators + // Comparison operators(i32) + case TP_C_EXPR_KIND_I32_NE: // op1 != op2 + TP_MAKE_WASM_NUMERIC_OPERATOR( + symbol_table, index, c_expr, + tp_make_i32_ne_code(section_buffer, index), + TP_WASM_MODULE_SECTION_TYPE_RETURN_TYPE_I32 + ); + break; + + // Comparison operators(i64) + case TP_C_EXPR_KIND_I64_NE: // op1 != op2 + TP_MAKE_WASM_NUMERIC_OPERATOR( + symbol_table, index, c_expr, + tp_make_i64_ne_code(section_buffer, index), + TP_WASM_MODULE_SECTION_TYPE_RETURN_TYPE_I64 + ); + break; // Numeric operators(i32) case TP_C_EXPR_KIND_I32_ADD: @@ -816,6 +840,10 @@ static bool set_containing_function_call_attr( case TP_C_EXPR_KIND_I64_SET_LOCAL_ARG: case TP_C_EXPR_KIND_I32_TEE_LOCAL_ARG: case TP_C_EXPR_KIND_I64_TEE_LOCAL_ARG: + // Comparison operators(i32) + case TP_C_EXPR_KIND_I32_NE: // op1 != op2 + // Comparison operators(i64) + case TP_C_EXPR_KIND_I64_NE: // op1 != op2 // Numeric operators(i32) case TP_C_EXPR_KIND_I32_ADD: case TP_C_EXPR_KIND_I32_SUB: diff --git a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C_statements.c b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C_statements.c index ae3f593..1341ad1 100644 --- a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C_statements.c +++ b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_C_statements.c @@ -5,15 +5,81 @@ // Convert C_IR to WebAssembly(C compiler: statement). +// do statement while ( expression ) ; bool tp_make_wasm_C_iteration_statement_do( TP_SYMBOL_TABLE* symbol_table, uint8_t* entry_point_symbol, TP_WASM_MODULE_SECTION* section, TP_C_OBJECT* c_object, - TP_C_TYPE_ITERATION_STATEMENT_DO* type_iteration_statement_do) + TP_C_TYPE_ITERATION_STATEMENT_DO* type_iteration_statement_do, + TP_C_TYPE* type_return, uint32_t parameter_num, TP_C_TYPE_FUNCTION_F_PARAM* parameter) { - TP_PUT_LOG_MSG_ICE(symbol_table); + TP_PARSE_TREE* expression = type_iteration_statement_do->member_expression; + TP_C_EXPR* c_expr = type_iteration_statement_do->member_c_expr; + TP_C_TYPE* statement = &(type_iteration_statement_do->member_statement->member_type); + + if ((NULL == expression) || (NULL == c_expr) || (NULL == statement)){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + + return false; + } + + { + uint8_t* section_buffer = symbol_table->member_code_section_buffer; + size_t index = symbol_table->member_code_index; + TP_WASM_CODE_BEGIN; + + // do{ + // loop ;; label = @1 + TP_WASM_CODE(symbol_table, index, tp_make_loop_code(section_buffer, index, TP_WASM_BLOCK_TYPE_VOID)); + symbol_table->member_code_index = index; + } + + switch(statement->member_type){ + case TP_C_TYPE_TYPE_COMPOUND_STATEMENT: + if ( ! tp_make_wasm_C_compound_statement( + symbol_table, entry_point_symbol, + section, c_object, + &(type_iteration_statement_do->member_statement->member_type. + member_body.member_type_compound_statement), + NULL, NULL, type_return, NULL, parameter_num, parameter, NULL)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + break; + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + + { + uint8_t* section_buffer = symbol_table->member_code_section_buffer; + size_t index = symbol_table->member_code_index; + TP_WASM_CODE_BEGIN; + + if ( ! tp_make_wasm_C_expression( + symbol_table, c_object, section_buffer, &index)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + + return false; + } + + // }while (expression); + // br_if 0 (;@1;) + TP_WASM_CODE(symbol_table, index, tp_make_br_if_code(section_buffer, index, 0/* relative_depth */)); + // end + TP_WASM_CODE(symbol_table, index, tp_make_end_code(section_buffer, index)); + symbol_table->member_code_index = index; + } + + return true; +fail: return false; } +// Grammer: jump-statement -> return expression ; +// Grammer: jump-statement -> return ; bool tp_make_wasm_C_jump_statement_return( TP_SYMBOL_TABLE* symbol_table, uint8_t* entry_point_symbol, TP_WASM_MODULE_SECTION* section, TP_C_OBJECT* c_object, diff --git a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_expr.c b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_expr.c index 17f01ef..d54d65b 100644 --- a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_expr.c +++ b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_body_expr.c @@ -569,7 +569,7 @@ static bool search_parse_tree( if (TP_PARSE_TREE_TYPE_NODE == element[i].member_type){ if ( ! search_parse_tree( - symbol_table, (TP_PARSE_TREE*)(element[i].member_body.member_child), section, grammer_context)){ + symbol_table, element[i].member_body.member_child, section, grammer_context)){ is_make_section_code_success = false; } diff --git a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_disasm.c b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_disasm.c index 53420a0..6df9fa6 100644 --- a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_disasm.c +++ b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_disasm.c @@ -308,8 +308,12 @@ static bool disasm_wasm_body( case TP_WASM_OPCODE_DROP: // break; - // Comparison operators - case TP_WASM_OPCODE_I64_NE: + // Comparison operators(i32) + case TP_WASM_OPCODE_I32_NE: // op1 != op2 +// break; + + // Comparison operators(i64) + case TP_WASM_OPCODE_I64_NE: // op1 != op2 // break; // Control flow operators @@ -383,7 +387,8 @@ static uint8_t* get_opcode_string(uint32_t wasm_opcode) // Parametric operators case TP_WASM_OPCODE_DROP: return "drop"; // Comparison operators - case TP_WASM_OPCODE_I64_NE: return "i64_ne"; + case TP_WASM_OPCODE_I32_NE: return "i32_ne"; // op1 != op2 + case TP_WASM_OPCODE_I64_NE: return "i64_ne"; // op1 != op2 // Control flow operators case TP_WASM_OPCODE_RETURN: return "return"; case TP_WASM_OPCODE_END: return "end"; diff --git a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_opcode.c b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_opcode.c index 125e4c7..3fc12e3 100644 --- a/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_opcode.c +++ b/src/lib/tp_compiler/tp_make_wasm/tp_make_wasm_opcode.c @@ -175,8 +175,13 @@ uint32_t tp_make_i64_const_code(uint8_t* buffer, size_t offset, int64_t value) TP_MAKE_SLEB128_CODE(buffer, offset, TP_WASM_OPCODE_I64_CONST, value); } -// Comparison operators +// Comparison operators(i32) +uint32_t tp_make_i32_ne_code(uint8_t* buffer, size_t offset) +{ + TP_MAKE_OPCODE(buffer, offset, TP_WASM_OPCODE_I32_NE); // op1 != op2 +} +// Comparison operators(i64) uint32_t tp_make_i64_ne_code(uint8_t* buffer, size_t offset) { TP_MAKE_OPCODE(buffer, offset, TP_WASM_OPCODE_I64_NE); // op1 != op2 diff --git a/src/lib/tp_compiler/tp_make_x64_code/tp_make_x64_code.c b/src/lib/tp_compiler/tp_make_x64_code/tp_make_x64_code.c index 7dcf2fc..e18c49b 100644 --- a/src/lib/tp_compiler/tp_make_x64_code/tp_make_x64_code.c +++ b/src/lib/tp_compiler/tp_make_x64_code/tp_make_x64_code.c @@ -784,7 +784,18 @@ static uint32_t convert_section_code_content2x64( TP_X64_CHECK_CODE_STATUS(symbol_table, status, x64_code_size, tmp_x64_code_size); break; - // Comparison operators + // Comparison operators(i32) + case TP_WASM_OPCODE_I32_NE: // op1 != op2 + op2 = tp_wasm_stack_pop(symbol_table, TP_WASM_STACK_POP_MODE_PARAM, NULL); + op1 = tp_wasm_stack_pop(symbol_table, TP_WASM_STACK_POP_MODE_PARAM, NULL); + tmp_x64_code_size = tp_encode_i32_ne_code( + symbol_table, x64_code_buffer, x64_code_size, + opcode.member_wasm_relocation, &op1, &op2 + ); + TP_X64_CHECK_CODE_SIZE(symbol_table, x64_code_size, tmp_x64_code_size); + break; + + // Comparison operators(i64) case TP_WASM_OPCODE_I64_NE: // op1 != op2 op2 = tp_wasm_stack_pop(symbol_table, TP_WASM_STACK_POP_MODE_PARAM, NULL); op1 = tp_wasm_stack_pop(symbol_table, TP_WASM_STACK_POP_MODE_PARAM, NULL); @@ -873,7 +884,6 @@ static uint32_t calc_padding_and_size( { // Use non-volatile register. uint32_t nv_register_num = 0; - uint32_t nv_rex_num = 0; for (rsize_t i = 0; TP_X64_NV64_REGISTER_NUM > i; ++i){ @@ -882,11 +892,6 @@ static uint32_t calc_padding_and_size( if (TP_X64_NV64_REGISTER_NULL != use_nv_register){ ++nv_register_num; - - if (TP_X64_NV64_REGISTER_R12 <= use_nv_register){ - - ++nv_rex_num; - } } } @@ -899,18 +904,20 @@ static uint32_t calc_padding_and_size( // See tp_encode_allocate_stack function. // x64_code_size += TP_X64_NV64_REGISTER_NUM; - nv_register_num = TP_X64_NV64_REGISTER_NUM - nv_register_num; + uint32_t sub_nv_register_num = (nv_register_num ? + (TP_X64_NV64_REGISTER_NUM - nv_register_num) : + TP_X64_NV64_REGISTER_NUM); TP_PUT_LOG_MSG( (symbol_table), TP_LOG_TYPE_HIDE, - TP_MSG_FMT("Prev. x64_code_size -= nv_register_num; // push register." - "(%1 function: %2): x64_code_size(%3), nv_register_num(%4)"), + TP_MSG_FMT("Prev. x64_code_size -= sub_nv_register_num; // push register." + "(%1 function: %2): x64_code_size(%3), sub_nv_register_num(%4)"), TP_LOG_PARAM_STRING(__func__), TP_LOG_PARAM_UINT64_VALUE(__LINE__), TP_LOG_PARAM_UINT64_VALUE(x64_code_size), - TP_LOG_PARAM_UINT64_VALUE(nv_register_num) + TP_LOG_PARAM_UINT64_VALUE(sub_nv_register_num) ); - x64_code_size -= (nv_register_num + nv_rex_num); // push register. + x64_code_size -= sub_nv_register_num; // push register. } // Temporary variables. @@ -944,13 +951,7 @@ static uint32_t calc_padding_and_size( if (TP_X64_V64_REGISTER_NULL != use_v_register){ - if (TP_X64_V64_REGISTER_R8 <= use_v_register){ - - v_register_num += 2; - }else{ - - ++v_register_num; - } + ++v_register_num; } } diff --git a/src/lib/tp_compiler/tp_make_x64_code/tp_make_x64_code_body.c b/src/lib/tp_compiler/tp_make_x64_code/tp_make_x64_code_body.c index f8eb0af..96310ec 100644 --- a/src/lib/tp_compiler/tp_make_x64_code/tp_make_x64_code_body.c +++ b/src/lib/tp_compiler/tp_make_x64_code/tp_make_x64_code_body.c @@ -1821,7 +1821,24 @@ uint32_t tp_encode_i64_const_code( return x64_code_size; } -// Comparison operators +// Comparison operators(i32) + +uint32_t tp_encode_i32_ne_code( + TP_SYMBOL_TABLE* symbol_table, uint8_t* x64_code_buffer, uint32_t x64_code_offset, + TP_WASM_RELOCATION* wasm_relocation, TP_WASM_STACK_ELEMENT* op1, TP_WASM_STACK_ELEMENT* op2) +{ + uint32_t x64_code_size = 0; + + // NOTE: Call tp_free_register(op2) in tp_encode_sub_code(). + uint32_t tmp_x64_code_size = tp_encode_sub_code( + symbol_table, x64_code_buffer, x64_code_offset, wasm_relocation, op1, op2 + ); + TP_X64_CHECK_CODE_SIZE(symbol_table, x64_code_size, tmp_x64_code_size); + + return x64_code_size; +} + +// Comparison operators(i64) uint32_t tp_encode_i64_ne_code( TP_SYMBOL_TABLE* symbol_table, uint8_t* x64_code_buffer, uint32_t x64_code_offset, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_declarations.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_declarations.c index 3c25e03..e35ce46 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_declarations.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_declarations.c @@ -87,8 +87,7 @@ bool tp_make_C_IR_declaration( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; switch (parse_tree_child_left->member_grammer){ // Grammer: declaration-specifiers -> @@ -104,8 +103,7 @@ bool tp_make_C_IR_declaration( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[1].member_body.member_child; switch (parse_tree_child_right->member_grammer){ // Grammer: init-declarator-list -> init-declarator @@ -159,8 +157,7 @@ bool tp_make_C_IR_declaration( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: declaration-specifiers -> @@ -294,8 +291,7 @@ bool tp_make_C_IR_declaration_specifiers( } } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; switch (parse_tree_child_left->member_grammer){ // Grammer: storage-class-specifier -> extern | static | auto | register @@ -334,8 +330,7 @@ bool tp_make_C_IR_declaration_specifiers( if (TP_PARSE_TREE_GRAMMER_DECLARATION_SPECIFIERS_1 == parse_tree->member_grammer){ - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[1].member_body.member_child; switch (parse_tree_child_right->member_grammer){ // Grammer: declaration-specifiers -> @@ -755,8 +750,7 @@ static bool make_C_IR_init_declarator_list( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: init-declarator -> declarator = initializer @@ -818,8 +812,7 @@ static bool make_C_IR_init_declarator( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; if ( ! tp_make_C_IR_declarator( symbol_table, parse_tree_child_left, grammer_context, c_object, type)){ @@ -828,8 +821,7 @@ static bool make_C_IR_init_declarator( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[2].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[2].member_body.member_child; if ( ! tp_make_C_IR_initializer( symbol_table, @@ -853,8 +845,7 @@ static bool make_C_IR_init_declarator( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: declarator -> direct-declarator diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_declarator.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_declarator.c index 40cee6f..f6aa956 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_declarator.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_declarator.c @@ -28,8 +28,7 @@ bool tp_make_C_IR_declarator( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: direct-declarator -> DirectDeclaratorTmp1 diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_direct_declarator.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_direct_declarator.c index c7f3187..95c1c5d 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_direct_declarator.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_direct_declarator.c @@ -64,8 +64,7 @@ bool tp_make_C_IR_direct_declarator( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: direct-declarator -> DirectDeclaratorTmp1 DirectDeclaratorTmp2+ @@ -126,8 +125,7 @@ static bool make_C_IR_direct_declarator_1( return false; } - TP_PARSE_TREE* parse_tree_child_tmp1 = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_tmp1 = element[0].member_body.member_child; if ( ! make_C_IR_DirectDeclaratorTmp1( symbol_table, @@ -137,8 +135,7 @@ static bool make_C_IR_direct_declarator_1( return false; } - TP_PARSE_TREE* parse_tree_child_tmp2 = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_tmp2 = element[1].member_body.member_child; // Grammer: DirectDeclaratorTmp2 -> ( parameter-type-list ) if (TP_PARSE_TREE_GRAMMER_DIRECT_DECLARATOR_TMP2_PAREN_1 != @@ -311,8 +308,7 @@ static bool make_C_IR_DirectDeclaratorTmp2( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[1].member_body.member_child; // Grammer: parameter-type-list -> parameter-list if (TP_PARSE_TREE_GRAMMER_PARAMETER_TYPE_LIST_2 != @@ -360,8 +356,7 @@ static bool make_C_IR_parameter_type_list( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: parameter-list -> parameter-declaration (, parameter-declaration)+ @@ -428,8 +423,7 @@ static bool make_C_IR_parameter_list( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; switch (parse_tree_child_left->member_grammer){ // Grammer: parameter-list -> parameter-declaration (, parameter-declaration)+ @@ -468,8 +462,7 @@ static bool make_C_IR_parameter_list( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[2].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[2].member_body.member_child; switch (parse_tree_child_right->member_grammer){ // Grammer: parameter-declaration -> declaration-specifiers declarator @@ -512,8 +505,7 @@ static bool make_C_IR_parameter_list( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; // Grammer: parameter-declaration -> declaration-specifiers switch (parse_tree_child->member_grammer){ @@ -593,8 +585,7 @@ static bool make_C_IR_parameter_declaration( goto fail; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; if ( ! tp_make_C_IR_declaration_specifiers( symbol_table, parse_tree_child_left, @@ -615,8 +606,7 @@ static bool make_C_IR_parameter_declaration( goto fail; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[1].member_body.member_child; if ( ! tp_make_C_IR_declarator( symbol_table, parse_tree_child_right, @@ -640,8 +630,7 @@ static bool make_C_IR_parameter_declaration( goto fail; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: declaration-specifiers -> @@ -757,7 +746,7 @@ static bool append_function_formal_param( } arg_type->member_type = TP_C_TYPE_TYPE_BASIC; - arg_type->member_body.\ + arg_type->member_body. member_type_basic.member_type_specifier = type_specifier; TP_C_DECL* c_decl = &(arg_type->member_decl); diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr.c index 2033333..dec319c 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr.c @@ -50,8 +50,7 @@ bool tp_make_C_IR_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_assignment_expression( symbol_table, parse_tree_child, grammer_context, @@ -126,8 +125,7 @@ bool tp_make_C_IR_assignment_expression( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[2].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[2].member_body.member_child; if ( ! tp_make_C_IR_assignment_expression( symbol_table, parse_tree_child_right, TP_GRAMMER_CONTEXT_R_VALUES, @@ -188,8 +186,7 @@ bool tp_make_C_IR_assignment_expression( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; bool is_nesting_expression = ((0 < symbol_table->member_nesting_level_of_expression) || @@ -223,8 +220,7 @@ bool tp_make_C_IR_assignment_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; ++(symbol_table->member_nesting_expression); @@ -493,7 +489,39 @@ bool tp_c_return_type_check( switch (TP_MASK_C_TYPE_SPECIFIER(type_specifier)){ case TP_C_TYPE_SPECIFIER_INT: - // break; +// break; + case TP_C_TYPE_SPECIFIER_LONG1: + type_specifier_expr = TP_C_TYPE_SPECIFIER_INT; + break; + case TP_C_TYPE_SPECIFIER_LONG2: + type_specifier_expr = TP_C_TYPE_SPECIFIER_LONG2; + break; + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + break; + } + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + break; + } + case TP_C_TYPE_TYPE_DECLARATION_STATEMENT:{ + + TP_C_TYPE* type_declaration = + c_type->member_body.member_type_declaration_statement.member_declaration; + + switch (type_declaration->member_type){ + case TP_C_TYPE_TYPE_BASIC:{ + + TP_C_TYPE_SPECIFIER type_specifier = + type_declaration->member_body.member_type_basic.member_type_specifier; + + switch (TP_MASK_C_TYPE_SPECIFIER(type_specifier)){ + case TP_C_TYPE_SPECIFIER_INT: +// break; case TP_C_TYPE_SPECIFIER_LONG1: type_specifier_expr = TP_C_TYPE_SPECIFIER_INT; break; @@ -572,6 +600,14 @@ bool tp_get_type( c_expr_pos = type_expression_statement->member_c_expr_pos; break; } + case TP_C_TYPE_TYPE_ITERATION_STATEMENT_DO:{ + + TP_C_TYPE_ITERATION_STATEMENT_DO* type_iteration_statement_do = + &(c_type_body->member_type_iteration_statement_do); + c_expr = type_iteration_statement_do->member_c_expr; + c_expr_pos = type_iteration_statement_do->member_c_expr_pos; + break; + } case TP_C_TYPE_TYPE_JUMP_STATEMENT_RETURN:{ TP_C_TYPE_JUMP_STATEMENT_RETURN* type_jump_statement_return = @@ -727,6 +763,8 @@ static bool get_type_common( case TP_C_EXPR_KIND_I32_TEE_LOCAL_ARG: // break; case TP_C_EXPR_KIND_I32_CONST: +// break; + case TP_C_EXPR_KIND_I32_NE: // op1 != op2 // break; case TP_C_EXPR_KIND_I32_ADD: // break; @@ -752,6 +790,8 @@ static bool get_type_common( case TP_C_EXPR_KIND_I64_TEE_LOCAL_ARG: // break; case TP_C_EXPR_KIND_I64_CONST: +// break; + case TP_C_EXPR_KIND_I64_NE: // op1 != op2 // break; case TP_C_EXPR_KIND_I64_ADD: // break; @@ -802,6 +842,15 @@ bool tp_append_c_expr( c_expr_size = &(type_expression_statement->member_c_expr_size); break; } + case TP_C_TYPE_TYPE_ITERATION_STATEMENT_DO:{ + + TP_C_TYPE_ITERATION_STATEMENT_DO* type_iteration_statement_do = + &(c_type_body->member_type_iteration_statement_do); + c_expr = &(type_iteration_statement_do->member_c_expr); + c_expr_pos = &(type_iteration_statement_do->member_c_expr_pos); + c_expr_size = &(type_iteration_statement_do->member_c_expr_size); + break; + } case TP_C_TYPE_TYPE_JUMP_STATEMENT_RETURN:{ TP_C_TYPE_JUMP_STATEMENT_RETURN* type_jump_statement_return = diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_cond.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_cond.c index 2a448dc..6820596 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_cond.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_cond.c @@ -31,8 +31,7 @@ bool tp_make_C_IR_conditional_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_logical_OR_expression( symbol_table, parse_tree_child, grammer_context, c_object, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_one_op.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_one_op.c index 68377dc..4eaf837 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_one_op.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_one_op.c @@ -36,8 +36,7 @@ bool tp_make_C_IR_unary_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_postfix_expression( symbol_table, parse_tree_child, grammer_context, c_object, @@ -71,8 +70,7 @@ bool tp_make_C_IR_unary_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[1].member_body.member_child; if ( ! tp_make_C_IR_cast_expression( symbol_table, parse_tree_child, grammer_context, c_object, @@ -139,8 +137,7 @@ bool tp_make_C_IR_cast_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_unary_expression( symbol_table, parse_tree_child, grammer_context, c_object, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_postfix.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_postfix.c index bde67e8..47e48dd 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_postfix.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_postfix.c @@ -48,8 +48,7 @@ bool tp_make_C_IR_postfix_expression( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; is_exec_expr_id = false; @@ -70,8 +69,7 @@ bool tp_make_C_IR_postfix_expression( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[1].member_body.member_child; switch (parse_tree_child_right->member_grammer){ // Grammer: PostfixExpressionTmp1 -> ( argument-expression-list ) @@ -127,8 +125,7 @@ bool tp_make_C_IR_postfix_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_primary_expression( symbol_table, parse_tree_child, grammer_context, @@ -201,8 +198,7 @@ static bool make_C_IR_postfix_expressionTmp1( int32_t func_arg_index_child = TP_WASM_ARG_INDEX_VOID; { - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[1].member_body.member_child; bool is_ignore_ABI = false; @@ -385,8 +381,7 @@ static bool make_C_IR_argument_expression_list( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; switch (parse_tree_child_left->member_grammer){ // Grammer: argument-expression-list -> assignment-expression (, assignment-expression)+ @@ -437,8 +432,7 @@ static bool make_C_IR_argument_expression_list( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[2].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[2].member_body.member_child; if ( ! tp_make_C_IR_assignment_expression( symbol_table, parse_tree_child_right, grammer_context, @@ -472,8 +466,7 @@ static bool make_C_IR_argument_expression_list( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_assignment_expression( symbol_table, parse_tree_child, grammer_context, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_primary.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_primary.c index 085e9d3..6a32612 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_primary.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_primary.c @@ -106,8 +106,7 @@ bool tp_make_C_IR_primary_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[1].member_body.member_child; ++(symbol_table->member_nesting_level_of_expression); diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_arithmetic.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_arithmetic.c index 396318e..c30699f 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_arithmetic.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_arithmetic.c @@ -54,8 +54,7 @@ bool tp_make_C_IR_additive_expression( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; if ( ! tp_make_C_IR_additive_expression( symbol_table, parse_tree_child_left, grammer_context, c_object, @@ -65,8 +64,7 @@ bool tp_make_C_IR_additive_expression( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[2].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[2].member_body.member_child; if ( ! make_C_IR_multiplicative_expression( symbol_table, parse_tree_child_right, grammer_context, c_object, @@ -144,8 +142,7 @@ bool tp_make_C_IR_additive_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! make_C_IR_multiplicative_expression( symbol_table, parse_tree_child, grammer_context, c_object, @@ -212,8 +209,7 @@ static bool make_C_IR_multiplicative_expression( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; if ( ! make_C_IR_multiplicative_expression( symbol_table, parse_tree_child_left, grammer_context, c_object, @@ -223,8 +219,7 @@ static bool make_C_IR_multiplicative_expression( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[2].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[2].member_body.member_child; if ( ! tp_make_C_IR_cast_expression( symbol_table, parse_tree_child_right, grammer_context, c_object, @@ -302,8 +297,7 @@ static bool make_C_IR_multiplicative_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_cast_expression( symbol_table, parse_tree_child, grammer_context, c_object, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_bit.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_bit.c index b7b0642..dce3b0a 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_bit.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_bit.c @@ -43,8 +43,7 @@ bool tp_make_C_IR_inclusive_OR_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! make_C_IR_exclusive_OR_expression( symbol_table, parse_tree_child, grammer_context, c_object, @@ -94,8 +93,7 @@ static bool make_C_IR_exclusive_OR_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! make_C_IR_AND_expression( symbol_table, parse_tree_child, grammer_context, c_object, @@ -145,8 +143,7 @@ static bool make_C_IR_AND_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_equality_expression( symbol_table, parse_tree_child, grammer_context, c_object, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_logical.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_logical.c index 653a538..6067df3 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_logical.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_logical.c @@ -37,8 +37,7 @@ bool tp_make_C_IR_logical_OR_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! make_C_IR_logical_AND_expression( symbol_table, parse_tree_child, grammer_context, c_object, @@ -88,8 +87,7 @@ static bool make_C_IR_logical_AND_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_inclusive_OR_expression( symbol_table, parse_tree_child, grammer_context, c_object, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_other.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_other.c index 630f843..302456d 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_other.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_expr_two_op_other.c @@ -29,6 +29,99 @@ bool tp_make_C_IR_equality_expression( size_t element_num = parse_tree->member_element_num; switch (parse_tree->member_grammer){ + // Grammer: equality-expression -> (relational-expression (== | !=))+ relational-expression + case TP_PARSE_TREE_GRAMMER_EQUALITY_EXPRESSION_1:{ + if (3 != element_num){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + + if ((TP_PARSE_TREE_TYPE_NODE != element[0].member_type) || + (TP_PARSE_TREE_TYPE_TOKEN != element[1].member_type) || + (TP_PARSE_TREE_TYPE_NODE != element[2].member_type)){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + + TP_TOKEN* token = element[1].member_body.member_tp_token; + + // ToDo: + if ( ! (/* IS_TOKEN_DOUBLE_EQUAL(token) || */IS_TOKEN_EXCLAMATION_MARK_EQUAL(token))){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; + + if ( ! make_C_IR_relational_expression( + symbol_table, parse_tree_child_left, grammer_context, c_object, + func_arg_index, is_ignore_ABI, function_call_depth)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + + TP_PARSE_TREE* parse_tree_child_right = element[2].member_body.member_child; + + if ( ! make_C_IR_relational_expression( + symbol_table, parse_tree_child_right, grammer_context, c_object, + func_arg_index, is_ignore_ABI, function_call_depth)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + + // Comparison operators + TP_EXPR_TYPE type1 = TP_EXPR_TYPE_NULL; + + if ( ! tp_get_type(symbol_table, c_object, &type1)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + + TP_C_EXPR c_expr = { 0 }; + + if (TP_EXPR_TYPE_I32 == type1){ + + if (IS_TOKEN_EXCLAMATION_MARK_EQUAL(token)){ + + c_expr.member_c_expr_kind = TP_C_EXPR_KIND_I32_NE; // op1 != op2 + }else{ + + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + }else if (TP_EXPR_TYPE_I64 == type1){ + + if (IS_TOKEN_EXCLAMATION_MARK_EQUAL(token)){ + + c_expr.member_c_expr_kind = TP_C_EXPR_KIND_I64_NE; // op1 != op2 + }else{ + + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + }else{ + + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + c_expr.member_c_expr_body.member_function_arg.member_arg_index = + (is_ignore_ABI ? TP_WASM_ARG_INDEX_VOID : (*func_arg_index)); + c_expr.member_c_expr_body.member_function_arg.member_c_return_type = + (is_ignore_ABI ? NULL : c_object->member_c_return_type_attr); + + if ( ! tp_append_c_expr(symbol_table, c_object, &c_expr)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + break; + } // Grammer: equality-expression -> relational-expression case TP_PARSE_TREE_GRAMMER_EQUALITY_EXPRESSION_2:{ if (1 != element_num){ @@ -43,8 +136,7 @@ bool tp_make_C_IR_equality_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! make_C_IR_relational_expression( symbol_table, parse_tree_child, grammer_context, c_object, @@ -94,8 +186,7 @@ static bool make_C_IR_relational_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! make_C_IR_shift_expression( symbol_table, parse_tree_child, grammer_context, c_object, @@ -145,8 +236,7 @@ static bool make_C_IR_shift_expression( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_additive_expression( symbol_table, parse_tree_child, grammer_context, c_object, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_external_declarations.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_external_declarations.c index d945c91..bb6cd48 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_external_declarations.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_external_declarations.c @@ -55,8 +55,7 @@ bool tp_make_C_IR_external_declaration( goto fail; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: declaration -> declaration-specifiers init-declarator-list ; diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_function_definition.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_function_definition.c index 0ef0eb1..8a55bb1 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_function_definition.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_function_definition.c @@ -19,8 +19,7 @@ bool tp_make_C_IR_function_definition( if (c_object){ TP_PUT_LOG_MSG_ICE(symbol_table); - - goto fail; + return false; } TP_PARSE_TREE_ELEMENT* element = parse_tree->member_element; @@ -35,8 +34,7 @@ bool tp_make_C_IR_function_definition( if (3 != element_num){ TP_PUT_LOG_MSG_ICE(symbol_table); - - goto fail; + return false; } function_definition = @@ -45,8 +43,7 @@ bool tp_make_C_IR_function_definition( if (NULL == function_definition){ TP_PRINT_CRT_ERROR(symbol_table); - - goto fail; + return false; } function_definition->member_type.member_type = TP_C_TYPE_TYPE_FUNCTION; @@ -57,12 +54,10 @@ bool tp_make_C_IR_function_definition( if (TP_PARSE_TREE_TYPE_NODE != element[i].member_type){ TP_PUT_LOG_MSG_ICE(symbol_table); - goto fail; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[i].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[i].member_body.member_child; switch (i){ case 0:{ // declaration-specifiers @@ -145,17 +140,10 @@ bool tp_make_C_IR_function_definition( goto fail; } - TP_C_TYPE_FUNCTION* type_function = - &(function_definition->member_type.member_body.member_type_function); + TP_C_TYPE_COMPOUND_STATEMENT* function_body = + &(function_definition->member_type.member_body.member_type_function.member_function_body); - type_function->member_function_body.member_c_return_type = - type_function->member_c_return_type; - - type_function->member_function_body.member_function_parameter = - function_definition->member_function_parameter_attr; - - type_function->member_function_body.member_function_parameter_num = - function_definition->member_function_parameter_num_attr; + TP_C_INHERIT_ATTR_TO_FUNCTION_BODY_FROM_C_OBJECT(function_body, function_definition); if ( ! tp_make_C_IR_statements( symbol_table, parse_tree_child, grammer_context, function_definition)){ @@ -174,17 +162,19 @@ bool tp_make_C_IR_function_definition( if ( ! tp_append_c_object(symbol_table, function_definition)){ TP_PUT_LOG_MSG_TRACE(symbol_table); - - goto fail; + return false; } - return true; +fail: + if ( ! tp_append_c_object(symbol_table, function_definition)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + } + return false; } TP_PUT_LOG_MSG_ICE(symbol_table); -fail: - tp_free_c_object(symbol_table, &function_definition); - tp_free_c_object(symbol_table, &return_object); + return false; } diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_initializer.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_initializer.c index 31674dc..e67569c 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_initializer.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_initializer.c @@ -28,8 +28,7 @@ bool tp_make_C_IR_initializer( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: assignment-expression -> unary-expression assignment-operator assignment-expression diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements.c index 9eb27cb..a11cc23 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements.c @@ -52,8 +52,7 @@ bool tp_make_C_IR_statements( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: compound-statement -> { block-item-list } @@ -94,8 +93,7 @@ bool tp_make_C_IR_statements( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: expression-statement -> expression ; @@ -116,6 +114,32 @@ bool tp_make_C_IR_statements( } break; } + // Grammer: statement -> iteration-statement + case TP_PARSE_TREE_GRAMMER_C_STATEMENT_5:{ + if (1 != element_num){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; + + switch (parse_tree_child->member_grammer){ + // Grammer: iteration-statement -> do statement while ( expression ) ; + case TP_PARSE_TREE_GRAMMER_ITERATION_STATEMENT_DO_1: + break; + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + if ( ! tp_make_C_IR_iteration_statement( + symbol_table, parse_tree_child, grammer_context, c_object)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + break; + } // Grammer: statement -> jump-statement case TP_PARSE_TREE_GRAMMER_C_STATEMENT_6:{ if (1 != element_num){ @@ -124,8 +148,7 @@ bool tp_make_C_IR_statements( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: jump-statement -> return expression ; @@ -162,12 +185,12 @@ bool tp_append_c_object_to_compound_statement( switch (parent_c_object->member_type.member_type){ case TP_C_TYPE_TYPE_FUNCTION: compound_statement = - &(parent_c_object->member_type.\ + &(parent_c_object->member_type. member_body.member_type_function.member_function_body); break; case TP_C_TYPE_TYPE_COMPOUND_STATEMENT: compound_statement = - &(parent_c_object->member_type.\ + &(parent_c_object->member_type. member_body.member_type_compound_statement); break; default: @@ -270,13 +293,13 @@ static bool make_C_IR_compound_statement( // C compiler(Statements: compound-statement) TP_C_OBJECT* compound_statement = NULL; - bool is_push_c_namespace_stack = false; + + bool is_skip_append_c_object_to_compound_statement = true; if (NULL == c_object){ TP_PUT_LOG_MSG_ICE(symbol_table); - - goto fail; + return false; } switch (grammer_context){ @@ -290,16 +313,18 @@ static bool make_C_IR_compound_statement( if (NULL == compound_statement){ TP_PRINT_CRT_ERROR(symbol_table); - goto fail; + return false; } compound_statement->member_type.member_type = TP_C_TYPE_TYPE_COMPOUND_STATEMENT; + + is_skip_append_c_object_to_compound_statement = false; break; } default: TP_PUT_LOG_MSG_ICE(symbol_table); - goto fail; + return false; } TP_PARSE_TREE_ELEMENT* element = parse_tree->member_element; @@ -309,6 +334,9 @@ static bool make_C_IR_compound_statement( switch (parse_tree->member_grammer){ // Grammer: compound-statement -> { block-item-list } case TP_PARSE_TREE_GRAMMER_COMPOUND_STATEMENT_1:{ + + bool is_push_c_namespace_stack = false; + if (3 != element_num){ TP_PUT_LOG_MSG_ICE(symbol_table); @@ -328,8 +356,7 @@ static bool make_C_IR_compound_statement( goto fail; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[1].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: block-item-list -> block-item block-item+ @@ -368,7 +395,7 @@ static bool make_C_IR_compound_statement( switch (compound_statement->member_type.member_type){ case TP_C_TYPE_TYPE_COMPOUND_STATEMENT: child_compound_statement = - &(compound_statement->member_type.\ + &(compound_statement->member_type. member_body.member_type_compound_statement); break; default: @@ -381,34 +408,42 @@ member_body.member_type_compound_statement); switch (c_object->member_type.member_type){ case TP_C_TYPE_TYPE_FUNCTION: parent_compound_statement = - &(c_object->member_type.\ + &(c_object->member_type. member_body.member_type_function.member_function_body); break; case TP_C_TYPE_TYPE_COMPOUND_STATEMENT: parent_compound_statement = - &(c_object->member_type.\ + &(c_object->member_type. member_body.member_type_compound_statement); break; + case TP_C_TYPE_TYPE_ITERATION_STATEMENT_DO: + c_object->member_type.member_body. +member_type_iteration_statement_do.member_statement = compound_statement; + break; default: TP_PUT_LOG_MSG_ICE(symbol_table); goto fail; } - child_compound_statement->member_function_parameter = - parent_compound_statement->member_function_parameter; + if (parent_compound_statement){ - child_compound_statement->member_function_parameter_num = - parent_compound_statement->member_function_parameter_num; + TP_C_INHERIT_ATTR_TO_COMPOUND_STATEMENT_FROM_COMPOUND_STATEMENT( + child_compound_statement, parent_compound_statement + ); - child_compound_statement->member_c_return_type = - parent_compound_statement->member_c_return_type; + if (!tp_append_c_object_to_compound_statement( + symbol_table, c_object, compound_statement)){ - if ( ! tp_append_c_object_to_compound_statement( - symbol_table, c_object, compound_statement)){ + TP_PUT_LOG_MSG_TRACE(symbol_table); + goto fail; + } + }else{ - TP_PUT_LOG_MSG_TRACE(symbol_table); - goto fail; + TP_C_INHERIT_ATTR_TO_COMPOUND_STATEMENT_FROM_C_OBJECT( + child_compound_statement, c_object + ); } + is_skip_append_c_object_to_compound_statement = true; } if ( ! make_C_IR_block_item_list( @@ -424,53 +459,57 @@ member_body.member_type_compound_statement); symbol_table, TP_GRAMMER_CONTEXT_STATEMENTS)){ TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + return true; +fail: + if ( ! is_skip_append_c_object_to_compound_statement){ - is_push_c_namespace_stack = false; - goto fail; + if ( ! tp_append_c_object_to_compound_statement( + symbol_table, c_object, compound_statement)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + } } - break; + if (is_push_c_namespace_stack){ + + if ( ! tp_pop_c_namespace_stack( + symbol_table, TP_GRAMMER_CONTEXT_STATEMENTS)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + }else{ + + is_push_c_namespace_stack = false; + } + } + return false; } // Grammer: compound-statement -> { } case TP_PARSE_TREE_GRAMMER_COMPOUND_STATEMENT_2: if (2 != element_num){ TP_PUT_LOG_MSG_ICE(symbol_table); - goto fail; + return false; } if ((TP_PARSE_TREE_TYPE_TOKEN != element[0].member_type) || (TP_PARSE_TREE_TYPE_TOKEN != element[1].member_type)){ TP_PUT_LOG_MSG_ICE(symbol_table); - goto fail; + return false; } if (( ! IS_TOKEN_LEFT_CURLY_BRACKET(element[0].member_body.member_tp_token)) || ( ! IS_TOKEN_RIGHT_CURLY_BRACKET(element[1].member_body.member_tp_token))){ TP_PUT_LOG_MSG_ICE(symbol_table); - goto fail; + return false; } break; default: TP_PUT_LOG_MSG_ICE(symbol_table); - goto fail; + return false; } return true; -fail: - TP_FREE(symbol_table, &compound_statement, sizeof(TP_C_OBJECT)); - - if (is_push_c_namespace_stack){ - - if ( ! tp_pop_c_namespace_stack( - symbol_table, TP_GRAMMER_CONTEXT_STATEMENTS)){ - - TP_PUT_LOG_MSG_TRACE(symbol_table); - }else{ - - is_push_c_namespace_stack = false; - } - } - return false; } static bool register_function_formal_param( @@ -629,8 +668,7 @@ static bool make_C_IR_block_item_list( for (size_t i = 0; 2 > i; ++i){ - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[i].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[i].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: block-item-list -> block-item block-item+ @@ -673,8 +711,7 @@ static bool make_C_IR_block_item_list( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree_child->member_grammer){ // Grammer: block-item -> declaration @@ -727,8 +764,7 @@ static bool make_C_IR_block_item( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; switch (parse_tree->member_grammer){ // Grammer: block-item -> declaration @@ -760,6 +796,9 @@ static bool make_C_IR_block_item( // Grammer: statement -> expression-statement case TP_PARSE_TREE_GRAMMER_C_STATEMENT_3: break; + // Grammer: statement -> iteration-statement + case TP_PARSE_TREE_GRAMMER_C_STATEMENT_5: + break; // Grammer: statement -> jump-statement case TP_PARSE_TREE_GRAMMER_C_STATEMENT_6: break; diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_expr.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_expr.c index 29654b7..5b95c68 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_expr.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_expr.c @@ -74,8 +74,7 @@ bool tp_make_C_IR_expression_statement( goto fail; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; // Grammer: expression -> assignment-expression if (TP_PARSE_TREE_GRAMMER_C_EXPRESSION_2 != @@ -87,12 +86,12 @@ bool tp_make_C_IR_expression_statement( expression_statement->member_type.member_type = TP_C_TYPE_TYPE_EXPRESSION_STATEMENT; - expression_statement->member_type.member_body.\ + expression_statement->member_type.member_body. member_type_expression_statement.member_expression = parse_tree_child; - expression_statement->member_function_parameter_num_attr = - c_object->member_function_parameter_num_attr; - expression_statement->member_function_parameter_attr = - c_object->member_function_parameter_attr; + + TP_C_INHERIT_ATTR_TO_C_OBJECT_FROM_C_OBJECT( + expression_statement, c_object + ); int32_t func_arg_index = TP_WASM_ARG_INDEX_VOID; bool is_ignore_ABI = false; diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_iteration.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_iteration.c new file mode 100644 index 0000000..d9e75e0 --- /dev/null +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_iteration.c @@ -0,0 +1,279 @@ + +// (C) Shin'ichi Ichikawa. Released under the MIT license. + +#include "../tp_compiler.h" + +// Convert parse tree to C IR(statements: iteration_statement). + +static bool make_C_IR_iteration_statement_do( + TP_SYMBOL_TABLE* symbol_table, + TP_PARSE_TREE* parse_tree, TP_GRAMMER_CONTEXT grammer_context, + TP_C_OBJECT* c_object, TP_C_TYPE_COMPOUND_STATEMENT* compound_statement, + TP_C_OBJECT* iteration_statement_do +); + +bool tp_make_C_IR_iteration_statement( + TP_SYMBOL_TABLE* symbol_table, + TP_PARSE_TREE* parse_tree, TP_GRAMMER_CONTEXT grammer_context, + TP_C_OBJECT* c_object) +{ + // C compiler(Statements: iteration_statement) + TP_C_OBJECT* iteration_statement = NULL; + + if (NULL == c_object){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + + goto fail; + } + + switch (grammer_context){ + case TP_GRAMMER_CONTEXT_STATEMENTS: + break; + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + + TP_C_TYPE_COMPOUND_STATEMENT* compound_statement = NULL; + + switch (c_object->member_type.member_type){ + case TP_C_TYPE_TYPE_FUNCTION: + compound_statement = + &(c_object->member_type. +member_body.member_type_function.member_function_body); + break; + case TP_C_TYPE_TYPE_COMPOUND_STATEMENT: + compound_statement = + &(c_object->member_type. +member_body.member_type_compound_statement); + break; + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + + switch (c_object->member_type.member_type){ + case TP_C_TYPE_TYPE_FUNCTION: +// break; + case TP_C_TYPE_TYPE_COMPOUND_STATEMENT:{ + + iteration_statement = + (TP_C_OBJECT*)TP_CALLOC(symbol_table, 1, sizeof(TP_C_OBJECT)); + + if (NULL == iteration_statement){ + + TP_PRINT_CRT_ERROR(symbol_table); + goto fail; + } + + switch (parse_tree->member_grammer){ + // Grammer: iteration-statement -> do statement while ( expression ) ; + case TP_PARSE_TREE_GRAMMER_ITERATION_STATEMENT_DO_1: + if ( ! make_C_IR_iteration_statement_do( + symbol_table, parse_tree, grammer_context, + c_object, compound_statement, iteration_statement)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + goto fail; + } + break; + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + break; + } + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + + if ( ! tp_append_c_object_to_compound_statement( + symbol_table, c_object, iteration_statement)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + + return true; + +fail: + if ( ! tp_append_c_object_to_compound_statement( + symbol_table, c_object, iteration_statement)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + } + + return false; +} + +static bool make_C_IR_iteration_statement_do( + TP_SYMBOL_TABLE* symbol_table, + TP_PARSE_TREE* parse_tree, TP_GRAMMER_CONTEXT grammer_context, + TP_C_OBJECT* c_object, TP_C_TYPE_COMPOUND_STATEMENT* compound_statement, + TP_C_OBJECT* iteration_statement_do) +{ + TP_PARSE_TREE_ELEMENT* element = parse_tree->member_element; + + size_t element_num = parse_tree->member_element_num; + + switch (parse_tree->member_grammer){ + // Grammer: iteration-statement -> do statement while ( expression ) ; + case TP_PARSE_TREE_GRAMMER_ITERATION_STATEMENT_DO_1:{ + + symbol_table->member_nesting_level_of_expression = 0; + symbol_table->member_nesting_expression = 0; + + if (7 != parse_tree->member_element_num){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + if ((TP_PARSE_TREE_TYPE_TOKEN != element[0].member_type) || + ( ! IS_TOKEN_KEYWORD_DO(element[0].member_body.member_tp_token))){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + if (TP_PARSE_TREE_TYPE_NODE != element[1].member_type){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + if ((TP_PARSE_TREE_TYPE_TOKEN != element[2].member_type) || + ( ! IS_TOKEN_KEYWORD_WHILE(element[2].member_body.member_tp_token))){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + if ((TP_PARSE_TREE_TYPE_TOKEN != element[3].member_type) || + ( ! IS_TOKEN_LEFT_PAREN(element[3].member_body.member_tp_token))){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + if (TP_PARSE_TREE_TYPE_NODE != element[4].member_type){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + + TP_PARSE_TREE* parse_tree_child_expression = element[4].member_body.member_child; + + // Grammer: expression -> assignment-expression + if (TP_PARSE_TREE_GRAMMER_C_EXPRESSION_2 != + parse_tree_child_expression->member_grammer){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + if ((TP_PARSE_TREE_TYPE_TOKEN != element[5].member_type) || + ( ! IS_TOKEN_RIGHT_PAREN(element[5].member_body.member_tp_token))){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + if ((TP_PARSE_TREE_TYPE_TOKEN != element[6].member_type) || + ( ! IS_TOKEN_SEMICOLON(element[6].member_body.member_tp_token))){ + + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + + iteration_statement_do->member_type.member_type = + TP_C_TYPE_TYPE_ITERATION_STATEMENT_DO; + + iteration_statement_do->member_type.member_body. +member_type_iteration_statement_do.member_expression = parse_tree_child_expression; + + TP_C_INHERIT_ATTR_TO_C_OBJECT_FROM_COMPOUND_STATEMENT( + iteration_statement_do, compound_statement + ); + + TP_PARSE_TREE* parse_tree_child_statement = element[1].member_body.member_child; + + switch (parse_tree_child_statement->member_grammer){ + // Grammer: statement -> compound-statement + case TP_PARSE_TREE_GRAMMER_C_STATEMENT_2: + if ( ! tp_make_C_IR_statements( + symbol_table, parse_tree_child_statement, + grammer_context, iteration_statement_do)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + goto fail; + } + break; + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + + int32_t func_arg_index = TP_WASM_ARG_INDEX_VOID; + bool is_ignore_ABI = true; + uint32_t function_call_depth = 0; + + if ( ! tp_make_C_IR_expression( + symbol_table, parse_tree_child_expression, grammer_context, + iteration_statement_do, NULL, + &func_arg_index, is_ignore_ABI, &function_call_depth)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + goto fail; + } + + TP_EXPR_TYPE type1 = TP_EXPR_TYPE_NULL; + + if ( ! tp_get_type(symbol_table, iteration_statement_do, &type1)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + + TP_C_EXPR c_expr_op2 = { 0 }; + TP_C_EXPR c_expr_operator = { 0 }; + + switch (type1){ + case TP_EXPR_TYPE_I32: + c_expr_op2.member_c_expr_kind = TP_C_EXPR_KIND_I32_CONST; + c_expr_op2.member_c_expr_body. +member_i32_const.member_function_arg.member_arg_index = TP_WASM_ARG_INDEX_VOID; + if ( ! tp_append_c_expr(symbol_table, iteration_statement_do, &c_expr_op2)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + c_expr_operator.member_c_expr_kind = TP_C_EXPR_KIND_I32_NE; // op1 != op2 + break; + case TP_EXPR_TYPE_I64: + c_expr_op2.member_c_expr_kind = TP_C_EXPR_KIND_I64_CONST; + c_expr_op2.member_c_expr_body. +member_i64_const.member_function_arg.member_arg_index = TP_WASM_ARG_INDEX_VOID; + if ( ! tp_append_c_expr(symbol_table, iteration_statement_do, &c_expr_op2)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + c_expr_operator.member_c_expr_kind = TP_C_EXPR_KIND_I64_NE; // op1 != op2 + break; + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + return false; + } + if ( ! tp_append_c_expr(symbol_table, iteration_statement_do, &c_expr_operator)){ + + TP_PUT_LOG_MSG_TRACE(symbol_table); + return false; + } + break; + } + default: + TP_PUT_LOG_MSG_ICE(symbol_table); + goto fail; + } + + return true; +fail: + return false; +} + diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_jump.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_jump.c index 39f4a05..d5959e9 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_jump.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_statements_jump.c @@ -34,12 +34,12 @@ bool tp_make_C_IR_jump_statement( switch (c_object->member_type.member_type){ case TP_C_TYPE_TYPE_FUNCTION: compound_statement = - &(c_object->member_type.\ + &(c_object->member_type. member_body.member_type_function.member_function_body); break; case TP_C_TYPE_TYPE_COMPOUND_STATEMENT: compound_statement = - &(c_object->member_type.\ + &(c_object->member_type. member_body.member_type_compound_statement); break; default: @@ -103,8 +103,7 @@ member_body.member_type_compound_statement); goto fail; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[1].member_body.member_child; // Grammer: expression -> assignment-expression if (TP_PARSE_TREE_GRAMMER_C_EXPRESSION_2 != @@ -117,21 +116,16 @@ member_body.member_type_compound_statement); jump_statement_return->member_type.member_type = TP_C_TYPE_TYPE_JUMP_STATEMENT_RETURN; - jump_statement_return->member_type.member_body.\ + jump_statement_return->member_type.member_body. member_type_jump_statement_return.member_expression = parse_tree_child; - jump_statement_return->member_type.member_body.\ + jump_statement_return->member_type.member_body. member_type_jump_statement_return.member_c_return_type = - compound_statement->member_c_return_type; - - jump_statement_return->member_c_return_type_attr = - compound_statement->member_c_return_type; - - jump_statement_return->member_function_parameter_attr = - compound_statement->member_function_parameter; + compound_statement->member_c_return_type_attr; - jump_statement_return->member_function_parameter_num_attr = - compound_statement->member_function_parameter_num; + TP_C_INHERIT_ATTR_TO_C_OBJECT_FROM_COMPOUND_STATEMENT( + jump_statement_return, compound_statement + ); int32_t func_arg_index = TP_WASM_ARG_INDEX_VOID; bool is_ignore_ABI = false; diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_translation_unit.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_translation_unit.c index be0058b..8bb30bf 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_translation_unit.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_make_C_IR_translation_unit.c @@ -36,7 +36,7 @@ bool tp_make_C_IR_translation_unit( if (TP_PARSE_TREE_TYPE_NODE == element[i].member_type){ - TP_PARSE_TREE* parse_tree_child = (TP_PARSE_TREE*)(element[i].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[i].member_body.member_child; switch (grammer_context){ case TP_GRAMMER_CONTEXT_TRANSLATION_UNIT: @@ -105,8 +105,7 @@ static bool make_C_IR_translation_unit_body( return false; } - TP_PARSE_TREE* parse_tree_child_left = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_left = element[0].member_body.member_child; if ( ! tp_make_C_IR_translation_unit( symbol_table, @@ -117,8 +116,7 @@ static bool make_C_IR_translation_unit_body( return false; } - TP_PARSE_TREE* parse_tree_child_right = - (TP_PARSE_TREE*)(element[1].member_body.member_child); + TP_PARSE_TREE* parse_tree_child_right = element[1].member_body.member_child; if ( ! tp_make_C_IR_translation_unit( symbol_table, @@ -138,8 +136,7 @@ static bool make_C_IR_translation_unit_body( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_translation_unit( symbol_table, @@ -158,8 +155,7 @@ static bool make_C_IR_translation_unit_body( return false; } - TP_PARSE_TREE* parse_tree_child = - (TP_PARSE_TREE*)(element[0].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[0].member_body.member_child; if ( ! tp_make_C_IR_function_definition( symbol_table, diff --git a/src/lib/tp_compiler/tp_semantic_analysis/tp_semantic_analysis.c b/src/lib/tp_compiler/tp_semantic_analysis/tp_semantic_analysis.c index 2100343..f1ed551 100644 --- a/src/lib/tp_compiler/tp_semantic_analysis/tp_semantic_analysis.c +++ b/src/lib/tp_compiler/tp_semantic_analysis/tp_semantic_analysis.c @@ -279,7 +279,7 @@ static bool search_parse_tree( if (TP_PARSE_TREE_TYPE_NODE == element[i].member_type){ - TP_PARSE_TREE* parse_tree_child = (TP_PARSE_TREE*)(element[i].member_body.member_child); + TP_PARSE_TREE* parse_tree_child = element[i].member_body.member_child; if ( ! search_parse_tree(symbol_table, parse_tree_child, grammer_context)){ diff --git a/src/tenpoku-dev/tenpoku-dev.vcxproj b/src/tenpoku-dev/tenpoku-dev.vcxproj index fb627ca..937cfbf 100644 --- a/src/tenpoku-dev/tenpoku-dev.vcxproj +++ b/src/tenpoku-dev/tenpoku-dev.vcxproj @@ -20,7 +20,7 @@ Application true - v142 + v143 Unicode false @@ -51,6 +51,8 @@ true ProgramDatabase /source-charset:utf-8 %(AdditionalOptions) + stdcpp20 + stdc17 Console