X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ast.c;h=f10dbb2f4f0688513a182a0d214e743f99cdc1e6;hb=62d062f860c4388274b0545727b8ed1eb6b2db9d;hp=a0af13022ebd8585252af91e36eca44bd983e793;hpb=478a9249a0da6c1fd66258ac8b13fd0b5a76db86;p=xonotic%2Fgmqcc.git

diff --git a/ast.c b/ast.c
index a0af130..f10dbb2 100644
--- a/ast.c
+++ b/ast.c
@@ -217,6 +217,87 @@ bool ast_compare_type(ast_expression *a, ast_expression *b)
     return true;
 }
 
+static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsize, size_t pos)
+{
+    const char *typestr;
+    size_t typelen;
+    size_t i;
+
+    if (!e) {
+        if (pos + 6 >= bufsize)
+            goto full;
+        strcpy(buf + pos, "(null)");
+        return pos + 6;
+    }
+
+    if (pos + 1 >= bufsize)
+        goto full;
+
+    switch (e->expression.vtype) {
+        case TYPE_VARIANT:
+            strcpy(buf + pos, "(variant)");
+            return pos + 9;
+
+        case TYPE_FIELD:
+            buf[pos++] = '.';
+            return ast_type_to_string_impl(e->expression.next, buf, bufsize, pos);
+
+        case TYPE_POINTER:
+            if (pos + 3 >= bufsize)
+                goto full;
+            buf[pos++] = '*';
+            buf[pos++] = '(';
+            pos = ast_type_to_string_impl(e->expression.next, buf, bufsize, pos);
+            if (pos + 1 >= bufsize)
+                goto full;
+            buf[pos++] = ')';
+            return pos;
+
+        case TYPE_FUNCTION:
+            pos = ast_type_to_string_impl(e->expression.next, buf, bufsize, pos);
+            if (pos + 2 >= bufsize)
+                goto full;
+            if (e->expression.params_count == 0) {
+                buf[pos++] = '(';
+                buf[pos++] = ')';
+                return pos;
+            }
+            buf[pos++] = '(';
+            pos = ast_type_to_string_impl((ast_expression*)(e->expression.params[0]), buf, bufsize, pos);
+            for (i = 1; i < e->expression.params_count; ++i) {
+                if (pos + 2 >= bufsize)
+                    goto full;
+                buf[pos++] = ',';
+                buf[pos++] = ' ';
+                pos = ast_type_to_string_impl((ast_expression*)(e->expression.params[i]), buf, bufsize, pos);
+            }
+            if (pos + 1 >= bufsize)
+                goto full;
+            buf[pos++] = ')';
+            return pos;
+
+        default:
+            typestr = type_name[e->expression.vtype];
+            typelen = strlen(typestr);
+            if (pos + typelen >= bufsize)
+                goto full;
+            strcpy(buf + pos, typestr);
+            return pos + typelen;
+    }
+
+full:
+    buf[bufsize-3] = '.';
+    buf[bufsize-2] = '.';
+    buf[bufsize-1] = '.';
+    return bufsize;
+}
+
+void ast_type_to_string(ast_expression *e, char *buf, size_t bufsize)
+{
+    size_t pos = ast_type_to_string_impl(e, buf, bufsize-1, 0);
+    buf[pos] = 0;
+}
+
 ast_value* ast_value_new(lex_ctx ctx, const char *name, int t)
 {
     ast_instantiate(ast_value, ctx, ast_value_delete);
@@ -231,7 +312,9 @@ ast_value* ast_value_new(lex_ctx ctx, const char *name, int t)
     self->uses    = 0;
     memset(&self->constval, 0, sizeof(self->constval));
 
-    self->ir_v    = NULL;
+    self->ir_v           = NULL;
+    self->ir_values      = NULL;
+    self->ir_value_count = 0;
 
     return self;
 }
@@ -593,9 +676,12 @@ bool ast_call_check_types(ast_call *self)
 {
     size_t i;
     bool   retval = true;
-    const ast_expression *func = self->func;
+    const  ast_expression *func = self->func;
+    size_t count = self->params_count;
+    if (count > func->expression.params_count)
+        count = func->expression.params_count;
 
-    for (i = 0; i < self->params_count; ++i) {
+    for (i = 0; i < count; ++i) {
         if (!ast_compare_type(self->params[i], (ast_expression*)(func->expression.params[i]))) {
             asterror(ast_ctx(self), "invalid type for parameter %u in function call",
                      (unsigned int)(i+1));
@@ -616,6 +702,17 @@ ast_store* ast_store_new(lex_ctx ctx, int op,
     self->dest = dest;
     self->source = source;
 
+    self->expression.vtype = dest->expression.vtype;
+    if (dest->expression.next) {
+        self->expression.next = ast_type_copy(ctx, dest);
+        if (!self->expression.next) {
+            ast_delete(self);
+            return NULL;
+        }
+    }
+    else
+        self->expression.next = NULL;
+
     return self;
 }
 
@@ -782,7 +879,7 @@ bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_valu
     return true;
 }
 
-bool ast_global_codegen(ast_value *self, ir_builder *ir)
+bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
 {
     ir_value *v = NULL;
     if (self->isconst && self->expression.vtype == TYPE_FUNCTION)
@@ -799,7 +896,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir)
         return true;
     }
 
-    if (self->expression.vtype == TYPE_FIELD) {
+    if (isfield && self->expression.vtype == TYPE_FIELD) {
         v = ir_builder_create_field(ir, self->name, self->expression.next->expression.vtype);
         if (!v)
             return false;
@@ -817,6 +914,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir)
         asterror(ast_ctx(self), "ir_builder_create_global failed");
         return false;
     }
+    if (self->expression.vtype == TYPE_FIELD)
+        v->fieldtype = self->expression.next->expression.vtype;
     v->context = ast_ctx(self);
 
     if (self->isconst) {
@@ -869,6 +968,8 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param)
     v = ir_function_create_local(func, self->name, self->expression.vtype, param);
     if (!v)
         return false;
+    if (self->expression.vtype == TYPE_FIELD)
+        v->fieldtype = self->expression.next->expression.vtype;
     v->context = ast_ctx(self);
 
     /* A constant local... hmmm...
@@ -987,7 +1088,11 @@ bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_valu
      * Note: an ast-representation using the comma-operator
      * of the form: (a, b, c) = x should not assign to c...
      */
-    (void)lvalue;
+    if (lvalue) {
+        asterror(ast_ctx(self), "not an l-value (code-block)");
+        return false;
+    }
+
     if (self->expression.outr) {
         *out = self->expression.outr;
         return true;
@@ -1070,10 +1175,12 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va
     ast_expression_codegen *cgen;
     ir_value *left, *right;
 
-    /* In the context of a binary operation, we can disregard
-     * the lvalue flag.
-     */
-    (void)lvalue;
+    /* A binary operation cannot yield an l-value */
+    if (lvalue) {
+        asterror(ast_ctx(self), "not an l-value (binop)");
+        return false;
+    }
+
     if (self->expression.outr) {
         *out = self->expression.outr;
         return true;
@@ -1157,10 +1264,12 @@ bool ast_unary_codegen(ast_unary *self, ast_function *func, bool lvalue, ir_valu
     ast_expression_codegen *cgen;
     ir_value *operand;
 
-    /* In the context of a unary operation, we can disregard
-     * the lvalue flag.
-     */
-    (void)lvalue;
+    /* An unary operation cannot yield an l-value */
+    if (lvalue) {
+        asterror(ast_ctx(self), "not an l-value (binop)");
+        return false;
+    }
+
     if (self->expression.outr) {
         *out = self->expression.outr;
         return true;
@@ -1185,10 +1294,14 @@ bool ast_return_codegen(ast_return *self, ast_function *func, bool lvalue, ir_va
     ast_expression_codegen *cgen;
     ir_value *operand;
 
-    /* In the context of a return operation, we can disregard
-     * the lvalue flag.
+    /* In the context of a return operation, we don't actually return
+     * anything...
      */
-    (void)lvalue;
+    if (lvalue) {
+        asterror(ast_ctx(self), "return-expression is not an l-value");
+        return false;
+    }
+
     if (self->expression.outr) {
         asterror(ast_ctx(self), "internal error: ast_return cannot be reused, it bears no result!");
         return false;
@@ -1301,8 +1414,8 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va
     ir_block *cond = func->curblock;
     ir_block *ontrue;
     ir_block *onfalse;
-    ir_block *ontrue_endblock;
-    ir_block *onfalse_endblock;
+    ir_block *ontrue_endblock = NULL;
+    ir_block *onfalse_endblock = NULL;
     ir_block *merge;
 
     /* We don't output any value, thus also don't care about r/lvalue */
@@ -1737,7 +1850,10 @@ bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value
     ir_value *funval = NULL;
 
     /* return values are never lvalues */
-    (void)lvalue;
+    if (lvalue) {
+        asterror(ast_ctx(self), "not an l-value (function call)");
+        return false;
+    }
 
     if (self->expression.outr) {
         *out = self->expression.outr;