Merge branch 'master' into ast-and-ir

diff --git a/ast.c b/ast.c
index 63787cd547d0f56582c8689212bd583ea6f91896..7fa27f5b3c4188a6897749987de79456b5fc14d2 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -267,6 +267,7 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype)
     MEM_VECTOR_INIT(self, blocks);
 
     self->ir_func = NULL;
+    self->curblock = NULL;
 
     vtype->isconst = true;
     vtype->constval.vfunc = self;
@@ -297,7 +298,10 @@ void ast_function_delete(ast_function *self)
 }
 
 /*********************************************************************/
-/* AST codegen aprt
+/* AST codegen part
+ * by convention you must never pass NULL to the 'ir_value **out'
+ * parameter. If you really don't care about the output, pass a dummy.
+ * But I can't imagine a pituation where the output is truly unnecessary.
  */
 
 bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_value **out)
@@ -309,7 +313,10 @@ bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_valu
      * and the ast-user should take care of ast_global_codegen to be used
      * on all the globals.
      */
-    return false;
+    if (!self->ir_v)
+        return false;
+    *out = self->ir_v;
+    return true;
 }
 
 bool ast_global_codegen(ast_value *self, ir_builder *ir)
@@ -365,24 +372,147 @@ error: /* clean up */
     return false;
 }
 
+bool ast_local_codegen(ast_value *self, ir_function *func)
+{
+    ir_value *v = NULL;
+    if (self->isconst && self->vtype == TYPE_FUNCTION)
+    {
+        /* Do we allow local functions? I think not...
+         * this is NOT a function pointer atm.
+         */
+        return false;
+    }
+
+    v = ir_function_create_local(func, self->name, self->vtype);
+    if (!v)
+        return false;
+
+    /* A constant local... hmmm...
+     * I suppose the IR will have to deal with this
+     */
+    if (self->isconst) {
+        switch (self->vtype)
+        {
+            case TYPE_FLOAT:
+                if (!ir_value_set_float(v, self->constval.vfloat))
+                    goto error;
+                break;
+            case TYPE_VECTOR:
+                if (!ir_value_set_vector(v, self->constval.vvec))
+                    goto error;
+                break;
+            case TYPE_STRING:
+                if (!ir_value_set_string(v, self->constval.vstring))
+                    goto error;
+                break;
+            default:
+                printf("TODO: global constant type %i\n", self->vtype);
+                break;
+        }
+    }
+
+    /* link us to the ir_value */
+    self->ir_v = v;
+    return true;
+
+error: /* clean up */
+    ir_value_delete(v);
+    return false;
+}
+
 bool ast_function_codegen(ast_function *self, ir_builder *ir)
 {
-    if (!self->ir_func) {
+    ir_function *irf;
+    ir_value    *dummy;
+    size_t    i;
+
+    irf = self->ir_func;
+    if (!irf) {
         printf("ast_function's related ast_value was not generated yet\n");
         return false;
     }
-    return false;
+
+    self->curblock = ir_function_create_block(irf, "entry");
+    if (!self->curblock)
+        return false;
+
+    for (i = 0; i < self->blocks_count; ++i) {
+        ast_expression_codegen *gen = self->blocks[i]->expression.codegen;
+        if (!(*gen)((ast_expression*)self->blocks[i], self, false, &dummy))
+            return false;
+    }
+    return true;
 }
 
+/* Note, you will not see ast_block_codegen generate ir_blocks.
+ * To the AST and the IR, blocks are 2 different things.
+ * In the AST it represents a block of code, usually enclosed in
+ * curly braces {...}.
+ * While in the IR it represents a block in terms of control-flow.
+ */
 bool ast_block_codegen(ast_block *self, ast_function *func, bool lvalue, ir_value **out)
 {
-    return false;
+    size_t i;
+
+    /* We don't use this
+     * Note: an ast-representation using the comma-operator
+     * of the form: (a, b, c) = x should not assign to c...
+     */
+    (void)lvalue;
+
+    /* output is NULL at first, we'll have each expression
+     * assign to out output, thus, a comma-operator represention
+     * using an ast_block will return the last generated value,
+     * so: (b, c) + a  executed both b and c, and returns c,
+     * which is then added to a.
+     */
+    *out = NULL;
+
+    /* generate locals */
+    for (i = 0; i < self->locals_count; ++i)
+    {
+        if (!ast_local_codegen(self->locals[i], func->ir_func))
+            return false;
+    }
+
+    for (i = 0; i < self->exprs_count; ++i)
+    {
+        ast_expression_codegen *gen = self->exprs[i]->expression.codegen;
+        if (!(*gen)(self->exprs[i], func, false, out))
+            return false;
+    }
+
+    return true;
 }
 
 bool ast_store_codegen(ast_store *self, ast_function *func, bool lvalue, ir_value **out)
 {
-    /* NOTE: remember: destination codegen needs to have lvalue=true */
-    return false;
+    ast_expression_codegen *cgen;
+    ir_value *left, *right;
+
+    cgen = self->dest->expression.codegen;
+    /* lvalue! */
+    if (!(*cgen)((ast_expression*)(self->dest), func, true, &left))
+        return false;
+
+    cgen = self->source->expression.codegen;
+    /* rvalue! */
+    if (!(*cgen)((ast_expression*)(self->source), func, false, &right))
+        return false;
+
+    if (!ir_block_create_store_op(func->curblock, self->op, left, right))
+        return false;
+
+    /* Theoretically, an assinment returns its left side as an
+     * lvalue, if we don't need an lvalue though, we return
+     * the right side as an rvalue, otherwise we have to
+     * somehow know whether or not we need to dereference the pointer
+     * on the left side - that is: OP_LOAD if it was an address.
+     * Also: in original QC we cannot OP_LOADP *anyway*.
+     */
+    *out = (lvalue ? left : right);
+
+    return true;
 }
 
 bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_value **out)

diff --git a/ast.h b/ast.h
index f1149994226f054b912c02e636e1772c94f3d159..9609a08d678600d2a44fe4b741203c40e5da0b4f 100644 (file)
--- a/ast.h
+++ b/ast.h
@@ -117,6 +117,8 @@ void ast_value_delete(ast_value*);
 bool ast_value_set_name(ast_value*, const char *name);
 
 bool ast_value_codegen(ast_value*, ast_function*, bool lvalue, ir_value**);
+bool ast_local_codegen(ast_value *self, ir_function *func);
+bool ast_global_codegen(ast_value *self, ir_builder *ir);
 
 /* Binary
  *
@@ -272,6 +274,7 @@ struct ast_function_s
     const char *name;
 
     ir_function *ir_func;
+    ir_block    *curblock;
 
     MEM_VECTOR_MAKE(ast_block*, blocks);
 };