Trash proposal, I'm not commited to this relationship anymore. Also I cannot afford...

[xonotic/gmqcc.git] / ast.c

diff --git a/ast.c b/ast.c
index c039679adb6574d2738ea5588738ac467bc320ee..9172a81c98eabc003d72d7eacb01d64f04e1f3e2 100644 (file)
--- 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);
@@ -589,6 +670,26 @@ void ast_call_delete(ast_call *self)
     mem_d(self);
 }
 
+bool ast_call_check_types(ast_call *self)
+{
+    size_t i;
+    bool   retval = true;
+    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 < 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));
+            /* we don't immediately return */
+            retval = false;
+        }
+    }
+    return retval;
+}
+
 ast_store* ast_store_new(lex_ctx ctx, int op,
                          ast_expression *dest, ast_expression *source)
 {
@@ -599,6 +700,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;
 }
 
@@ -720,10 +832,17 @@ void ast_function_delete(ast_function *self)
 
 const char* ast_function_label(ast_function *self, const char *prefix)
 {
-    size_t id  = (self->labelcount++);
-    size_t len = strlen(prefix);
+    size_t id;
+    size_t len;
+    char  *from;
+
+    if (!opts_dump)
+        return NULL;
 
-    char *from = self->labelbuf + sizeof(self->labelbuf)-1;
+    id  = (self->labelcount++);
+    len = strlen(prefix);
+
+    from = self->labelbuf + sizeof(self->labelbuf)-1;
     *from-- = 0;
     do {
         unsigned int digit = id % 10;
@@ -767,6 +886,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir)
         if (!func)
             return false;
         func->context = ast_ctx(self);
+        func->value->context = ast_ctx(self);
 
         self->constval.vfunc->ir_func = func;
         self->ir_v = func->value;
@@ -962,7 +1082,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;
@@ -1045,10 +1169,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;
@@ -1132,10 +1258,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;
@@ -1160,10 +1288,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;
@@ -1276,8 +1408,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 */
@@ -1712,7 +1844,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;