X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ast.c;h=ae710d6aeb2699038a53e881dd55f29e5db4d732;hp=43d770d8da44ca389c759d3feee3cac010d0b6b2;hb=160e7cf7eebd7fa173fb739aca00143097a3518b;hpb=a17015492758a0471e2631d3b5a030a29b51772a

diff --git a/ast.c b/ast.c
index 43d770d..ae710d6 100644
--- a/ast.c
+++ b/ast.c
@@ -1,7 +1,7 @@
 /*
- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013
  *     Wolfgang Bumiller
- *     Dale Weiler 
+ *     Dale Weiler
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  * this software and associated documentation files (the "Software"), to deal in
@@ -42,7 +42,7 @@ static GMQCC_NORETURN void _ast_node_destroy(ast_node *self)
 {
     (void)self;
     con_err("ast node missing destroy()\n");
-    abort();
+    exit(EXIT_FAILURE);
 }
 
 /* Initialize main ast node aprts */
@@ -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)
@@ -86,6 +87,8 @@ static void ast_expression_delete(ast_expression *self)
         ast_delete(self->expression.params[i]);
     }
     vec_free(self->expression.params);
+    if (self->expression.varparam)
+        ast_delete(self->expression.varparam);
 }
 
 static void ast_expression_delete_full(ast_expression *self)
@@ -102,10 +105,6 @@ ast_value* ast_value_copy(const ast_value *self)
     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);
-        if (!cp->expression.next) {
-            ast_value_delete(cp);
-            return NULL;
-        }
     }
     fromex   = &self->expression;
     selfex = &cp->expression;
@@ -113,16 +112,12 @@ ast_value* ast_value_copy(const ast_value *self)
     selfex->flags    = fromex->flags;
     for (i = 0; i < vec_size(fromex->params); ++i) {
         ast_value *v = ast_value_copy(fromex->params[i]);
-        if (!v) {
-            ast_value_delete(cp);
-            return NULL;
-        }
         vec_push(selfex->params, v);
     }
     return cp;
 }
 
-bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other)
+void ast_type_adopt_impl(ast_expression *self, const ast_expression *other)
 {
     size_t i;
     const ast_expression_common *fromex;
@@ -130,8 +125,6 @@ bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other)
     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;
@@ -139,11 +132,8 @@ bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other)
     selfex->flags    = fromex->flags;
     for (i = 0; i < vec_size(fromex->params); ++i) {
         ast_value *v = ast_value_copy(fromex->params[i]);
-        if (!v)
-            return false;
         vec_push(selfex->params, v);
     }
-    return true;
 }
 
 static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype)
@@ -177,13 +167,7 @@ ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex)
 
         selfex->vtype = fromex->vtype;
         if (fromex->next)
-        {
             selfex->next = ast_type_copy(ctx, fromex->next);
-            if (!selfex->next) {
-                ast_expression_delete_full(self);
-                return NULL;
-            }
-        }
         else
             selfex->next = NULL;
 
@@ -191,10 +175,6 @@ ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex)
         selfex->flags    = fromex->flags;
         for (i = 0; i < vec_size(fromex->params); ++i) {
             ast_value *v = ast_value_copy(fromex->params[i]);
-            if (!v) {
-                ast_expression_delete_full(self);
-                return NULL;
-            }
             vec_push(selfex->params, v);
         }
 
@@ -240,7 +220,7 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi
     if (!e) {
         if (pos + 6 >= bufsize)
             goto full;
-        strcpy(buf + pos, "(null)");
+        strncpy(buf + pos, "(null)", 6);
         return pos + 6;
     }
 
@@ -249,7 +229,7 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi
 
     switch (e->expression.vtype) {
         case TYPE_VARIANT:
-            strcpy(buf + pos, "(variant)");
+            strncpy(buf + pos, "(variant)", 9);
             return pos + 9;
 
         case TYPE_FIELD:
@@ -306,7 +286,7 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi
             typelen = strlen(typestr);
             if (pos + typelen >= bufsize)
                 goto full;
-            strcpy(buf + pos, typestr);
+            strncpy(buf + pos, typestr, typelen);
             return pos + typelen;
     }
 
@@ -347,6 +327,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 +336,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)
         {
@@ -424,13 +408,17 @@ ast_binary* ast_binary_new(lex_ctx ctx, int op,
     else
         self->expression.vtype = left->expression.vtype;
 
+    /* references all */
+    self->refs = AST_REF_ALL;
+
     return self;
 }
 
 void ast_binary_delete(ast_binary *self)
 {
-    ast_unref(self->left);
-    ast_unref(self->right);
+    if (self->refs & AST_REF_LEFT)  ast_unref(self->left);
+    if (self->refs & AST_REF_RIGHT) ast_unref(self->right);
+
     ast_expression_delete((ast_expression*)self);
     mem_d(self);
 }
@@ -450,11 +438,7 @@ ast_binstore* ast_binstore_new(lex_ctx ctx, int storop, int op,
 
     self->keep_dest = false;
 
-    if (!ast_type_adopt(self, left)) {
-        ast_delete(self);
-        return NULL;
-    }
-
+    ast_type_adopt(self, left);
     return self;
 }
 
@@ -540,11 +524,7 @@ ast_entfield* ast_entfield_new_force(lex_ctx ctx, ast_expression *entity, ast_ex
     ast_propagate_effects(self, entity);
     ast_propagate_effects(self, field);
 
-    if (!ast_type_adopt(self, outtype)) {
-        ast_entfield_delete(self);
-        return NULL;
-    }
-
+    ast_type_adopt(self, outtype);
     return self;
 }
 
@@ -606,6 +586,7 @@ void ast_member_delete(ast_member *self)
      * purpose that is not garbage-collected.
     */
     ast_expression_delete((ast_expression*)self);
+    mem_d(self->name);
     mem_d(self);
 }
 
@@ -636,10 +617,7 @@ ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_exp
     ast_propagate_effects(self, array);
     ast_propagate_effects(self, index);
 
-    if (!ast_type_adopt(self, outtype)) {
-        ast_array_index_delete(self);
-        return NULL;
-    }
+    ast_type_adopt(self, outtype);
     if (array->expression.vtype == TYPE_FIELD && outtype->expression.vtype == TYPE_ARRAY) {
         if (self->expression.vtype != TYPE_ARRAY) {
             compile_error(ast_ctx(self), "array_index node on type");
@@ -655,8 +633,10 @@ ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_exp
 
 void ast_array_index_delete(ast_array_index *self)
 {
-    ast_unref(self->array);
-    ast_unref(self->index);
+    if (self->array)
+        ast_unref(self->array);
+    if (self->index)
+        ast_unref(self->index);
     ast_expression_delete((ast_expression*)self);
     mem_d(self);
 }
@@ -714,19 +694,19 @@ ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *
 
     if (ontrue->expression.vtype == TYPE_NIL)
         exprtype = onfalse;
-    if (!ast_type_adopt(self, exprtype)) {
-        ast_ternary_delete(self);
-        return NULL;
-    }
+    ast_type_adopt(self, exprtype);
 
     return self;
 }
 
 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 +806,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;
 }
@@ -879,12 +862,18 @@ ast_call* ast_call_new(lex_ctx ctx,
                        ast_expression *funcexpr)
 {
     ast_instantiate(ast_call, ctx, ast_call_delete);
+    if (!funcexpr->expression.next) {
+        compile_error(ctx, "not a function");
+        mem_d(self);
+        return NULL;
+    }
     ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_call_codegen);
 
     ast_side_effects(self) = true;
 
-    self->params = NULL;
-    self->func   = funcexpr;
+    self->params   = NULL;
+    self->func     = funcexpr;
+    self->va_count = NULL;
 
     ast_type_adopt(self, funcexpr->expression.next);
 
@@ -901,12 +890,17 @@ void ast_call_delete(ast_call *self)
     if (self->func)
         ast_unref(self->func);
 
+    if (self->va_count)
+        ast_unref(self->va_count);
+
     ast_expression_delete((ast_expression*)self);
     mem_d(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 +911,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 +919,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;
 }
 
@@ -942,10 +948,7 @@ ast_store* ast_store_new(lex_ctx ctx, int op,
     self->dest = dest;
     self->source = source;
 
-    if (!ast_type_adopt(self, dest)) {
-        ast_delete(self);
-        return NULL;
-    }
+    ast_type_adopt(self, dest);
 
     return self;
 }
@@ -979,10 +982,7 @@ bool ast_block_add_expr(ast_block *self, ast_expression *e)
         ast_delete(self->expression.next);
         self->expression.next = NULL;
     }
-    if (!ast_type_adopt(self, e)) {
-        compile_error(ast_ctx(self), "internal error: failed to adopt type");
-        return false;
-    }
+    ast_type_adopt(self, e);
     return true;
 }
 
@@ -1008,13 +1008,11 @@ void ast_block_delete(ast_block *self)
     mem_d(self);
 }
 
-bool ast_block_set_type(ast_block *self, ast_expression *from)
+void ast_block_set_type(ast_block *self, ast_expression *from)
 {
     if (self->expression.next)
         ast_delete(self->expression.next);
-    if (!ast_type_adopt(self, from))
-        return false;
-    return true;
+    ast_type_adopt(self, from);
 }
 
 ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype)
@@ -1049,6 +1047,10 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype)
     vtype->hasvalue = true;
     vtype->constval.vfunc = self;
 
+    self->varargs     = NULL;
+    self->argc        = NULL;
+    self->fixedparams = NULL;
+
     return self;
 }
 
@@ -1071,6 +1073,12 @@ 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);
+    if (self->argc)
+        ast_delete(self->argc);
+    if (self->fixedparams)
+        ast_unref(self->fixedparams);
     mem_d(self);
 }
 
@@ -1080,8 +1088,12 @@ const char* ast_function_label(ast_function *self, const char *prefix)
     size_t len;
     char  *from;
 
-    if (!opts.dump && !opts.dumpfin && !opts.debug)
+    if (!OPTS_OPTION_BOOL(OPTION_DUMP)    &&
+        !OPTS_OPTION_BOOL(OPTION_DUMPFIN) &&
+        !OPTS_OPTION_BOOL(OPTION_DEBUG))
+    {
         return NULL;
+    }
 
     id  = (self->labelcount++);
     len = strlen(prefix);
@@ -1158,6 +1170,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;
     }
@@ -1185,7 +1199,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
             }
 
             /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */
-            if (!array->expression.count || array->expression.count > opts.max_array_size)
+            if (!array->expression.count || array->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE))
                 compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)array->expression.count);
 
             elemtype = &array->expression.next->expression;
@@ -1200,10 +1214,12 @@ 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);
-            strcpy(name, self->name);
+            strncpy(name, self->name, namelen);
 
             array->ir_values = (ir_value**)mem_a(sizeof(array->ir_values[0]) * array->expression.count);
             array->ir_values[0] = v;
@@ -1218,6 +1234,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 +1246,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;
     }
@@ -1241,7 +1261,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
         int vtype = elemtype->vtype;
 
         /* same as with field arrays */
-        if (!self->expression.count || self->expression.count > opts.max_array_size)
+        if (!self->expression.count || self->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE))
             compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count);
 
         v = ir_builder_create_global(ir, self->name, vtype);
@@ -1252,10 +1272,12 @@ 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);
-        strcpy(name, self->name);
+        strncpy(name, self->name, namelen);
 
         self->ir_values = (ir_value**)mem_a(sizeof(self->ir_values[0]) * self->expression.count);
         self->ir_values[0] = v;
@@ -1270,6 +1292,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 +1356,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,13 +1392,13 @@ 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;
         }
 
         /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */
-        if (!self->expression.count || self->expression.count > opts.max_array_size) {
+        if (!self->expression.count || self->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE)) {
             compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count);
         }
 
@@ -1384,7 +1410,7 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param)
 
         v = ir_function_create_local(func, self->name, vtype, param);
         if (!v) {
-            compile_error(ast_ctx(self), "ir_function_create_local failed");
+            compile_error(ast_ctx(self), "internal error: ir_function_create_local failed");
             return false;
         }
         v->context = ast_ctx(self);
@@ -1393,20 +1419,21 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param)
 
         namelen = strlen(self->name);
         name    = (char*)mem_a(namelen + 16);
-        strcpy(name, self->name);
+        strncpy(name, self->name, namelen);
 
         self->ir_values[0] = v;
         for (ai = 1; ai < self->expression.count; ++ai) {
             snprintf(name + namelen, 16, "[%u]", (unsigned int)ai);
             self->ir_values[ai] = ir_function_create_local(func, name, vtype, param);
             if (!self->ir_values[ai]) {
-                compile_error(ast_ctx(self), "ir_builder_create_global failed on `%s`", name);
+                compile_error(ast_ctx(self), "internal_error: ir_builder_create_global failed on `%s`", name);
                 return false;
             }
             self->ir_values[ai]->context = ast_ctx(self);
             self->ir_values[ai]->unique_life = true;
             self->ir_values[ai]->locked      = true;
         }
+        mem_d(name);
     }
     else
     {
@@ -1507,14 +1534,15 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir)
 {
     ir_function *irf;
     ir_value    *dummy;
-    ast_expression_common *ec;
+    ast_expression_common  *ec;
+    ast_expression_codegen *cgen;
     size_t    i;
 
     (void)ir;
 
     irf = self->ir_func;
     if (!irf) {
-        compile_error(ast_ctx(self), "ast_function's related ast_value was not generated yet");
+        compile_error(ast_ctx(self), "internal error: ast_function's related ast_value was not generated yet");
         return false;
     }
 
@@ -1532,6 +1560,12 @@ 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;
+        irf->max_varargs = self->varargs->expression.count;
+    }
+
     if (self->builtin) {
         irf->builtin = self->builtin;
         return true;
@@ -1542,15 +1576,39 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir)
         return false;
     }
 
-    self->curblock = ir_function_create_block(ast_ctx(self), irf, "entry");
+    irf->first = self->curblock = ir_function_create_block(ast_ctx(self), irf, "entry");
     if (!self->curblock) {
         compile_error(ast_ctx(self), "failed to allocate entry block for `%s`", self->name);
         return false;
     }
 
+    if (self->argc) {
+        ir_value *va_count;
+        ir_value *fixed;
+        ir_value *sub;
+        if (!ast_local_codegen(self->argc, self->ir_func, true))
+            return false;
+        cgen = self->argc->expression.codegen;
+        if (!(*cgen)((ast_expression*)(self->argc), self, false, &va_count))
+            return false;
+        cgen = self->fixedparams->expression.codegen;
+        if (!(*cgen)((ast_expression*)(self->fixedparams), self, false, &fixed))
+            return false;
+        sub = ir_block_create_binop(self->curblock, ast_ctx(self),
+                                    ast_function_label(self, "va_count"), INSTR_SUB_F,
+                                    ir_builder_get_va_count(ir), fixed);
+        if (!sub)
+            return false;
+        if (!ir_block_create_store_op(self->curblock, ast_ctx(self), INSTR_STORE_F,
+                                      va_count, sub))
+        {
+            return false;
+        }
+    }
+
     for (i = 0; i < vec_size(self->blocks); ++i) {
-        ast_expression_codegen *gen = self->blocks[i]->expression.codegen;
-        if (!(*gen)((ast_expression*)self->blocks[i], self, false, &dummy))
+        cgen = self->blocks[i]->expression.codegen;
+        if (!(*cgen)((ast_expression*)self->blocks[i], self, false, &dummy))
             return false;
     }
 
@@ -1562,7 +1620,7 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir)
         {
             return ir_block_create_return(self->curblock, ast_ctx(self), NULL);
         }
-        else if (vec_size(self->curblock->entries))
+        else if (vec_size(self->curblock->entries) || self->curblock == irf->first)
         {
             /* error("missing return"); */
             if (compile_warning(ast_ctx(self), WARN_MISSING_RETURN_VALUES,
@@ -1613,7 +1671,7 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu
     for (i = 0; i < vec_size(self->locals); ++i)
     {
         if (!ast_local_codegen(self->locals[i], func->ir_func, false)) {
-            if (opts.debug)
+            if (OPTS_OPTION_BOOL(OPTION_DEBUG))
                 compile_error(ast_ctx(self), "failed to generate local `%s`", self->locals[i]->name);
             return false;
         }
@@ -1846,6 +1904,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 +1921,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;
 }
@@ -2071,7 +2131,7 @@ bool ast_entfield_codegen(ast_entfield *self, ast_function *func, bool lvalue, i
     } else {
         *out = ir_block_create_load_from_ent(func->curblock, ast_ctx(self), ast_function_label(func, "efv"),
                                              ent, field, self->expression.vtype);
-        /* Done AFTER error checking: 
+        /* Done AFTER error checking:
         codegen_output_type(self, *out);
         */
     }
@@ -2131,9 +2191,11 @@ bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lva
 
     if (!lvalue && self->expression.outr) {
         *out = self->expression.outr;
+        return true;
     }
     if (lvalue && self->expression.outl) {
         *out = self->expression.outl;
+        return true;
     }
 
     if (!ast_istype(self->array, ast_value)) {
@@ -2180,6 +2242,8 @@ bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lva
 
         *out = ir_call_value(call);
         self->expression.outr = *out;
+        (*out)->vtype = self->expression.vtype;
+        codegen_output_type(self, *out);
         return true;
     }
 
@@ -2205,6 +2269,8 @@ bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lva
         compile_error(ast_ctx(self), "array indexing here needs an integer constant");
         return false;
     }
+    (*out)->vtype = self->expression.vtype;
+    codegen_output_type(self, *out);
     return true;
 }
 
@@ -2399,15 +2465,18 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_
     /* Here, now, we need a PHI node
      * but first some sanity checking...
      */
-    if (trueval->vtype != falseval->vtype) {
+    if (trueval->vtype != falseval->vtype && trueval->vtype != TYPE_NIL && falseval->vtype != TYPE_NIL) {
         /* error("ternary with different types on the two sides"); */
+        compile_error(ast_ctx(self), "internal error: ternary operand types invalid");
         return false;
     }
 
     /* create PHI */
-    phi = ir_block_create_phi(merge, ast_ctx(self), ast_function_label(func, "phi"), trueval->vtype);
-    if (!phi)
+    phi = ir_block_create_phi(merge, ast_ctx(self), ast_function_label(func, "phi"), self->expression.vtype);
+    if (!phi) {
+        compile_error(ast_ctx(self), "internal error: failed to generate phi node");
         return false;
+    }
     ir_phi_add(phi, ontrue_out,  trueval);
     ir_phi_add(phi, onfalse_out, falseval);
 
@@ -2732,7 +2801,7 @@ bool ast_switch_codegen(ast_switch *self, ast_function *func, bool lvalue, ir_va
         return true;
 
     cmpinstr = type_eq_instr[irop->vtype];
-    if (cmpinstr >= AINSTR_END) {
+    if (cmpinstr >= VINSTR_END) {
         ast_type_to_string(self->operand, typestr, sizeof(typestr));
         compile_error(ast_ctx(self), "invalid type to perform a switch on: %s", typestr);
         return false;
@@ -2863,6 +2932,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");
@@ -2972,6 +3046,20 @@ bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value
         vec_push(params, param);
     }
 
+    /* varargs counter */
+    if (self->va_count) {
+        ir_value   *va_count;
+        ir_builder *builder = func->curblock->owner->owner;
+        cgen = self->va_count->expression.codegen;
+        if (!(*cgen)((ast_expression*)(self->va_count), func, false, &va_count))
+            return false;
+        if (!ir_block_create_store_op(func->curblock, ast_ctx(self), INSTR_STORE_F,
+                                      ir_builder_get_va_count(builder), va_count))
+        {
+            return false;
+        }
+    }
+
     callinstr = ir_block_create_call(func->curblock, ast_ctx(self),
                                      ast_function_label(func, "call"),
                                      funval, !!(self->func->expression.flags & AST_FLAG_NORETURN));