parse_block gets a warn-return bool flag

[xonotic/gmqcc.git] / ast.c

diff --git a/ast.c b/ast.c
index bca493e606285cf59b8e15ffc56dfe4c861645ab..7c349b4638657b2cfa52dbe8866479dcf4e65199 100644 (file)
--- 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;
     }