Merge branch 'master' into blub/bc3

diff --combined ast.c
index fd2ace99d1297c98c43031cae2268bf82f7bc5cf,61b89e4caee5d78be54d00d201b126d6ac7542df..944fee9b613dec7ba830c4a5e3d5d05397e5a540
--- 1/ast.c
--- 2/ast.c
+++ b/ast.c
@@@ -57,12 -57,18 +57,18 @@@ static void ast_expression_init(ast_exp
      self->expression.codegen = codegen;
      self->expression.vtype   = TYPE_VOID;
      self->expression.next    = NULL;
+     MEM_VECTOR_INIT(&self->expression, params);
  }
  
  static void ast_expression_delete(ast_expression *self)
  {
+     size_t i;
      if (self->expression.next)
          ast_delete(self->expression.next);
+     for (i = 0; i < self->expression.params_count; ++i) {
+         ast_delete(self->expression.params[i]);
+     }
+     MEM_VECTOR_CLEAR(&self->expression, params);
  }
  
  static void ast_expression_delete_full(ast_expression *self)
@@@ -71,9 -77,26 +77,26 @@@
      mem_d(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 *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;
+         }
+     }
+     return cp;
+ }
+ 
  static ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex)
  {
-     const ast_expression_common *cpex;
+     size_t i;
+     const ast_expression_common *fromex;
      ast_expression_common *selfex;
  
      if (!ex)
@@@ -82,23 -105,32 +105,32 @@@
      {
          ast_instantiate(ast_expression, ctx, ast_expression_delete_full);
  
-         cpex   = &ex->expression;
+         fromex   = &ex->expression;
          selfex = &self->expression;
  
-         selfex->vtype = cpex->vtype;
-         if (cpex->next)
+         /* This may never be codegen()d */
+         selfex->codegen = NULL;
+ 
+         selfex->vtype = fromex->vtype;
+         if (fromex->next)
          {
-             selfex->next = ast_type_copy(ctx, cpex->next);
+             selfex->next = ast_type_copy(ctx, fromex->next);
              if (!selfex->next) {
-                 mem_d(self);
+                 ast_expression_delete_full(self);
                  return NULL;
              }
          }
          else
              selfex->next = NULL;
  
-         /* This may never be codegen()d */
-         selfex->codegen = NULL;
+         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_expression_delete_full(self);
+                 return NULL;
+             }
+         }
+ 
          return self;
      }
  }
@@@ -113,7 -145,6 +145,6 @@@ ast_value* ast_value_new(lex_ctx ctx, c
      self->name = name ? util_strdup(name) : NULL;
      self->expression.vtype = t;
      self->expression.next  = NULL;
-     MEM_VECTOR_INIT(self, params);
      self->isconst = false;
      memset(&self->constval, 0, sizeof(self->constval));
  
@@@ -121,16 -152,11 +152,11 @@@
  
      return self;
  }
- MEM_VEC_FUNCTIONS(ast_value, ast_value*, params)
  
  void ast_value_delete(ast_value* self)
  {
-     size_t i;
      if (self->name)
          mem_d((void*)self->name);
-     for (i = 0; i < self->params_count; ++i)
-         ast_value_delete(self->params[i]); /* delete, the ast_function is expected to die first */
-     MEM_VECTOR_CLEAR(self, params);
      if (self->isconst) {
          switch (self->expression.vtype)
          {
@@@ -152,6 -178,11 +178,11 @@@
      mem_d(self);
  }
  
+ bool GMQCC_WARN ast_value_params_add(ast_value *self, ast_value *p)
+ {
+     return ast_expression_common_params_add(&self->expression, p);
+ }
+ 
  bool ast_value_set_name(ast_value *self, const char *name)
  {
      if (self->name)
@@@ -170,18 -201,6 +201,18 @@@ ast_binary* ast_binary_new(lex_ctx ctx
      self->left = left;
      self->right = right;
  
 +    if (op >= INSTR_EQ_F && op <= INSTR_GT)
 +        self->expression.vtype = TYPE_FLOAT;
 +    else if (op == INSTR_AND || op == INSTR_OR ||
 +             op == INSTR_BITAND || op == INSTR_BITOR)
 +        self->expression.vtype = TYPE_FLOAT;
 +    else if (op == INSTR_MUL_VF || op == INSTR_MUL_FV)
 +        self->expression.vtype = TYPE_VECTOR;
 +    else if (op == INSTR_MUL_V)
 +        self->expression.vtype = TYPE_FLOAT;
 +    else
 +        self->expression.vtype = left->expression.vtype;
 +
      return self;
  }
  
@@@ -571,10 -590,8 +602,10 @@@ bool ast_global_codegen(ast_value *self
      }
  
      v = ir_builder_create_global(ir, self->name, self->expression.vtype);
 -    if (!v)
 +    if (!v) {
 +        printf("ir_builder_create_global failed\n");
          return false;
 +    }
  
      if (self->isconst) {
          switch (self->expression.vtype)
@@@ -664,6 -681,7 +695,7 @@@ bool ast_function_codegen(ast_function 
  {
      ir_function *irf;
      ir_value    *dummy;
+     ast_expression_common *ec;
      size_t    i;
  
      irf = self->ir_func;
@@@ -673,12 -691,13 +705,13 @@@
      }
  
      /* fill the parameter list */
-     for (i = 0; i < self->vtype->params_count; ++i)
+     ec = &self->vtype->expression;
+     for (i = 0; i < ec->params_count; ++i)
      {
-         if (!ir_function_params_add(irf, self->vtype->params[i]->expression.vtype))
+         if (!ir_function_params_add(irf, ec->params[i]->expression.vtype))
              return false;
          if (!self->builtin) {
-             if (!ast_local_codegen(self->vtype->params[i], self->ir_func, true))
+             if (!ast_local_codegen(ec->params[i], self->ir_func, true))
                  return false;
          }
      }
@@@ -1353,6 -1372,7 +1386,7 @@@ bool ast_call_codegen(ast_call *self, a
  
      *out = ir_call_value(callinstr);
  
+     MEM_VECTOR_CLEAR(&params, v);
      return true;
  error:
      MEM_VECTOR_CLEAR(&params, v);

diff --combined ast.h
index ace081f412a4d433a2f0651ec3babbe036bb842e,17f685030e669d80ff9295b3b6985761584e8858..ce56cc235b0e9a30427b9431d572819eb4f37857
--- 1/ast.h
--- 2/ast.h
+++ b/ast.h
@@@ -81,7 -81,9 +81,9 @@@ typedef struc
      ast_expression_codegen *codegen;
      int                     vtype;
      ast_expression         *next;
+     MEM_VECTOR_MAKE(ast_value*, params);
  } ast_expression_common;
+ MEM_VECTOR_PROTO(ast_expression_common, ast_value*, params);
  
  /* Value
   *
@@@ -109,18 -111,10 +111,12 @@@ struct ast_value_
          const char   *vstring;
          int           ventity;
          ast_function *vfunc;
 +        quaternion    vquat;
 +        matrix        vmat;
      } constval;
  
      ir_value *ir_v;
- 
-     /* if vtype is qc_function, params contain parameters, and
-      * 'next' the return type.
-      */
-     MEM_VECTOR_MAKE(ast_value*, params);
  };
- MEM_VECTOR_PROTO(ast_value, ast_value*, params);
  
  ast_value* ast_value_new(lex_ctx ctx, const char *name, int qctype);
  /* This will NOT delete an underlying ast_function */
@@@ -132,6 -126,8 +128,8 @@@ bool ast_value_codegen(ast_value*, ast_
  bool ast_local_codegen(ast_value *self, ir_function *func, bool isparam);
  bool ast_global_codegen(ast_value *self, ir_builder *ir);
  
+ bool GMQCC_WARN ast_value_params_add(ast_value*, ast_value*);
+ 
  /* Binary
   *
   * A value-returning binary expression.