From 424af172b7ecea974cf04f22c41aa49a29b94230 Mon Sep 17 00:00:00 2001 From: shenao78 Date: Thu, 2 Sep 2021 18:30:30 +0800 Subject: [PATCH 1/3] fix block grammar --- compiler/create.c | 3 + compiler/fix_tree.c | 663 ++++++++++++++++---------------------------- compiler/grammar.y | 4 +- 3 files changed, 250 insertions(+), 420 deletions(-) diff --git a/compiler/create.c b/compiler/create.c index bfee384..0a03199 100644 --- a/compiler/create.c +++ b/compiler/create.c @@ -233,13 +233,16 @@ Block *open_block() Block *new_block; Compiler *compiler = get_current_compiler(); new_block = alloc_block(NULL); + printf("open:%p\n", new_block); new_block->outer_block = compiler->current_block; +// printf("open out:%p\n", compiler->current_block); compiler->current_block = new_block; return new_block; } Block *close_block(Block *block, StatementList *stmt_list) { + printf("close:%p\n", block); Compiler *compiler = get_current_compiler(); block->statement_list = stmt_list; compiler->current_block = block->outer_block; diff --git a/compiler/fix_tree.c b/compiler/fix_tree.c index 16a275f..946b269 100644 --- a/compiler/fix_tree.c +++ b/compiler/fix_tree.c @@ -6,18 +6,18 @@ #include "../include/DBG.h" extern BuiltinFun *search_builtin_function(char *name); + static Expression *fix_expression(Block *current_block, Expression *expr); + static void fix_statement_list(Block *current_block, StatementList *list, FuncDefinition *fd); static Expression * -fix_identifier_expression(Block *current_block, Expression *expr) -{ +fix_identifier_expression(Block *current_block, Expression *expr) { Declaration *decl; BuiltinFun *builtin_func; decl = search_declaration(expr->u.identifier->name, current_block); - if (decl) - { + if (decl) { expr->type = decl->type; expr->u.identifier->kind = VARIABLE_IDENTIFIER; expr->u.identifier->u.declaration = decl; @@ -25,8 +25,7 @@ fix_identifier_expression(Block *current_block, Expression *expr) } builtin_func = search_builtin_function(expr->u.identifier->name); - if (builtin_func == NULL) - { + if (builtin_func == NULL) { compile_error(expr->line_number, IDENTIFIER_NOT_FOUND_ERR, STRING_MESSAGE_ARGUMENT, "name", @@ -43,36 +42,23 @@ fix_identifier_expression(Block *current_block, Expression *expr) } static Expression * -eval_math_expression_int(Expression *expr, int left, int right) -{ - if (expr->kind == ADD_EXPRESSION) - { +eval_math_expression_int(Expression *expr, int left, int right) { + if (expr->kind == ADD_EXPRESSION) { expr->u.int_value = left + right; - } - else if (expr->kind == SUB_EXPRESSION) - { + } else if (expr->kind == SUB_EXPRESSION) { expr->u.int_value = left - right; - } - else if (expr->kind == MUL_EXPRESSION) - { + } else if (expr->kind == MUL_EXPRESSION) { expr->u.int_value = left * right; - } - else if (expr->kind == DIV_EXPRESSION) - { - if (right == 0) - { + } else if (expr->kind == DIV_EXPRESSION) { + if (right == 0) { compile_error(expr->line_number, DIVISION_BY_ZERO_IN_COMPILE_ERR, MESSAGE_ARGUMENT_END); } expr->u.int_value = left / right; - } - else if (expr->kind == MOD_EXPRESSION) - { + } else if (expr->kind == MOD_EXPRESSION) { expr->u.int_value = left % right; - } - else - { + } else { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } expr->kind = INT_EXPRESSION; @@ -81,30 +67,18 @@ eval_math_expression_int(Expression *expr, int left, int right) } static Expression * -eval_math_expression_double(Expression *expr, double left, double right) -{ - if (expr->kind == ADD_EXPRESSION) - { +eval_math_expression_double(Expression *expr, double left, double right) { + if (expr->kind == ADD_EXPRESSION) { expr->u.double_value = left + right; - } - else if (expr->kind == SUB_EXPRESSION) - { + } else if (expr->kind == SUB_EXPRESSION) { expr->u.double_value = left - right; - } - else if (expr->kind == MUL_EXPRESSION) - { + } else if (expr->kind == MUL_EXPRESSION) { expr->u.double_value = left * right; - } - else if (expr->kind == DIV_EXPRESSION) - { + } else if (expr->kind == DIV_EXPRESSION) { expr->u.double_value = left / right; - } - else if (expr->kind == MOD_EXPRESSION) - { + } else if (expr->kind == MOD_EXPRESSION) { expr->u.double_value = fmod(left, right); - } - else - { + } else { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } expr->kind = DOUBLE_EXPRESSION; @@ -113,8 +87,7 @@ eval_math_expression_double(Expression *expr, double left, double right) } static Expression * -chain_string(Expression *expr) -{ +chain_string(Expression *expr) { char *left_str = expr->u.binary_expression->left->u.str_value; char *right_str = expr->u.binary_expression->right->u.str_value; @@ -131,70 +104,53 @@ chain_string(Expression *expr) } static Expression * -eval_math_expression(Block *current_block, Expression *expr) -{ +eval_math_expression(Block *current_block, Expression *expr) { ExpressionKind left_kind = expr->u.binary_expression->left->kind; ExpressionKind right_kind = expr->u.binary_expression->right->kind; - if (left_kind == INT_EXPRESSION && right_kind == INT_EXPRESSION) - { + if (left_kind == INT_EXPRESSION && right_kind == INT_EXPRESSION) { expr = eval_math_expression_int(expr, expr->u.binary_expression->left - ->u.int_value, + ->u.int_value, expr->u.binary_expression->right - ->u.int_value); - } - else if ((left_kind == DOUBLE_EXPRESSION && right_kind == DOUBLE_EXPRESSION) || - (left_kind == DOUBLE_EXPRESSION && right_kind == INT_EXPRESSION) || - (left_kind == INT_EXPRESSION && right_kind == DOUBLE_EXPRESSION)) - { + ->u.int_value); + } else if ((left_kind == DOUBLE_EXPRESSION && right_kind == DOUBLE_EXPRESSION) || + (left_kind == DOUBLE_EXPRESSION && right_kind == INT_EXPRESSION) || + (left_kind == INT_EXPRESSION && right_kind == DOUBLE_EXPRESSION)) { double left_value = expr->u.binary_expression->left->u.double_value; - if (left_kind == INT_EXPRESSION) - { + if (left_kind == INT_EXPRESSION) { left_value = expr->u.binary_expression->left->u.int_value; } double right_value = expr->u.binary_expression->right->u.double_value; - if (right_kind == INT_EXPRESSION) - { + if (right_kind == INT_EXPRESSION) { right_value = expr->u.binary_expression->right->u.int_value; } expr = eval_math_expression_double(expr, left_value, right_value); - } - else if (left_kind == STRING_EXPRESSION && right_kind == STRING_EXPRESSION && expr->kind == ADD_EXPRESSION) - { + } else if (left_kind == STRING_EXPRESSION && right_kind == STRING_EXPRESSION && expr->kind == ADD_EXPRESSION) { expr = chain_string(expr); } return expr; } static Expression * -fix_math_binary_expression(Block *current_block, Expression *expr) -{ +fix_math_binary_expression(Block *current_block, Expression *expr) { expr->u.binary_expression->left = fix_expression(current_block, expr->u.binary_expression->left); expr->u.binary_expression->right = fix_expression(current_block, expr->u.binary_expression->right); expr = eval_math_expression(current_block, expr); - if (expr->kind == INT_EXPRESSION || expr->kind == DOUBLE_EXPRESSION || expr->kind == STRING_EXPRESSION) - { + if (expr->kind == INT_EXPRESSION || expr->kind == DOUBLE_EXPRESSION || expr->kind == STRING_EXPRESSION) { return expr; } BasicType left_type = expr->u.binary_expression->left->type->basic_type; BasicType right_type = expr->u.binary_expression->right->type->basic_type; - if (left_type == INT_TYPE && right_type == INT_TYPE) - { + if (left_type == INT_TYPE && right_type == INT_TYPE) { expr->type = alloc_type_specifier(INT_TYPE); - } - else if (left_type == DOUBLE_TYPE && right_type == DOUBLE_TYPE) - { + } else if (left_type == DOUBLE_TYPE && right_type == DOUBLE_TYPE) { expr->type = alloc_type_specifier(DOUBLE_TYPE); - } - else if (expr->kind == ADD_EXPRESSION && left_type == STRING_TYPE && right_type == STRING_TYPE) - { + } else if (expr->kind == ADD_EXPRESSION && left_type == STRING_TYPE && right_type == STRING_TYPE) { expr->type = alloc_type_specifier(STRING_TYPE); - } - else - { + } else { compile_error(expr->line_number, MATH_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -204,18 +160,12 @@ fix_math_binary_expression(Block *current_block, Expression *expr) static Expression * eval_compare_expression_boolean(Expression *expr, - bool left, bool right) -{ - if (expr->kind == EQ_EXPRESSION) - { + bool left, bool right) { + if (expr->kind == EQ_EXPRESSION) { expr->u.boolean_value = (left == right); - } - else if (expr->kind == NE_EXPRESSION) - { + } else if (expr->kind == NE_EXPRESSION) { expr->u.boolean_value = (left != right); - } - else - { + } else { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } @@ -225,34 +175,20 @@ eval_compare_expression_boolean(Expression *expr, } static Expression * -eval_compare_expression_int(Expression *expr, int left, int right) -{ - if (expr->kind == EQ_EXPRESSION) - { +eval_compare_expression_int(Expression *expr, int left, int right) { + if (expr->kind == EQ_EXPRESSION) { expr->u.boolean_value = (left == right); - } - else if (expr->kind == NE_EXPRESSION) - { + } else if (expr->kind == NE_EXPRESSION) { expr->u.boolean_value = (left != right); - } - else if (expr->kind == GT_EXPRESSION) - { + } else if (expr->kind == GT_EXPRESSION) { expr->u.boolean_value = (left > right); - } - else if (expr->kind == GE_EXPRESSION) - { + } else if (expr->kind == GE_EXPRESSION) { expr->u.boolean_value = (left >= right); - } - else if (expr->kind == LT_EXPRESSION) - { + } else if (expr->kind == LT_EXPRESSION) { expr->u.boolean_value = (left < right); - } - else if (expr->kind == LE_EXPRESSION) - { + } else if (expr->kind == LE_EXPRESSION) { expr->u.boolean_value = (left <= right); - } - else - { + } else { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } @@ -262,34 +198,20 @@ eval_compare_expression_int(Expression *expr, int left, int right) } static Expression * -eval_compare_expression_double(Expression *expr, double left, double right) -{ - if (expr->kind == EQ_EXPRESSION) - { +eval_compare_expression_double(Expression *expr, double left, double right) { + if (expr->kind == EQ_EXPRESSION) { expr->u.boolean_value = (left == right); - } - else if (expr->kind == NE_EXPRESSION) - { + } else if (expr->kind == NE_EXPRESSION) { expr->u.boolean_value = (left != right); - } - else if (expr->kind == GT_EXPRESSION) - { + } else if (expr->kind == GT_EXPRESSION) { expr->u.boolean_value = (left > right); - } - else if (expr->kind == GE_EXPRESSION) - { + } else if (expr->kind == GE_EXPRESSION) { expr->u.boolean_value = (left >= right); - } - else if (expr->kind == LT_EXPRESSION) - { + } else if (expr->kind == LT_EXPRESSION) { expr->u.boolean_value = (left < right); - } - else if (expr->kind == LE_EXPRESSION) - { + } else if (expr->kind == LE_EXPRESSION) { expr->u.boolean_value = (left <= right); - } - else - { + } else { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } @@ -300,35 +222,21 @@ eval_compare_expression_double(Expression *expr, double left, double right) static Expression * eval_compare_expression_string(Expression *expr, - char *left, char *right) -{ + char *left, char *right) { int cmp = strcmp(left, right); - if (expr->kind == EQ_EXPRESSION) - { + if (expr->kind == EQ_EXPRESSION) { expr->u.boolean_value = (cmp == 0); - } - else if (expr->kind == NE_EXPRESSION) - { + } else if (expr->kind == NE_EXPRESSION) { expr->u.boolean_value = (cmp != 0); - } - else if (expr->kind == GT_EXPRESSION) - { + } else if (expr->kind == GT_EXPRESSION) { expr->u.boolean_value = (cmp > 0); - } - else if (expr->kind == GE_EXPRESSION) - { + } else if (expr->kind == GE_EXPRESSION) { expr->u.boolean_value = (cmp >= 0); - } - else if (expr->kind == LT_EXPRESSION) - { + } else if (expr->kind == LT_EXPRESSION) { expr->u.boolean_value = (cmp < 0); - } - else if (expr->kind == LE_EXPRESSION) - { + } else if (expr->kind == LE_EXPRESSION) { expr->u.boolean_value = (cmp <= 0); - } - else - { + } else { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } @@ -341,58 +249,51 @@ eval_compare_expression_string(Expression *expr, } static Expression * -eval_compare_expression(Expression *expr) -{ - if (expr->u.binary_expression->left->kind == BOOL_EXPRESSION && expr->u.binary_expression->right->kind == BOOL_EXPRESSION) - { +eval_compare_expression(Expression *expr) { + if (expr->u.binary_expression->left->kind == BOOL_EXPRESSION && + expr->u.binary_expression->right->kind == BOOL_EXPRESSION) { expr = eval_compare_expression_boolean(expr, expr->u.binary_expression->left - ->u.boolean_value, + ->u.boolean_value, expr->u.binary_expression->right - ->u.boolean_value); - } - else if (expr->u.binary_expression->left->kind == INT_EXPRESSION && expr->u.binary_expression->right->kind == INT_EXPRESSION) - { + ->u.boolean_value); + } else if (expr->u.binary_expression->left->kind == INT_EXPRESSION && + expr->u.binary_expression->right->kind == INT_EXPRESSION) { expr = eval_compare_expression_int(expr, expr->u.binary_expression->left - ->u.int_value, + ->u.int_value, expr->u.binary_expression->right - ->u.int_value); - } - else if (expr->u.binary_expression->left->kind == DOUBLE_EXPRESSION && expr->u.binary_expression->right->kind == DOUBLE_EXPRESSION) - { + ->u.int_value); + } else if (expr->u.binary_expression->left->kind == DOUBLE_EXPRESSION && + expr->u.binary_expression->right->kind == DOUBLE_EXPRESSION) { expr = eval_compare_expression_double(expr, expr->u.binary_expression->left - ->u.double_value, + ->u.double_value, expr->u.binary_expression->right - ->u.double_value); - } - else if (expr->u.binary_expression->left->kind == STRING_EXPRESSION && expr->u.binary_expression->right->kind == STRING_EXPRESSION) - { + ->u.double_value); + } else if (expr->u.binary_expression->left->kind == STRING_EXPRESSION && + expr->u.binary_expression->right->kind == STRING_EXPRESSION) { expr = eval_compare_expression_string(expr, expr->u.binary_expression->left - ->u.str_value, + ->u.str_value, expr->u.binary_expression->right - ->u.str_value); + ->u.str_value); } return expr; } static Expression * -fix_compare_expression(Block *current_block, Expression *expr) -{ +fix_compare_expression(Block *current_block, Expression *expr) { expr->u.binary_expression->left = fix_expression(current_block, expr->u.binary_expression->left); expr->u.binary_expression->right = fix_expression(current_block, expr->u.binary_expression->right); expr = eval_compare_expression(expr); - if (expr->kind == BOOL_EXPRESSION) - { + if (expr->kind == BOOL_EXPRESSION) { return expr; } if (expr->u.binary_expression->left->type->basic_type != - expr->u.binary_expression->right->type->basic_type) - { + expr->u.binary_expression->right->type->basic_type) { compile_error(expr->line_number, COMPARE_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -403,18 +304,14 @@ fix_compare_expression(Block *current_block, Expression *expr) } static Expression * -fix_logical_and_or_expression(Block *current_block, Expression *expr) -{ +fix_logical_and_or_expression(Block *current_block, Expression *expr) { expr->u.binary_expression->left = fix_expression(current_block, expr->u.binary_expression->left); expr->u.binary_expression->right = fix_expression(current_block, expr->u.binary_expression->right); if (expr->u.binary_expression->left->type->basic_type == BOOLEAN_TYPE && - expr->u.binary_expression->right->type->basic_type == BOOLEAN_TYPE) - { + expr->u.binary_expression->right->type->basic_type == BOOLEAN_TYPE) { expr->type = alloc_type_specifier(BOOLEAN_TYPE); - } - else - { + } else { compile_error(expr->line_number, LOGICAL_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -423,25 +320,20 @@ fix_logical_and_or_expression(Block *current_block, Expression *expr) } static Expression * -fix_minus_expression(Block *current_block, Expression *expr) -{ +fix_minus_expression(Block *current_block, Expression *expr) { expr->u.unary_expression = fix_expression(current_block, expr->u.unary_expression); BasicType expr_type = expr->u.unary_expression->type->basic_type; - if (expr_type != INT_TYPE && expr_type != DOUBLE_TYPE) - { + if (expr_type != INT_TYPE && expr_type != DOUBLE_TYPE) { compile_error(expr->line_number, MINUS_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); } expr->type = expr->u.unary_expression->type; - if (expr->u.unary_expression->kind == INT_EXPRESSION) - { + if (expr->u.unary_expression->kind == INT_EXPRESSION) { expr->kind = INT_EXPRESSION; expr->u.int_value = -expr->u.unary_expression->u.int_value; - } - else if (expr->u.unary_expression->kind == DOUBLE_EXPRESSION) - { + } else if (expr->u.unary_expression->kind == DOUBLE_EXPRESSION) { expr->kind = DOUBLE_EXPRESSION; expr->u.double_value = -expr->u.unary_expression->u.double_value; } @@ -449,20 +341,17 @@ fix_minus_expression(Block *current_block, Expression *expr) } static Expression * -fix_logical_not_expression(Block *current_block, Expression *expr) -{ +fix_logical_not_expression(Block *current_block, Expression *expr) { expr->u.unary_expression = fix_expression(current_block, expr->u.unary_expression); - if (expr->u.unary_expression->kind == BOOL_EXPRESSION) - { + if (expr->u.unary_expression->kind == BOOL_EXPRESSION) { expr->kind = BOOL_EXPRESSION; expr->u.boolean_value = !expr->u.unary_expression->u.boolean_value; expr->type = alloc_type_specifier(BOOLEAN_TYPE); return expr; } - if (expr->u.unary_expression->type->basic_type != BOOLEAN_TYPE) - { + if (expr->u.unary_expression->type->basic_type != BOOLEAN_TYPE) { compile_error(expr->line_number, LOGICAL_NOT_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -472,27 +361,19 @@ fix_logical_not_expression(Block *current_block, Expression *expr) } static Expression * -fix_type_cast_expression(Block *current_block, Expression *expr) -{ +fix_type_cast_expression(Block *current_block, Expression *expr) { expr->u.unary_expression = fix_expression(current_block, expr->u.unary_expression); - if (expr->type->basic_type == DOUBLE_TYPE && expr->u.unary_expression->type->basic_type == INT_TYPE) - { - if (expr->u.unary_expression->kind == INT_EXPRESSION) - { + if (expr->type->basic_type == DOUBLE_TYPE && expr->u.unary_expression->type->basic_type == INT_TYPE) { + if (expr->u.unary_expression->kind == INT_EXPRESSION) { expr->kind = DOUBLE_EXPRESSION; - expr->u.double_value = (double)expr->u.unary_expression->u.int_value; + expr->u.double_value = (double) expr->u.unary_expression->u.int_value; } - } - else if (expr->type->basic_type == INT_TYPE && expr->u.unary_expression->type->basic_type == DOUBLE_TYPE) - { - if (expr->u.unary_expression->kind == DOUBLE_EXPRESSION) - { + } else if (expr->type->basic_type == INT_TYPE && expr->u.unary_expression->type->basic_type == DOUBLE_TYPE) { + if (expr->u.unary_expression->kind == DOUBLE_EXPRESSION) { expr->kind = INT_EXPRESSION; - expr->u.int_value = (int)expr->u.unary_expression->u.double_value; + expr->u.int_value = (int) expr->u.unary_expression->u.double_value; } - } - else - { + } else { compile_error(expr->line_number, TYPE_CAST_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -501,27 +382,19 @@ fix_type_cast_expression(Block *current_block, Expression *expr) } static void -implicit_type_cast(Expression *expr, TypeSpecifier *type) -{ - if (expr->kind == INT_EXPRESSION && type->basic_type == DOUBLE_TYPE) - { +implicit_type_cast(Expression *expr, TypeSpecifier *type) { + if (expr->kind == INT_EXPRESSION && type->basic_type == DOUBLE_TYPE) { expr->kind = DOUBLE_EXPRESSION; expr->type->basic_type = DOUBLE_TYPE; expr->u.double_value = expr->u.int_value; - } - else if (expr->kind == INT_EXPRESSION && type->basic_type == AMOUNT_TYPE) - { + } else if (expr->kind == INT_EXPRESSION && type->basic_type == AMOUNT_TYPE) { expr->type->basic_type = AMOUNT_TYPE; - } - else if (expr->kind == STRING_EXPRESSION && - (type->basic_type == ASSET_TYPE || type->basic_type == HASH_TYPE || - type->basic_type == PUBKEY_TYPE || type->basic_type == SIG_TYPE || - type->basic_type == HEX_TYPE)) - { + } else if (expr->kind == STRING_EXPRESSION && + (type->basic_type == ASSET_TYPE || type->basic_type == HASH_TYPE || + type->basic_type == PUBKEY_TYPE || type->basic_type == SIG_TYPE || + type->basic_type == HEX_TYPE)) { expr->type->basic_type = type->basic_type; - } - else - { + } else { compile_error(expr->line_number, TYPE_CAST_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -531,24 +404,20 @@ implicit_type_cast(Expression *expr, TypeSpecifier *type) static void check_argument(Block *current_block, int line_number, - ParameterList *param_list, ArgumentList *arg) -{ + ParameterList *param_list, ArgumentList *arg) { ParameterList *param; TypeSpecifier *temp_type; for (param = param_list; param && arg; - param = param->next, arg = arg->next) - { + param = param->next, arg = arg->next) { arg->expr = fix_expression(current_block, arg->expr); - if (param->type->basic_type != arg->expr->type->basic_type) - { + if (param->type->basic_type != arg->expr->type->basic_type) { implicit_type_cast(arg->expr, param->type); } } - if (param || arg) - { + if (param || arg) { compile_error(line_number, ARGUMENT_COUNT_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -556,14 +425,12 @@ check_argument(Block *current_block, int line_number, } static Expression * -fix_function_call_expression(Block *current_block, Expression *expr) -{ +fix_function_call_expression(Block *current_block, Expression *expr) { Expression *func_expr = fix_expression(current_block, expr->u.func_call_expression->function); expr->u.func_call_expression->function = func_expr; BuiltinFun *builtin_fun = func_expr->u.identifier->u.builtin_func; - if (builtin_fun == NULL) - { + if (builtin_fun == NULL) { compile_error(expr->line_number, FUNCTION_NOT_FOUND_ERR, STRING_MESSAGE_ARGUMENT, "name", @@ -572,16 +439,15 @@ fix_function_call_expression(Block *current_block, Expression *expr) } ParameterList *parameter_list = NULL; - for (int i = 0; i < builtin_fun->parameter_count; i++) - { - parameter_list = chain_parameter(parameter_list, alloc_parameter(alloc_type_specifier(builtin_fun->parameters[i]), "")); + for (int i = 0; i < builtin_fun->parameter_count; i++) { + parameter_list = chain_parameter(parameter_list, + alloc_parameter(alloc_type_specifier(builtin_fun->parameters[i]), "")); } check_argument(current_block, expr->line_number, parameter_list, expr->u.func_call_expression->argument_list); - for (ParameterList *pos = parameter_list; pos;) - { + for (ParameterList *pos = parameter_list; pos;) { ParameterList *old = pos; pos = old->next; free(old->type); @@ -592,91 +458,86 @@ fix_function_call_expression(Block *current_block, Expression *expr) return expr; } -static Expression *init_expression(BasicType basic_type) -{ - switch (basic_type) - { - case AMOUNT_TYPE: - case INT_TYPE: - return alloc_int_expression(0); - case DOUBLE_TYPE: - return alloc_double_expression(0); - case STRING_TYPE: - case ASSET_TYPE: - case HASH_TYPE: - case PUBKEY_TYPE: - case SIG_TYPE: - case HEX_TYPE: - return alloc_string_expression(""); - default: - DBG_assert(0, ("bad case. type..%d\n", basic_type)); +static Expression *init_expression(BasicType basic_type) { + switch (basic_type) { + case AMOUNT_TYPE: + case INT_TYPE: + return alloc_int_expression(0); + case DOUBLE_TYPE: + return alloc_double_expression(0); + case STRING_TYPE: + case ASSET_TYPE: + case HASH_TYPE: + case PUBKEY_TYPE: + case SIG_TYPE: + case HEX_TYPE: + return alloc_string_expression(""); + default: + DBG_assert(0, ("bad case. type..%d\n", basic_type)); } return NULL; } static Expression * -fix_expression(Block *current_block, Expression *expr) -{ +fix_expression(Block *current_block, Expression *expr) { if (expr == NULL) return NULL; - switch (expr->kind) - { - case BOOL_EXPRESSION: - expr->type = alloc_type_specifier(BOOLEAN_TYPE); - break; - case INT_EXPRESSION: - expr->type = alloc_type_specifier(INT_TYPE); - break; - case DOUBLE_EXPRESSION: - expr->type = alloc_type_specifier(DOUBLE_TYPE); - break; - case STRING_EXPRESSION: - expr->type = alloc_type_specifier(STRING_TYPE); - break; - case IDENTIFIER_EXPRESSION: - expr = fix_identifier_expression(current_block, expr); - break; - case ADD_EXPRESSION: /* FALLTHRU */ - case SUB_EXPRESSION: /* FALLTHRU */ - case MUL_EXPRESSION: /* FALLTHRU */ - case DIV_EXPRESSION: /* FALLTHRU */ - case MOD_EXPRESSION: - expr = fix_math_binary_expression(current_block, expr); - break; - case EQ_EXPRESSION: /* FALLTHRU */ - case NE_EXPRESSION: /* FALLTHRU */ - case GT_EXPRESSION: /* FALLTHRU */ - case GE_EXPRESSION: /* FALLTHRU */ - case LT_EXPRESSION: /* FALLTHRU */ - case LE_EXPRESSION: - expr = fix_compare_expression(current_block, expr); - break; - case AND_EXPRESSION: /* FALLTHRU */ - case OR_EXPRESSION: - expr = fix_logical_and_or_expression(current_block, expr); - break; - case MINUS_EXPRESSION: - expr = fix_minus_expression(current_block, expr); - break; - case NOT_EXPRESSION: - expr = fix_logical_not_expression(current_block, expr); - break; - case TYPE_CAST_EXPRESSION: - expr = fix_type_cast_expression(current_block, expr); - break; - case FUNC_CALL_EXPRESSION: - expr = fix_function_call_expression(current_block, expr); - break; - default: - DBG_assert(0, ("bad case. kind..%d\n", expr->kind)); + switch (expr->kind) { + case BOOL_EXPRESSION: + expr->type = alloc_type_specifier(BOOLEAN_TYPE); + break; + case INT_EXPRESSION: + expr->type = alloc_type_specifier(INT_TYPE); + break; + case DOUBLE_EXPRESSION: + expr->type = alloc_type_specifier(DOUBLE_TYPE); + break; + case STRING_EXPRESSION: + expr->type = alloc_type_specifier(STRING_TYPE); + break; + case IDENTIFIER_EXPRESSION: + expr = fix_identifier_expression(current_block, expr); + break; + case ADD_EXPRESSION: /* FALLTHRU */ + case SUB_EXPRESSION: /* FALLTHRU */ + case MUL_EXPRESSION: /* FALLTHRU */ + case DIV_EXPRESSION: /* FALLTHRU */ + case MOD_EXPRESSION: + expr = fix_math_binary_expression(current_block, expr); + break; + case EQ_EXPRESSION: /* FALLTHRU */ + case NE_EXPRESSION: /* FALLTHRU */ + case GT_EXPRESSION: /* FALLTHRU */ + case GE_EXPRESSION: /* FALLTHRU */ + case LT_EXPRESSION: /* FALLTHRU */ + case LE_EXPRESSION: + expr = fix_compare_expression(current_block, expr); + break; + case AND_EXPRESSION: /* FALLTHRU */ + case OR_EXPRESSION: + expr = fix_logical_and_or_expression(current_block, expr); + break; + case MINUS_EXPRESSION: + expr = fix_minus_expression(current_block, expr); + break; + case NOT_EXPRESSION: + expr = fix_logical_not_expression(current_block, expr); + break; + case TYPE_CAST_EXPRESSION: + expr = fix_type_cast_expression(current_block, expr); + break; + case FUNC_CALL_EXPRESSION: + expr = fix_function_call_expression(current_block, expr); + break; + default: + DBG_assert(0, ("bad case. kind..%d\n", expr->kind)); } return expr; } static void -add_local_variable(FuncDefinition *fd, Declaration *decl) -{ +add_local_variable(FuncDefinition *fd, Declaration *decl) { fd->local_variable = realloc(fd->local_variable, sizeof(Declaration *) * (fd->local_variable_count + 1)); fd->local_variable[fd->local_variable_count] = decl; @@ -686,27 +547,21 @@ add_local_variable(FuncDefinition *fd, Declaration *decl) static void add_declaration(Block *current_block, Declaration *decl, - FuncDefinition *fd, int line_number) -{ - if (search_declaration_in_current_block(decl->name, current_block)) - { + FuncDefinition *fd, int line_number) { + if (search_declaration_in_current_block(decl->name, current_block)) { compile_error(line_number, VARIABLE_MULTIPLE_DEFINE_ERR, STRING_MESSAGE_ARGUMENT, "name", decl->name, MESSAGE_ARGUMENT_END); } - if (current_block) - { + if (current_block) { current_block->declaration_list = chain_declaration_list(current_block->declaration_list, decl); } - if (fd) - { + if (fd) { decl->is_local = true; add_local_variable(fd, decl); - } - else - { + } else { Compiler *compiler = get_current_compiler(); decl->is_local = false; compiler->declaration_list = chain_declaration_list(compiler->declaration_list, decl); @@ -714,11 +569,9 @@ add_declaration(Block *current_block, Declaration *decl, } static void -fix_if_statement(Block *current_block, IfStatement *if_s, FuncDefinition *fd) -{ +fix_if_statement(Block *current_block, IfStatement *if_s, FuncDefinition *fd) { if_s->condition = fix_expression(current_block, if_s->condition); - if (if_s->condition->type->basic_type != BOOLEAN_TYPE) - { + if (if_s->condition->type->basic_type != BOOLEAN_TYPE) { compile_error(if_s->condition->line_number, IF_CONDITION_NOT_BOOLEAN_ERR, MESSAGE_ARGUMENT_END); @@ -726,32 +579,26 @@ fix_if_statement(Block *current_block, IfStatement *if_s, FuncDefinition *fd) fix_statement_list(if_s->then_block, if_s->then_block->statement_list, fd); - for (Elseif *pos = if_s->elseif_list; pos; pos = pos->next) - { + for (Elseif *pos = if_s->elseif_list; pos; pos = pos->next) { pos->condition = fix_expression(current_block, pos->condition); - if (pos->block) - { + if (pos->block) { fix_statement_list(pos->block, pos->block->statement_list, fd); } } - if (if_s->else_block) - { + if (if_s->else_block) { fix_statement_list(if_s->else_block, if_s->else_block->statement_list, fd); } } static void -fix_return_statement(Block *current_block, Statement *statement, FuncDefinition *fd) -{ +fix_return_statement(Block *current_block, Statement *statement, FuncDefinition *fd) { Expression *return_value = fix_expression(current_block, statement->u.expr_s); - if (fd->return_type->basic_type == VOID_TYPE && return_value != NULL) - { + if (fd->return_type->basic_type == VOID_TYPE && return_value != NULL) { compile_error(statement->line_number, RETURN_IN_VOID_FUNCTION_ERR, MESSAGE_ARGUMENT_END); } - if (fd->return_type->basic_type != VOID_TYPE) - { + if (fd->return_type->basic_type != VOID_TYPE) { if (return_value == NULL || return_value->type->basic_type != fd->return_type->basic_type) compile_error(statement->line_number, RETURN_TYPE_MISMATCH_ERR, @@ -762,46 +609,35 @@ fix_return_statement(Block *current_block, Statement *statement, FuncDefinition } static void -fix_declaration_stmt(Block *current_block, Statement *stmt, FuncDefinition *fd) -{ +fix_declaration_stmt(Block *current_block, Statement *stmt, FuncDefinition *fd) { Declaration *decl = stmt->u.decl_s; add_declaration(current_block, decl, fd, stmt->line_number); - if (decl->initializer) - { + if (decl->initializer) { decl->initializer = fix_expression(current_block, decl->initializer); - if (!decl->type) - { + if (!decl->type) { decl->type = decl->initializer->type; - } - else if (decl->initializer->type->basic_type != decl->type->basic_type) - { + } else if (decl->initializer->type->basic_type != decl->type->basic_type) { implicit_type_cast(decl->initializer, decl->type); } - } - else - { + } else { decl->initializer = init_expression(decl->type->basic_type); } } static void -fix_assign_stmt(Block *current_block, Statement *stmt) -{ +fix_assign_stmt(Block *current_block, Statement *stmt) { AssignStatement *assign_s = stmt->u.assign_s; assign_s->left = fix_expression(current_block, assign_s->left); assign_s->operand = fix_expression(current_block, assign_s->operand); - if (assign_s->operand->type->basic_type != assign_s->left->type->basic_type) - { + if (assign_s->operand->type->basic_type != assign_s->left->type->basic_type) { implicit_type_cast(assign_s->operand, assign_s->left->type); } } static void -fix_expression_stmt(Block *current_block, Statement *stmt) -{ +fix_expression_stmt(Block *current_block, Statement *stmt) { stmt->u.expr_s = fix_expression(current_block, stmt->u.expr_s); - if (stmt->u.expr_s->kind != FUNC_CALL_EXPRESSION) - { + if (stmt->u.expr_s->kind != FUNC_CALL_EXPRESSION) { compile_error(stmt->line_number, EXPR_EVALUATED_BUT_NOT_USED, MESSAGE_ARGUMENT_END); @@ -809,66 +645,61 @@ fix_expression_stmt(Block *current_block, Statement *stmt) } static void -fix_statement(Block *current_block, Statement *statement, FuncDefinition *fd) -{ - switch (statement->kind) - { - case IF_STATEMENT: - fix_if_statement(current_block, statement->u.if_s, fd); - break; - case RETURN_STATEMENT: - fix_return_statement(current_block, statement, fd); - break; - case DECLARATION_STATEMENT: - fix_declaration_stmt(current_block, statement, fd); - break; - case ASSIGN_STATEMENT: - fix_assign_stmt(current_block, statement); - break; - case EXPRESSION_STATEMENT: - fix_expression_stmt(current_block, statement); - break; - default: - DBG_assert(0, ("bad case. kind..%d\n", statement->kind)); +fix_statement(Block *current_block, Statement *statement, FuncDefinition *fd) { + switch (statement->kind) { + case IF_STATEMENT: + fix_if_statement(current_block, statement->u.if_s, fd); + break; + case RETURN_STATEMENT: + fix_return_statement(current_block, statement, fd); + break; + case DECLARATION_STATEMENT: + fix_declaration_stmt(current_block, statement, fd); + break; + case ASSIGN_STATEMENT: + fix_assign_stmt(current_block, statement); + break; + case EXPRESSION_STATEMENT: + fix_expression_stmt(current_block, statement); + break; + case BLOCK_STATEMENT: + fix_statement_list(statement->u.block_s, statement->u.block_s->statement_list, NULL); + break; + default: + DBG_assert(0, ("bad case. kind..%d\n", statement->kind)); } } static void -fix_statement_list(Block *current_block, StatementList *list, FuncDefinition *fd) -{ +fix_statement_list(Block *current_block, StatementList *list, FuncDefinition *fd) { StatementList *pos; - for (pos = list; pos; pos = pos->next) - { + for (pos = list; pos; pos = pos->next) { fix_statement(current_block, pos->statement, fd); } } static void -add_parameter_as_declaration(FuncDefinition *fd) -{ +add_parameter_as_declaration(FuncDefinition *fd) { Declaration *decl; ParameterList *param; - for (param = fd->parameters; param; param = param->next) - { + for (param = fd->parameters; param; param = param->next) { decl = alloc_declaration(param->name, param->type, NULL); - if (fd->code_block) - { + if (fd->code_block) { add_declaration(fd->code_block, decl, fd, param->line_number); } } } static int -reserve_function_index(Compiler *compiler, FuncDefinition *src) -{ +reserve_function_index(Compiler *compiler, FuncDefinition *src) { int i; SVM_Function *dest; compiler->svm_function - = realloc(compiler->svm_function, - sizeof(SVM_Function) * (compiler->svm_function_count+1)); + = realloc(compiler->svm_function, + sizeof(SVM_Function) * (compiler->svm_function_count + 1)); dest = &compiler->svm_function[compiler->svm_function_count]; compiler->svm_function_count++; @@ -877,28 +708,24 @@ reserve_function_index(Compiler *compiler, FuncDefinition *src) return compiler->svm_function_count - 1; } -static void fix_function(FuncDefinition *fd) -{ +static void fix_function(FuncDefinition *fd) { add_parameter_as_declaration(fd); - if (fd->code_block) - { + if (fd->code_block) { fix_statement_list(fd->code_block, fd->code_block->statement_list, fd); } } -void fix_tree(Compiler *compiler) -{ +void fix_tree(Compiler *compiler) { FuncDefinition *func_pos; - for (func_pos = compiler->func_definition_list; func_pos; + for (func_pos = compiler->func_definition_list; func_pos; func_pos = func_pos->next) { reserve_function_index(compiler, func_pos); } fix_statement_list(NULL, compiler->stmt_list, NULL); - for (func_pos = compiler->func_definition_list; func_pos; func_pos = func_pos->next) - { + for (func_pos = compiler->func_definition_list; func_pos; func_pos = func_pos->next) { fix_function(func_pos); } } \ No newline at end of file diff --git a/compiler/grammar.y b/compiler/grammar.y index 204cce2..a7ee992 100644 --- a/compiler/grammar.y +++ b/compiler/grammar.y @@ -172,8 +172,8 @@ type_specifier: ; block: - '{' new_line_opt stmt_list new_line_opt { $$ = open_block(); } - '}' { $$ = close_block($5, $3); } + '{' new_line_opt { $$ = open_block(); } + stmt_list new_line_opt '}' { $$ = close_block($3, $4); } | '{' new_line_opt '}' { $$ = alloc_block(NULL); } ; From 38197f05386fede0b07c71c63e424ced032a2fd9 Mon Sep 17 00:00:00 2001 From: shenao78 Date: Thu, 2 Sep 2021 18:31:23 +0800 Subject: [PATCH 2/3] remove print --- compiler/create.c | 3 --- 1 file changed, 3 deletions(-) diff --git a/compiler/create.c b/compiler/create.c index 0a03199..bfee384 100644 --- a/compiler/create.c +++ b/compiler/create.c @@ -233,16 +233,13 @@ Block *open_block() Block *new_block; Compiler *compiler = get_current_compiler(); new_block = alloc_block(NULL); - printf("open:%p\n", new_block); new_block->outer_block = compiler->current_block; -// printf("open out:%p\n", compiler->current_block); compiler->current_block = new_block; return new_block; } Block *close_block(Block *block, StatementList *stmt_list) { - printf("close:%p\n", block); Compiler *compiler = get_current_compiler(); block->statement_list = stmt_list; compiler->current_block = block->outer_block; From c1ea7c1b7dd0d0b7bdd0c90bcb141264c0f25538 Mon Sep 17 00:00:00 2001 From: shenao78 Date: Thu, 2 Sep 2021 18:32:52 +0800 Subject: [PATCH 3/3] fix block stmt --- compiler/fix_tree.c | 478 ++++++++++++++++++++++++++++++-------------- 1 file changed, 327 insertions(+), 151 deletions(-) diff --git a/compiler/fix_tree.c b/compiler/fix_tree.c index 946b269..be1d3d5 100644 --- a/compiler/fix_tree.c +++ b/compiler/fix_tree.c @@ -6,18 +6,18 @@ #include "../include/DBG.h" extern BuiltinFun *search_builtin_function(char *name); - static Expression *fix_expression(Block *current_block, Expression *expr); - static void fix_statement_list(Block *current_block, StatementList *list, FuncDefinition *fd); static Expression * -fix_identifier_expression(Block *current_block, Expression *expr) { +fix_identifier_expression(Block *current_block, Expression *expr) +{ Declaration *decl; BuiltinFun *builtin_func; decl = search_declaration(expr->u.identifier->name, current_block); - if (decl) { + if (decl) + { expr->type = decl->type; expr->u.identifier->kind = VARIABLE_IDENTIFIER; expr->u.identifier->u.declaration = decl; @@ -25,7 +25,8 @@ fix_identifier_expression(Block *current_block, Expression *expr) { } builtin_func = search_builtin_function(expr->u.identifier->name); - if (builtin_func == NULL) { + if (builtin_func == NULL) + { compile_error(expr->line_number, IDENTIFIER_NOT_FOUND_ERR, STRING_MESSAGE_ARGUMENT, "name", @@ -42,23 +43,36 @@ fix_identifier_expression(Block *current_block, Expression *expr) { } static Expression * -eval_math_expression_int(Expression *expr, int left, int right) { - if (expr->kind == ADD_EXPRESSION) { +eval_math_expression_int(Expression *expr, int left, int right) +{ + if (expr->kind == ADD_EXPRESSION) + { expr->u.int_value = left + right; - } else if (expr->kind == SUB_EXPRESSION) { + } + else if (expr->kind == SUB_EXPRESSION) + { expr->u.int_value = left - right; - } else if (expr->kind == MUL_EXPRESSION) { + } + else if (expr->kind == MUL_EXPRESSION) + { expr->u.int_value = left * right; - } else if (expr->kind == DIV_EXPRESSION) { - if (right == 0) { + } + else if (expr->kind == DIV_EXPRESSION) + { + if (right == 0) + { compile_error(expr->line_number, DIVISION_BY_ZERO_IN_COMPILE_ERR, MESSAGE_ARGUMENT_END); } expr->u.int_value = left / right; - } else if (expr->kind == MOD_EXPRESSION) { + } + else if (expr->kind == MOD_EXPRESSION) + { expr->u.int_value = left % right; - } else { + } + else + { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } expr->kind = INT_EXPRESSION; @@ -67,18 +81,30 @@ eval_math_expression_int(Expression *expr, int left, int right) { } static Expression * -eval_math_expression_double(Expression *expr, double left, double right) { - if (expr->kind == ADD_EXPRESSION) { +eval_math_expression_double(Expression *expr, double left, double right) +{ + if (expr->kind == ADD_EXPRESSION) + { expr->u.double_value = left + right; - } else if (expr->kind == SUB_EXPRESSION) { + } + else if (expr->kind == SUB_EXPRESSION) + { expr->u.double_value = left - right; - } else if (expr->kind == MUL_EXPRESSION) { + } + else if (expr->kind == MUL_EXPRESSION) + { expr->u.double_value = left * right; - } else if (expr->kind == DIV_EXPRESSION) { + } + else if (expr->kind == DIV_EXPRESSION) + { expr->u.double_value = left / right; - } else if (expr->kind == MOD_EXPRESSION) { + } + else if (expr->kind == MOD_EXPRESSION) + { expr->u.double_value = fmod(left, right); - } else { + } + else + { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } expr->kind = DOUBLE_EXPRESSION; @@ -87,7 +113,8 @@ eval_math_expression_double(Expression *expr, double left, double right) { } static Expression * -chain_string(Expression *expr) { +chain_string(Expression *expr) +{ char *left_str = expr->u.binary_expression->left->u.str_value; char *right_str = expr->u.binary_expression->right->u.str_value; @@ -104,53 +131,70 @@ chain_string(Expression *expr) { } static Expression * -eval_math_expression(Block *current_block, Expression *expr) { +eval_math_expression(Block *current_block, Expression *expr) +{ ExpressionKind left_kind = expr->u.binary_expression->left->kind; ExpressionKind right_kind = expr->u.binary_expression->right->kind; - if (left_kind == INT_EXPRESSION && right_kind == INT_EXPRESSION) { + if (left_kind == INT_EXPRESSION && right_kind == INT_EXPRESSION) + { expr = eval_math_expression_int(expr, expr->u.binary_expression->left ->u.int_value, expr->u.binary_expression->right ->u.int_value); - } else if ((left_kind == DOUBLE_EXPRESSION && right_kind == DOUBLE_EXPRESSION) || - (left_kind == DOUBLE_EXPRESSION && right_kind == INT_EXPRESSION) || - (left_kind == INT_EXPRESSION && right_kind == DOUBLE_EXPRESSION)) { + } + else if ((left_kind == DOUBLE_EXPRESSION && right_kind == DOUBLE_EXPRESSION) || + (left_kind == DOUBLE_EXPRESSION && right_kind == INT_EXPRESSION) || + (left_kind == INT_EXPRESSION && right_kind == DOUBLE_EXPRESSION)) + { double left_value = expr->u.binary_expression->left->u.double_value; - if (left_kind == INT_EXPRESSION) { + if (left_kind == INT_EXPRESSION) + { left_value = expr->u.binary_expression->left->u.int_value; } double right_value = expr->u.binary_expression->right->u.double_value; - if (right_kind == INT_EXPRESSION) { + if (right_kind == INT_EXPRESSION) + { right_value = expr->u.binary_expression->right->u.int_value; } expr = eval_math_expression_double(expr, left_value, right_value); - } else if (left_kind == STRING_EXPRESSION && right_kind == STRING_EXPRESSION && expr->kind == ADD_EXPRESSION) { + } + else if (left_kind == STRING_EXPRESSION && right_kind == STRING_EXPRESSION && expr->kind == ADD_EXPRESSION) + { expr = chain_string(expr); } return expr; } static Expression * -fix_math_binary_expression(Block *current_block, Expression *expr) { +fix_math_binary_expression(Block *current_block, Expression *expr) +{ expr->u.binary_expression->left = fix_expression(current_block, expr->u.binary_expression->left); expr->u.binary_expression->right = fix_expression(current_block, expr->u.binary_expression->right); expr = eval_math_expression(current_block, expr); - if (expr->kind == INT_EXPRESSION || expr->kind == DOUBLE_EXPRESSION || expr->kind == STRING_EXPRESSION) { + if (expr->kind == INT_EXPRESSION || expr->kind == DOUBLE_EXPRESSION || expr->kind == STRING_EXPRESSION) + { return expr; } BasicType left_type = expr->u.binary_expression->left->type->basic_type; BasicType right_type = expr->u.binary_expression->right->type->basic_type; - if (left_type == INT_TYPE && right_type == INT_TYPE) { + if (left_type == INT_TYPE && right_type == INT_TYPE) + { expr->type = alloc_type_specifier(INT_TYPE); - } else if (left_type == DOUBLE_TYPE && right_type == DOUBLE_TYPE) { + } + else if (left_type == DOUBLE_TYPE && right_type == DOUBLE_TYPE) + { expr->type = alloc_type_specifier(DOUBLE_TYPE); - } else if (expr->kind == ADD_EXPRESSION && left_type == STRING_TYPE && right_type == STRING_TYPE) { + } + else if (expr->kind == ADD_EXPRESSION && left_type == STRING_TYPE && right_type == STRING_TYPE) + { expr->type = alloc_type_specifier(STRING_TYPE); - } else { + } + else + { compile_error(expr->line_number, MATH_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -160,12 +204,18 @@ fix_math_binary_expression(Block *current_block, Expression *expr) { static Expression * eval_compare_expression_boolean(Expression *expr, - bool left, bool right) { - if (expr->kind == EQ_EXPRESSION) { + bool left, bool right) +{ + if (expr->kind == EQ_EXPRESSION) + { expr->u.boolean_value = (left == right); - } else if (expr->kind == NE_EXPRESSION) { + } + else if (expr->kind == NE_EXPRESSION) + { expr->u.boolean_value = (left != right); - } else { + } + else + { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } @@ -175,20 +225,34 @@ eval_compare_expression_boolean(Expression *expr, } static Expression * -eval_compare_expression_int(Expression *expr, int left, int right) { - if (expr->kind == EQ_EXPRESSION) { +eval_compare_expression_int(Expression *expr, int left, int right) +{ + if (expr->kind == EQ_EXPRESSION) + { expr->u.boolean_value = (left == right); - } else if (expr->kind == NE_EXPRESSION) { + } + else if (expr->kind == NE_EXPRESSION) + { expr->u.boolean_value = (left != right); - } else if (expr->kind == GT_EXPRESSION) { + } + else if (expr->kind == GT_EXPRESSION) + { expr->u.boolean_value = (left > right); - } else if (expr->kind == GE_EXPRESSION) { + } + else if (expr->kind == GE_EXPRESSION) + { expr->u.boolean_value = (left >= right); - } else if (expr->kind == LT_EXPRESSION) { + } + else if (expr->kind == LT_EXPRESSION) + { expr->u.boolean_value = (left < right); - } else if (expr->kind == LE_EXPRESSION) { + } + else if (expr->kind == LE_EXPRESSION) + { expr->u.boolean_value = (left <= right); - } else { + } + else + { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } @@ -198,20 +262,34 @@ eval_compare_expression_int(Expression *expr, int left, int right) { } static Expression * -eval_compare_expression_double(Expression *expr, double left, double right) { - if (expr->kind == EQ_EXPRESSION) { +eval_compare_expression_double(Expression *expr, double left, double right) +{ + if (expr->kind == EQ_EXPRESSION) + { expr->u.boolean_value = (left == right); - } else if (expr->kind == NE_EXPRESSION) { + } + else if (expr->kind == NE_EXPRESSION) + { expr->u.boolean_value = (left != right); - } else if (expr->kind == GT_EXPRESSION) { + } + else if (expr->kind == GT_EXPRESSION) + { expr->u.boolean_value = (left > right); - } else if (expr->kind == GE_EXPRESSION) { + } + else if (expr->kind == GE_EXPRESSION) + { expr->u.boolean_value = (left >= right); - } else if (expr->kind == LT_EXPRESSION) { + } + else if (expr->kind == LT_EXPRESSION) + { expr->u.boolean_value = (left < right); - } else if (expr->kind == LE_EXPRESSION) { + } + else if (expr->kind == LE_EXPRESSION) + { expr->u.boolean_value = (left <= right); - } else { + } + else + { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } @@ -222,21 +300,35 @@ eval_compare_expression_double(Expression *expr, double left, double right) { static Expression * eval_compare_expression_string(Expression *expr, - char *left, char *right) { + char *left, char *right) +{ int cmp = strcmp(left, right); - if (expr->kind == EQ_EXPRESSION) { + if (expr->kind == EQ_EXPRESSION) + { expr->u.boolean_value = (cmp == 0); - } else if (expr->kind == NE_EXPRESSION) { + } + else if (expr->kind == NE_EXPRESSION) + { expr->u.boolean_value = (cmp != 0); - } else if (expr->kind == GT_EXPRESSION) { + } + else if (expr->kind == GT_EXPRESSION) + { expr->u.boolean_value = (cmp > 0); - } else if (expr->kind == GE_EXPRESSION) { + } + else if (expr->kind == GE_EXPRESSION) + { expr->u.boolean_value = (cmp >= 0); - } else if (expr->kind == LT_EXPRESSION) { + } + else if (expr->kind == LT_EXPRESSION) + { expr->u.boolean_value = (cmp < 0); - } else if (expr->kind == LE_EXPRESSION) { + } + else if (expr->kind == LE_EXPRESSION) + { expr->u.boolean_value = (cmp <= 0); - } else { + } + else + { DBG_assert(0, ("expr->kind..%d\n", expr->kind)); } @@ -249,30 +341,34 @@ eval_compare_expression_string(Expression *expr, } static Expression * -eval_compare_expression(Expression *expr) { - if (expr->u.binary_expression->left->kind == BOOL_EXPRESSION && - expr->u.binary_expression->right->kind == BOOL_EXPRESSION) { +eval_compare_expression(Expression *expr) +{ + if (expr->u.binary_expression->left->kind == BOOL_EXPRESSION && expr->u.binary_expression->right->kind == BOOL_EXPRESSION) + { expr = eval_compare_expression_boolean(expr, expr->u.binary_expression->left ->u.boolean_value, expr->u.binary_expression->right ->u.boolean_value); - } else if (expr->u.binary_expression->left->kind == INT_EXPRESSION && - expr->u.binary_expression->right->kind == INT_EXPRESSION) { + } + else if (expr->u.binary_expression->left->kind == INT_EXPRESSION && expr->u.binary_expression->right->kind == INT_EXPRESSION) + { expr = eval_compare_expression_int(expr, expr->u.binary_expression->left ->u.int_value, expr->u.binary_expression->right ->u.int_value); - } else if (expr->u.binary_expression->left->kind == DOUBLE_EXPRESSION && - expr->u.binary_expression->right->kind == DOUBLE_EXPRESSION) { + } + else if (expr->u.binary_expression->left->kind == DOUBLE_EXPRESSION && expr->u.binary_expression->right->kind == DOUBLE_EXPRESSION) + { expr = eval_compare_expression_double(expr, expr->u.binary_expression->left ->u.double_value, expr->u.binary_expression->right ->u.double_value); - } else if (expr->u.binary_expression->left->kind == STRING_EXPRESSION && - expr->u.binary_expression->right->kind == STRING_EXPRESSION) { + } + else if (expr->u.binary_expression->left->kind == STRING_EXPRESSION && expr->u.binary_expression->right->kind == STRING_EXPRESSION) + { expr = eval_compare_expression_string(expr, expr->u.binary_expression->left ->u.str_value, @@ -283,17 +379,20 @@ eval_compare_expression(Expression *expr) { } static Expression * -fix_compare_expression(Block *current_block, Expression *expr) { +fix_compare_expression(Block *current_block, Expression *expr) +{ expr->u.binary_expression->left = fix_expression(current_block, expr->u.binary_expression->left); expr->u.binary_expression->right = fix_expression(current_block, expr->u.binary_expression->right); expr = eval_compare_expression(expr); - if (expr->kind == BOOL_EXPRESSION) { + if (expr->kind == BOOL_EXPRESSION) + { return expr; } if (expr->u.binary_expression->left->type->basic_type != - expr->u.binary_expression->right->type->basic_type) { + expr->u.binary_expression->right->type->basic_type) + { compile_error(expr->line_number, COMPARE_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -304,14 +403,18 @@ fix_compare_expression(Block *current_block, Expression *expr) { } static Expression * -fix_logical_and_or_expression(Block *current_block, Expression *expr) { +fix_logical_and_or_expression(Block *current_block, Expression *expr) +{ expr->u.binary_expression->left = fix_expression(current_block, expr->u.binary_expression->left); expr->u.binary_expression->right = fix_expression(current_block, expr->u.binary_expression->right); if (expr->u.binary_expression->left->type->basic_type == BOOLEAN_TYPE && - expr->u.binary_expression->right->type->basic_type == BOOLEAN_TYPE) { + expr->u.binary_expression->right->type->basic_type == BOOLEAN_TYPE) + { expr->type = alloc_type_specifier(BOOLEAN_TYPE); - } else { + } + else + { compile_error(expr->line_number, LOGICAL_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -320,20 +423,25 @@ fix_logical_and_or_expression(Block *current_block, Expression *expr) { } static Expression * -fix_minus_expression(Block *current_block, Expression *expr) { +fix_minus_expression(Block *current_block, Expression *expr) +{ expr->u.unary_expression = fix_expression(current_block, expr->u.unary_expression); BasicType expr_type = expr->u.unary_expression->type->basic_type; - if (expr_type != INT_TYPE && expr_type != DOUBLE_TYPE) { + if (expr_type != INT_TYPE && expr_type != DOUBLE_TYPE) + { compile_error(expr->line_number, MINUS_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); } expr->type = expr->u.unary_expression->type; - if (expr->u.unary_expression->kind == INT_EXPRESSION) { + if (expr->u.unary_expression->kind == INT_EXPRESSION) + { expr->kind = INT_EXPRESSION; expr->u.int_value = -expr->u.unary_expression->u.int_value; - } else if (expr->u.unary_expression->kind == DOUBLE_EXPRESSION) { + } + else if (expr->u.unary_expression->kind == DOUBLE_EXPRESSION) + { expr->kind = DOUBLE_EXPRESSION; expr->u.double_value = -expr->u.unary_expression->u.double_value; } @@ -341,17 +449,20 @@ fix_minus_expression(Block *current_block, Expression *expr) { } static Expression * -fix_logical_not_expression(Block *current_block, Expression *expr) { +fix_logical_not_expression(Block *current_block, Expression *expr) +{ expr->u.unary_expression = fix_expression(current_block, expr->u.unary_expression); - if (expr->u.unary_expression->kind == BOOL_EXPRESSION) { + if (expr->u.unary_expression->kind == BOOL_EXPRESSION) + { expr->kind = BOOL_EXPRESSION; expr->u.boolean_value = !expr->u.unary_expression->u.boolean_value; expr->type = alloc_type_specifier(BOOLEAN_TYPE); return expr; } - if (expr->u.unary_expression->type->basic_type != BOOLEAN_TYPE) { + if (expr->u.unary_expression->type->basic_type != BOOLEAN_TYPE) + { compile_error(expr->line_number, LOGICAL_NOT_TYPE_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -361,19 +472,27 @@ fix_logical_not_expression(Block *current_block, Expression *expr) { } static Expression * -fix_type_cast_expression(Block *current_block, Expression *expr) { +fix_type_cast_expression(Block *current_block, Expression *expr) +{ expr->u.unary_expression = fix_expression(current_block, expr->u.unary_expression); - if (expr->type->basic_type == DOUBLE_TYPE && expr->u.unary_expression->type->basic_type == INT_TYPE) { - if (expr->u.unary_expression->kind == INT_EXPRESSION) { + if (expr->type->basic_type == DOUBLE_TYPE && expr->u.unary_expression->type->basic_type == INT_TYPE) + { + if (expr->u.unary_expression->kind == INT_EXPRESSION) + { expr->kind = DOUBLE_EXPRESSION; - expr->u.double_value = (double) expr->u.unary_expression->u.int_value; + expr->u.double_value = (double)expr->u.unary_expression->u.int_value; } - } else if (expr->type->basic_type == INT_TYPE && expr->u.unary_expression->type->basic_type == DOUBLE_TYPE) { - if (expr->u.unary_expression->kind == DOUBLE_EXPRESSION) { + } + else if (expr->type->basic_type == INT_TYPE && expr->u.unary_expression->type->basic_type == DOUBLE_TYPE) + { + if (expr->u.unary_expression->kind == DOUBLE_EXPRESSION) + { expr->kind = INT_EXPRESSION; - expr->u.int_value = (int) expr->u.unary_expression->u.double_value; + expr->u.int_value = (int)expr->u.unary_expression->u.double_value; } - } else { + } + else + { compile_error(expr->line_number, TYPE_CAST_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -382,19 +501,27 @@ fix_type_cast_expression(Block *current_block, Expression *expr) { } static void -implicit_type_cast(Expression *expr, TypeSpecifier *type) { - if (expr->kind == INT_EXPRESSION && type->basic_type == DOUBLE_TYPE) { +implicit_type_cast(Expression *expr, TypeSpecifier *type) +{ + if (expr->kind == INT_EXPRESSION && type->basic_type == DOUBLE_TYPE) + { expr->kind = DOUBLE_EXPRESSION; expr->type->basic_type = DOUBLE_TYPE; expr->u.double_value = expr->u.int_value; - } else if (expr->kind == INT_EXPRESSION && type->basic_type == AMOUNT_TYPE) { + } + else if (expr->kind == INT_EXPRESSION && type->basic_type == AMOUNT_TYPE) + { expr->type->basic_type = AMOUNT_TYPE; - } else if (expr->kind == STRING_EXPRESSION && - (type->basic_type == ASSET_TYPE || type->basic_type == HASH_TYPE || - type->basic_type == PUBKEY_TYPE || type->basic_type == SIG_TYPE || - type->basic_type == HEX_TYPE)) { + } + else if (expr->kind == STRING_EXPRESSION && + (type->basic_type == ASSET_TYPE || type->basic_type == HASH_TYPE || + type->basic_type == PUBKEY_TYPE || type->basic_type == SIG_TYPE || + type->basic_type == HEX_TYPE)) + { expr->type->basic_type = type->basic_type; - } else { + } + else + { compile_error(expr->line_number, TYPE_CAST_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -404,20 +531,24 @@ implicit_type_cast(Expression *expr, TypeSpecifier *type) { static void check_argument(Block *current_block, int line_number, - ParameterList *param_list, ArgumentList *arg) { + ParameterList *param_list, ArgumentList *arg) +{ ParameterList *param; TypeSpecifier *temp_type; for (param = param_list; param && arg; - param = param->next, arg = arg->next) { + param = param->next, arg = arg->next) + { arg->expr = fix_expression(current_block, arg->expr); - if (param->type->basic_type != arg->expr->type->basic_type) { + if (param->type->basic_type != arg->expr->type->basic_type) + { implicit_type_cast(arg->expr, param->type); } } - if (param || arg) { + if (param || arg) + { compile_error(line_number, ARGUMENT_COUNT_MISMATCH_ERR, MESSAGE_ARGUMENT_END); @@ -425,12 +556,14 @@ check_argument(Block *current_block, int line_number, } static Expression * -fix_function_call_expression(Block *current_block, Expression *expr) { +fix_function_call_expression(Block *current_block, Expression *expr) +{ Expression *func_expr = fix_expression(current_block, expr->u.func_call_expression->function); expr->u.func_call_expression->function = func_expr; BuiltinFun *builtin_fun = func_expr->u.identifier->u.builtin_func; - if (builtin_fun == NULL) { + if (builtin_fun == NULL) + { compile_error(expr->line_number, FUNCTION_NOT_FOUND_ERR, STRING_MESSAGE_ARGUMENT, "name", @@ -439,15 +572,16 @@ fix_function_call_expression(Block *current_block, Expression *expr) { } ParameterList *parameter_list = NULL; - for (int i = 0; i < builtin_fun->parameter_count; i++) { - parameter_list = chain_parameter(parameter_list, - alloc_parameter(alloc_type_specifier(builtin_fun->parameters[i]), "")); + for (int i = 0; i < builtin_fun->parameter_count; i++) + { + parameter_list = chain_parameter(parameter_list, alloc_parameter(alloc_type_specifier(builtin_fun->parameters[i]), "")); } check_argument(current_block, expr->line_number, parameter_list, expr->u.func_call_expression->argument_list); - for (ParameterList *pos = parameter_list; pos;) { + for (ParameterList *pos = parameter_list; pos;) + { ParameterList *old = pos; pos = old->next; free(old->type); @@ -458,8 +592,10 @@ fix_function_call_expression(Block *current_block, Expression *expr) { return expr; } -static Expression *init_expression(BasicType basic_type) { - switch (basic_type) { +static Expression *init_expression(BasicType basic_type) +{ + switch (basic_type) + { case AMOUNT_TYPE: case INT_TYPE: return alloc_int_expression(0); @@ -479,11 +615,13 @@ static Expression *init_expression(BasicType basic_type) { } static Expression * -fix_expression(Block *current_block, Expression *expr) { +fix_expression(Block *current_block, Expression *expr) +{ if (expr == NULL) return NULL; - switch (expr->kind) { + switch (expr->kind) + { case BOOL_EXPRESSION: expr->type = alloc_type_specifier(BOOLEAN_TYPE); break; @@ -537,7 +675,8 @@ fix_expression(Block *current_block, Expression *expr) { } static void -add_local_variable(FuncDefinition *fd, Declaration *decl) { +add_local_variable(FuncDefinition *fd, Declaration *decl) +{ fd->local_variable = realloc(fd->local_variable, sizeof(Declaration *) * (fd->local_variable_count + 1)); fd->local_variable[fd->local_variable_count] = decl; @@ -547,21 +686,27 @@ add_local_variable(FuncDefinition *fd, Declaration *decl) { static void add_declaration(Block *current_block, Declaration *decl, - FuncDefinition *fd, int line_number) { - if (search_declaration_in_current_block(decl->name, current_block)) { + FuncDefinition *fd, int line_number) +{ + if (search_declaration_in_current_block(decl->name, current_block)) + { compile_error(line_number, VARIABLE_MULTIPLE_DEFINE_ERR, STRING_MESSAGE_ARGUMENT, "name", decl->name, MESSAGE_ARGUMENT_END); } - if (current_block) { + if (current_block) + { current_block->declaration_list = chain_declaration_list(current_block->declaration_list, decl); } - if (fd) { + if (fd) + { decl->is_local = true; add_local_variable(fd, decl); - } else { + } + else + { Compiler *compiler = get_current_compiler(); decl->is_local = false; compiler->declaration_list = chain_declaration_list(compiler->declaration_list, decl); @@ -569,9 +714,11 @@ add_declaration(Block *current_block, Declaration *decl, } static void -fix_if_statement(Block *current_block, IfStatement *if_s, FuncDefinition *fd) { +fix_if_statement(Block *current_block, IfStatement *if_s, FuncDefinition *fd) +{ if_s->condition = fix_expression(current_block, if_s->condition); - if (if_s->condition->type->basic_type != BOOLEAN_TYPE) { + if (if_s->condition->type->basic_type != BOOLEAN_TYPE) + { compile_error(if_s->condition->line_number, IF_CONDITION_NOT_BOOLEAN_ERR, MESSAGE_ARGUMENT_END); @@ -579,26 +726,32 @@ fix_if_statement(Block *current_block, IfStatement *if_s, FuncDefinition *fd) { fix_statement_list(if_s->then_block, if_s->then_block->statement_list, fd); - for (Elseif *pos = if_s->elseif_list; pos; pos = pos->next) { + for (Elseif *pos = if_s->elseif_list; pos; pos = pos->next) + { pos->condition = fix_expression(current_block, pos->condition); - if (pos->block) { + if (pos->block) + { fix_statement_list(pos->block, pos->block->statement_list, fd); } } - if (if_s->else_block) { + if (if_s->else_block) + { fix_statement_list(if_s->else_block, if_s->else_block->statement_list, fd); } } static void -fix_return_statement(Block *current_block, Statement *statement, FuncDefinition *fd) { +fix_return_statement(Block *current_block, Statement *statement, FuncDefinition *fd) +{ Expression *return_value = fix_expression(current_block, statement->u.expr_s); - if (fd->return_type->basic_type == VOID_TYPE && return_value != NULL) { + if (fd->return_type->basic_type == VOID_TYPE && return_value != NULL) + { compile_error(statement->line_number, RETURN_IN_VOID_FUNCTION_ERR, MESSAGE_ARGUMENT_END); } - if (fd->return_type->basic_type != VOID_TYPE) { + if (fd->return_type->basic_type != VOID_TYPE) + { if (return_value == NULL || return_value->type->basic_type != fd->return_type->basic_type) compile_error(statement->line_number, RETURN_TYPE_MISMATCH_ERR, @@ -609,35 +762,46 @@ fix_return_statement(Block *current_block, Statement *statement, FuncDefinition } static void -fix_declaration_stmt(Block *current_block, Statement *stmt, FuncDefinition *fd) { +fix_declaration_stmt(Block *current_block, Statement *stmt, FuncDefinition *fd) +{ Declaration *decl = stmt->u.decl_s; add_declaration(current_block, decl, fd, stmt->line_number); - if (decl->initializer) { + if (decl->initializer) + { decl->initializer = fix_expression(current_block, decl->initializer); - if (!decl->type) { + if (!decl->type) + { decl->type = decl->initializer->type; - } else if (decl->initializer->type->basic_type != decl->type->basic_type) { + } + else if (decl->initializer->type->basic_type != decl->type->basic_type) + { implicit_type_cast(decl->initializer, decl->type); } - } else { + } + else + { decl->initializer = init_expression(decl->type->basic_type); } } static void -fix_assign_stmt(Block *current_block, Statement *stmt) { +fix_assign_stmt(Block *current_block, Statement *stmt) +{ AssignStatement *assign_s = stmt->u.assign_s; assign_s->left = fix_expression(current_block, assign_s->left); assign_s->operand = fix_expression(current_block, assign_s->operand); - if (assign_s->operand->type->basic_type != assign_s->left->type->basic_type) { + if (assign_s->operand->type->basic_type != assign_s->left->type->basic_type) + { implicit_type_cast(assign_s->operand, assign_s->left->type); } } static void -fix_expression_stmt(Block *current_block, Statement *stmt) { +fix_expression_stmt(Block *current_block, Statement *stmt) +{ stmt->u.expr_s = fix_expression(current_block, stmt->u.expr_s); - if (stmt->u.expr_s->kind != FUNC_CALL_EXPRESSION) { + if (stmt->u.expr_s->kind != FUNC_CALL_EXPRESSION) + { compile_error(stmt->line_number, EXPR_EVALUATED_BUT_NOT_USED, MESSAGE_ARGUMENT_END); @@ -645,8 +809,10 @@ fix_expression_stmt(Block *current_block, Statement *stmt) { } static void -fix_statement(Block *current_block, Statement *statement, FuncDefinition *fd) { - switch (statement->kind) { +fix_statement(Block *current_block, Statement *statement, FuncDefinition *fd) +{ + switch (statement->kind) + { case IF_STATEMENT: fix_if_statement(current_block, statement->u.if_s, fd); break; @@ -671,35 +837,41 @@ fix_statement(Block *current_block, Statement *statement, FuncDefinition *fd) { } static void -fix_statement_list(Block *current_block, StatementList *list, FuncDefinition *fd) { +fix_statement_list(Block *current_block, StatementList *list, FuncDefinition *fd) +{ StatementList *pos; - for (pos = list; pos; pos = pos->next) { + for (pos = list; pos; pos = pos->next) + { fix_statement(current_block, pos->statement, fd); } } static void -add_parameter_as_declaration(FuncDefinition *fd) { +add_parameter_as_declaration(FuncDefinition *fd) +{ Declaration *decl; ParameterList *param; - for (param = fd->parameters; param; param = param->next) { + for (param = fd->parameters; param; param = param->next) + { decl = alloc_declaration(param->name, param->type, NULL); - if (fd->code_block) { + if (fd->code_block) + { add_declaration(fd->code_block, decl, fd, param->line_number); } } } static int -reserve_function_index(Compiler *compiler, FuncDefinition *src) { +reserve_function_index(Compiler *compiler, FuncDefinition *src) +{ int i; SVM_Function *dest; compiler->svm_function = realloc(compiler->svm_function, - sizeof(SVM_Function) * (compiler->svm_function_count + 1)); + sizeof(SVM_Function) * (compiler->svm_function_count+1)); dest = &compiler->svm_function[compiler->svm_function_count]; compiler->svm_function_count++; @@ -708,14 +880,17 @@ reserve_function_index(Compiler *compiler, FuncDefinition *src) { return compiler->svm_function_count - 1; } -static void fix_function(FuncDefinition *fd) { +static void fix_function(FuncDefinition *fd) +{ add_parameter_as_declaration(fd); - if (fd->code_block) { + if (fd->code_block) + { fix_statement_list(fd->code_block, fd->code_block->statement_list, fd); } } -void fix_tree(Compiler *compiler) { +void fix_tree(Compiler *compiler) +{ FuncDefinition *func_pos; for (func_pos = compiler->func_definition_list; func_pos; @@ -725,7 +900,8 @@ void fix_tree(Compiler *compiler) { fix_statement_list(NULL, compiler->stmt_list, NULL); - for (func_pos = compiler->func_definition_list; func_pos; func_pos = func_pos->next) { + for (func_pos = compiler->func_definition_list; func_pos; func_pos = func_pos->next) + { fix_function(func_pos); } } \ No newline at end of file