vararg accessor generation

[xonotic/gmqcc.git] / ast.c

diff --git a/ast.c b/ast.c
index 2a1446c739933813ebb4d96be94ff122b0bab6a1..0f5b05ca4a98383e22e61f4989c451ce94e353e5 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013
  *     Wolfgang Bumiller
  *     Dale Weiler 
  *
@@ -75,6 +75,7 @@ static void ast_expression_init(ast_expression *self,
     self->expression.params   = NULL;
     self->expression.count    = 0;
     self->expression.flags    = 0;
+    self->expression.varparam = NULL;
 }
 
 static void ast_expression_delete(ast_expression *self)
@@ -347,6 +348,8 @@ ast_value* ast_value_new(lex_ctx ctx, const char *name, int t)
     self->getter = NULL;
     self->desc   = NULL;
 
+    self->argcounter = NULL;
+
     return self;
 }
 
@@ -354,6 +357,8 @@ void ast_value_delete(ast_value* self)
 {
     if (self->name)
         mem_d((void*)self->name);
+    if (self->argcounter)
+        mem_d((void*)self->argcounter);
     if (self->hasvalue) {
         switch (self->expression.vtype)
         {
@@ -724,9 +729,12 @@ ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *
 
 void ast_ternary_delete(ast_ternary *self)
 {
-    ast_unref(self->cond);
-    ast_unref(self->on_true);
-    ast_unref(self->on_false);
+    /* the if()s are only there because computed-gotos can set them
+     * to NULL
+     */
+    if (self->cond)     ast_unref(self->cond);
+    if (self->on_true)  ast_unref(self->on_true);
+    if (self->on_false) ast_unref(self->on_false);
     ast_expression_delete((ast_expression*)self);
     mem_d(self);
 }
@@ -826,14 +834,17 @@ void ast_switch_delete(ast_switch *self)
     mem_d(self);
 }
 
-ast_label* ast_label_new(lex_ctx ctx, const char *name)
+ast_label* ast_label_new(lex_ctx ctx, const char *name, bool undefined)
 {
     ast_instantiate(ast_label, ctx, ast_label_delete);
     ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_label_codegen);
 
-    self->name    = util_strdup(name);
-    self->irblock = NULL;
-    self->gotos   = NULL;
+    self->expression.vtype = TYPE_NOEXPR;
+
+    self->name      = util_strdup(name);
+    self->irblock   = NULL;
+    self->gotos     = NULL;
+    self->undefined = undefined;
 
     return self;
 }
@@ -907,6 +918,8 @@ void ast_call_delete(ast_call *self)
 
 bool ast_call_check_types(ast_call *self)
 {
+    char texp[1024];
+    char tgot[1024];
     size_t i;
     bool   retval = true;
     const  ast_expression *func = self->func;
@@ -917,8 +930,6 @@ bool ast_call_check_types(ast_call *self)
     for (i = 0; i < count; ++i) {
         if (!ast_compare_type(self->params[i], (ast_expression*)(func->expression.params[i])))
         {
-            char texp[1024];
-            char tgot[1024];
             ast_type_to_string(self->params[i], tgot, sizeof(tgot));
             ast_type_to_string((ast_expression*)func->expression.params[i], texp, sizeof(texp));
             compile_error(ast_ctx(self), "invalid type for parameter %u in function call: expected %s, got %s",
@@ -927,6 +938,20 @@ bool ast_call_check_types(ast_call *self)
             retval = false;
         }
     }
+    count = vec_size(self->params);
+    if (count > vec_size(func->expression.params) && func->expression.varparam) {
+        for (; i < count; ++i) {
+            if (!ast_compare_type(self->params[i], func->expression.varparam))
+            {
+                ast_type_to_string(self->params[i], tgot, sizeof(tgot));
+                ast_type_to_string(func->expression.varparam, texp, sizeof(texp));
+                compile_error(ast_ctx(self), "invalid type for parameter %u in function call: expected %s, got %s",
+                         (unsigned int)(i+1), texp, tgot);
+                /* we don't immediately return */
+                retval = false;
+            }
+        }
+    }
     return retval;
 }
 
@@ -1049,6 +1074,8 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype)
     vtype->hasvalue = true;
     vtype->constval.vfunc = self;
 
+    self->varargs = NULL;
+
     return self;
 }
 
@@ -1071,6 +1098,8 @@ void ast_function_delete(ast_function *self)
     vec_free(self->blocks);
     vec_free(self->breakblocks);
     vec_free(self->continueblocks);
+    if (self->varargs)
+        ast_delete(self->varargs);
     mem_d(self);
 }
 
@@ -1158,6 +1187,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
 
         self->constval.vfunc->ir_func = func;
         self->ir_v = func->value;
+        if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
+            self->ir_v->flags |= IR_FLAG_INCLUDE_DEF;
         /* The function is filled later on ast_function_codegen... */
         return true;
     }
@@ -1200,6 +1231,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
             v->unique_life = true;
             v->locked      = true;
             array->ir_v = self->ir_v = v;
+            if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
+                self->ir_v->flags |= IR_FLAG_INCLUDE_DEF;
 
             namelen = strlen(self->name);
             name    = (char*)mem_a(namelen + 16);
@@ -1218,6 +1251,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
                 array->ir_values[ai]->context = ast_ctx(self);
                 array->ir_values[ai]->unique_life = true;
                 array->ir_values[ai]->locked      = true;
+                if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
+                    self->ir_values[ai]->flags |= IR_FLAG_INCLUDE_DEF;
             }
             mem_d(name);
         }
@@ -1228,6 +1263,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
                 return false;
             v->context = ast_ctx(self);
             self->ir_v = v;
+            if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
+                self->ir_v->flags |= IR_FLAG_INCLUDE_DEF;
         }
         return true;
     }
@@ -1252,6 +1289,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
         v->context = ast_ctx(self);
         v->unique_life = true;
         v->locked      = true;
+        if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
+            v->flags |= IR_FLAG_INCLUDE_DEF;
 
         namelen = strlen(self->name);
         name    = (char*)mem_a(namelen + 16);
@@ -1270,6 +1309,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
             self->ir_values[ai]->context = ast_ctx(self);
             self->ir_values[ai]->unique_life = true;
             self->ir_values[ai]->locked      = true;
+            if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
+                self->ir_values[ai]->flags |= IR_FLAG_INCLUDE_DEF;
         }
         mem_d(name);
     }
@@ -1332,6 +1373,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
     /* link us to the ir_value */
     v->cvq = self->cvq;
     self->ir_v = v;
+    if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
+        self->ir_v->flags |= IR_FLAG_INCLUDE_DEF;
     return true;
 
 error: /* clean up */
@@ -1366,7 +1409,7 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param)
 
         func->flags |= IR_FLAG_HAS_ARRAYS;
 
-        if (param) {
+        if (param && !(self->expression.flags & AST_FLAG_IS_VARARG)) {
             compile_error(ast_ctx(self), "array-parameters are not supported");
             return false;
         }
@@ -1532,6 +1575,11 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir)
         }
     }
 
+    if (self->varargs) {
+        if (!ast_local_codegen(self->varargs, self->ir_func, true))
+            return false;
+    }
+
     if (self->builtin) {
         irf->builtin = self->builtin;
         return true;
@@ -1846,6 +1894,7 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va
         }
 
         self->expression.outr = *out;
+        codegen_output_type(self, *out);
         return true;
     }
 
@@ -1862,6 +1911,7 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va
     if (!*out)
         return false;
     self->expression.outr = *out;
+    codegen_output_type(self, *out);
 
     return true;
 }
@@ -2866,6 +2916,11 @@ bool ast_label_codegen(ast_label *self, ast_function *func, bool lvalue, ir_valu
     size_t i;
     ir_value *dummy;
 
+    if (self->undefined) {
+        compile_error(ast_ctx(self), "internal error: ast_label never defined");
+        return false;
+    }
+
     *out = NULL;
     if (lvalue) {
         compile_error(ast_ctx(self), "internal error: ast_label cannot be an lvalue");