fixed a typo in asm_instr[]: ES_FNC->EQ_FNC

[xonotic/gmqcc.git] / ast.c

diff --git a/ast.c b/ast.c
index 00ab6117c407a34044dc817bb3f7b6fa81a297ee..065dfd88dbf2d4fb80dd09c8c70caaa66475cfa7 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -36,7 +36,7 @@
     ( (ast_node*)self )->node.destroy = (ast_node_delete*)destroyfn
 
 /* It must not be possible to get here. */
-static void _ast_node_destroy(ast_node *self)
+static GMQCC_NORETURN void _ast_node_destroy(ast_node *self)
 {
     fprintf(stderr, "ast node missing destroy()\n");
     abort();
@@ -308,6 +308,31 @@ void ast_loop_delete(ast_loop *self)
     mem_d(self);
 }
 
+ast_call* ast_call_new(lex_ctx ctx,
+                       ast_expression *funcexpr)
+{
+    ast_instantiate(ast_call, ctx, ast_call_delete);
+    ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_call_codegen);
+
+    MEM_VECTOR_INIT(self, params);
+
+    return self;
+}
+
+void ast_call_delete(ast_call *self)
+{
+    size_t i;
+    for (i = 0; i < self->params_count; ++i)
+        ast_unref(self->params[i]);
+    MEM_VECTOR_CLEAR(self, params);
+
+    if (self->func)
+        ast_unref(self->func);
+
+    ast_expression_delete((ast_expression*)self);
+    mem_d(self);
+}
+
 ast_store* ast_store_new(lex_ctx ctx, int op,
                          ast_value *dest, ast_expression *source)
 {
@@ -468,7 +493,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir)
     ir_value *v = NULL;
     if (self->isconst && self->expression.vtype == TYPE_FUNCTION)
     {
-        ir_function *func = ir_builder_create_function(ir, self->name);
+        ir_function *func = ir_builder_create_function(ir, self->name, self->expression.next->expression.vtype);
         if (!func)
             return false;
 
@@ -772,7 +797,7 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va
             return false;
     } else
         ontrue = NULL;
-    
+
     /* on-false path */
     if (self->on_false) {
         /* create on-false block */
@@ -793,7 +818,7 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va
     /* Merge block were they all merge in to */
     merge = ir_function_create_block(func->ir_func, ast_function_label(func, "endif"));
     if (!merge)
-        return NULL;
+        return false;
 
     /* add jumps ot the merge block */
     if (ontrue && !ir_block_create_jump(ontrue, merge))
@@ -844,7 +869,7 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_
         return false;
 
     /* In the following, contraty to ast_ifthen, we assume both paths exist. */
-    
+
     /* generate the condition */
     func->curblock = cond;
     cgen = self->cond->expression.codegen;
@@ -865,7 +890,7 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_
         if (!(*cgen)((ast_expression*)(self->on_true), func, false, &trueval))
             return false;
     }
-    
+
     /* create on-false block */
     onfalse = ir_function_create_block(func->ir_func, ast_function_label(func, "tern_F"));
     if (!onfalse)
@@ -884,7 +909,7 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_
     /* create merge block */
     merge = ir_function_create_block(func->ir_func, ast_function_label(func, "tern_out"));
     if (!merge)
-        return NULL;
+        return false;
     /* jump to merge block */
     if (!ir_block_create_jump(ontrue, merge))
         return false;
@@ -925,31 +950,31 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value
 {
     ast_expression_codegen *cgen;
 
-    ir_value *dummy;
-    ir_value *precond;
-    ir_value *postcond;
+    ir_value *dummy      = NULL;
+    ir_value *precond    = NULL;
+    ir_value *postcond   = NULL;
 
     /* Since we insert some jumps "late" so we have blocks
      * ordered "nicely", we need to keep track of the actual end-blocks
      * of expressions to add the jumps to.
      */
-    ir_block *bbody,      *end_bbody;
-    ir_block *bprecond,   *end_bprecond;
-    ir_block *bpostcond,  *end_bpostcond;
-    ir_block *bincrement, *end_bincrement;
-    ir_block *bout, *bin;
+    ir_block *bbody      = NULL, *end_bbody      = NULL;
+    ir_block *bprecond   = NULL, *end_bprecond   = NULL;
+    ir_block *bpostcond  = NULL, *end_bpostcond  = NULL;
+    ir_block *bincrement = NULL, *end_bincrement = NULL;
+    ir_block *bout       = NULL, *bin            = NULL;
 
     /* let's at least move the outgoing block to the end */
     size_t    bout_id;
 
     /* 'break' and 'continue' need to be able to find the right blocks */
-    ir_block *bcontinue = NULL;
-    ir_block *bbreak    = NULL;
+    ir_block *bcontinue     = NULL;
+    ir_block *bbreak        = NULL;
 
-    ir_block *old_bcontinue;
-    ir_block *old_bbreak;
+    ir_block *old_bcontinue = NULL;
+    ir_block *old_bbreak    = NULL;
 
-    ir_block *tmpblock;
+    ir_block *tmpblock      = NULL;
 
     (void)lvalue;
     (void)out;
@@ -1148,3 +1173,56 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value
 
     return true;
 }
+
+bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value **out)
+{
+    /* TODO: call ir codegen */
+    ast_expression_codegen *cgen;
+    ir_value_vector         params;
+    ir_instr               *callinstr;
+    size_t i;
+
+    ir_value *funval = NULL;
+
+    /* return values are never rvalues */
+    (void)lvalue;
+
+    cgen = self->func->expression.codegen;
+    if (!(*cgen)((ast_expression*)(self->func), func, false, &funval))
+        return false;
+    if (!funval)
+        return false;
+
+    MEM_VECTOR_INIT(&params, v);
+
+    /* parameters */
+    for (i = 0; i < self->params_count; ++i)
+    {
+        ir_value *param;
+        ast_expression *expr = self->params[i];
+
+        cgen = expr->expression.codegen;
+        if (!(*cgen)(expr, func, false, &param))
+            goto error;
+        if (!param)
+            goto error;
+        if (!ir_value_vector_v_add(&params, param))
+            goto error;
+    }
+
+    callinstr = ir_block_create_call(func->curblock, ast_function_label(func, "call"), funval);
+    if (!callinstr)
+        goto error;
+
+    for (i = 0; i < params.v_count; ++i) {
+        if (!ir_call_param(callinstr, params.v[i]))
+            goto error;
+    }
+
+    *out = ir_call_value(callinstr);
+
+    return true;
+error:
+    MEM_VECTOR_CLEAR(&params, v);
+    return false;
+}