X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;ds=sidebyside;f=ast.c;h=7c349b4638657b2cfa52dbe8866479dcf4e65199;hb=66ec592f947b92ce1a07f2d6638f76a3d311d118;hp=bca493e606285cf59b8e15ffc56dfe4c861645ab;hpb=3effcd234298c5b135dd9ebfe2ade11986136f75;p=xonotic%2Fgmqcc.git diff --git a/ast.c b/ast.c index bca493e..7c349b4 100644 --- a/ast.c +++ b/ast.c @@ -91,9 +91,11 @@ static void ast_expression_delete_full(ast_expression *self) MEM_VEC_FUNCTIONS(ast_expression_common, ast_value*, params) -static ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex); -static ast_value* ast_value_copy(const ast_value *self) +ast_value* ast_value_copy(const ast_value *self) { + size_t i; + const ast_expression_common *fromex; + ast_expression_common *selfex; ast_value *cp = ast_value_new(self->expression.node.context, self->name, self->expression.vtype); if (self->expression.next) { cp->expression.next = ast_type_copy(self->expression.node.context, self->expression.next); @@ -102,9 +104,39 @@ static ast_value* ast_value_copy(const ast_value *self) return NULL; } } + fromex = &self->expression; + selfex = &cp->expression; + for (i = 0; i < fromex->params_count; ++i) { + ast_value *v = ast_value_copy(fromex->params[i]); + if (!v || !ast_expression_common_params_add(selfex, v)) { + ast_value_delete(cp); + return NULL; + } + } return cp; } +bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other) +{ + size_t i; + const ast_expression_common *fromex; + ast_expression_common *selfex; + self->expression.vtype = other->expression.vtype; + if (other->expression.next) { + self->expression.next = (ast_expression*)ast_type_copy(ast_ctx(self), other->expression.next); + if (!self->expression.next) + return false; + } + fromex = &other->expression; + selfex = &self->expression; + for (i = 0; i < fromex->params_count; ++i) { + ast_value *v = ast_value_copy(fromex->params[i]); + if (!v || !ast_expression_common_params_add(selfex, v)) + return false; + } + return true; +} + static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) { ast_instantiate(ast_expression, ctx, ast_expression_delete_full); @@ -115,7 +147,7 @@ static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) return self; } -static ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) +ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) { size_t i; const ast_expression_common *fromex; @@ -310,6 +342,11 @@ ast_unary* ast_unary_new(lex_ctx ctx, int op, self->op = op; self->operand = expr; + if (op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) { + self->expression.vtype = TYPE_FLOAT; + } else + asterror(ctx, "cannot determine type of unary operation %s", asm_instr[op].m); + return self; } @@ -332,7 +369,8 @@ ast_return* ast_return_new(lex_ctx ctx, ast_expression *expr) void ast_return_delete(ast_return *self) { - ast_unref(self->operand); + if (self->operand) + ast_unref(self->operand); ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -357,12 +395,14 @@ ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expressi ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_entfield_codegen); - self->expression.vtype = outtype->expression.vtype; - self->expression.next = ast_type_copy(ctx, outtype->expression.next); - self->entity = entity; self->field = field; + if (!ast_type_adopt(self, outtype)) { + ast_entfield_delete(self); + return NULL; + } + return self; } @@ -520,6 +560,10 @@ ast_call* ast_call_new(lex_ctx ctx, self->func = funcexpr; + self->expression.vtype = funcexpr->expression.next->expression.vtype; + if (funcexpr->expression.next->expression.next) + self->expression.next = ast_type_copy(ctx, funcexpr->expression.next->expression.next); + return self; } MEM_VEC_FUNCTIONS(ast_call, ast_expression*, params) @@ -609,6 +653,8 @@ bool ast_block_set_type(ast_block *self, ast_expression *from) if (!self->expression.next) return false; } + else + self->expression.next = NULL; return true; } @@ -730,6 +776,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) ir_function *func = ir_builder_create_function(ir, self->name, self->expression.next->expression.vtype); if (!func) return false; + func->context = ast_ctx(self); self->constval.vfunc->ir_func = func; self->ir_v = func->value; @@ -1121,13 +1168,18 @@ bool ast_return_codegen(ast_return *self, ast_function *func, bool lvalue, ir_va } self->expression.outr = (ir_value*)1; - cgen = self->operand->expression.codegen; - /* lvalue! */ - if (!(*cgen)((ast_expression*)(self->operand), func, false, &operand)) - return false; + if (self->operand) { + cgen = self->operand->expression.codegen; + /* lvalue! */ + if (!(*cgen)((ast_expression*)(self->operand), func, false, &operand)) + return false; - if (!ir_block_create_return(func->curblock, operand)) - return false; + if (!ir_block_create_return(func->curblock, operand)) + return false; + } else { + if (!ir_block_create_return(func->curblock, NULL)) + return false; + } return true; } @@ -1281,9 +1333,9 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va return false; /* add jumps ot the merge block */ - if (ontrue && !ir_block_create_jump(ontrue, merge)) + if (ontrue && !ontrue->final && !ir_block_create_jump(ontrue, merge)) return false; - if (onfalse && !ir_block_create_jump(onfalse, merge)) + if (onfalse && !onfalse->final && !ir_block_create_jump(onfalse, merge)) return false; /* we create the if here, that way all blocks are ordered :) @@ -1601,7 +1653,7 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value else if (bpostcond) tmpblock = bpostcond; else if (bprecond) tmpblock = bprecond; else tmpblock = bout; - if (!ir_block_create_jump(end_bbody, tmpblock)) + if (!end_bbody->final && !ir_block_create_jump(end_bbody, tmpblock)) return false; }