X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ast.c;h=b1d90562e38dc6126b09a1091b81c2084e430be1;hb=522738de48bbe6a406d53319170a7effe1450264;hp=9b85ba6fe00eb3b35aec576aaf2c953293488097;hpb=57d3da0ebbf8bdf6f5dab78b1060e7262f9ffb81;p=xonotic%2Fgmqcc.git

diff --git a/ast.c b/ast.c
index 9b85ba6..b1d9056 100644
--- a/ast.c
+++ b/ast.c
@@ -6,10 +6,10 @@
 
 #define ast_setfunc(me, fn, what) ( *(void**)&((me)->fn) = what )
 
-#define ast_instantiate(T, ctx, destroyfn) \
-	T *self = (T*)mem_a(sizeof(T)); \
-	ast_node_init((ast_node*)self, ctx); \
-	ast_setfunc(&((ast_node*)self)->node, destroy, destroyfn)
+#define ast_instantiate(T, ctx, destroyfn)                    \
+    T *self = (T*)mem_a(sizeof(T));                           \
+    ast_node_init((ast_node*)self, ctx);                      \
+    ast_setfunc(&((ast_node*)self)->node, destroy, destroyfn)
 
 /* It must not be possible to get here. */
 static void _ast_node_destroy(ast_node *self)
@@ -41,8 +41,8 @@ ast_value* ast_value_new(lex_ctx_t ctx, const char *name, qc_type_t t)
     self->name = name ? util_strdup(name) : NULL;
     self->vtype = t;
     self->next = NULL;
-    VEC_INIT(self, params);
-    self->has_constval = ifalse;
+    MEM_VECTOR_INIT(self, params);
+    self->has_constval = false;
     memset(&self->cvalue, 0, sizeof(self->cvalue));
 
     self->ir_v = NULL;
@@ -54,11 +54,11 @@ 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);
+    if (self->name)
+        mem_d((void*)self->name);
     for (i = 0; i < self->params_count; ++i)
         ast_delete(self->params[i]);
-    VEC_CLEAR(self, params);
+    MEM_VECTOR_CLEAR(self, params);
     if (self->next)
         ast_delete(self->next);
     if (self->has_constval) {
@@ -79,12 +79,12 @@ void ast_value_delete(ast_value* self)
 
 void ast_value_set_name(ast_value *self, const char *name)
 {
-    if (self->_name)
-        mem_d((void*)self->_name);
-    self->_name = strdup(name);
+    if (self->name)
+        mem_d((void*)self->name);
+    self->name = util_strdup(name);
 }
 
-ast_binary* ast_binary_new(filecontext_t ctx, qc_op_t op,
+ast_binary* ast_binary_new(lex_ctx_t ctx, qc_op_t op,
                            ast_value* left, ast_value* right)
 {
     ast_instantiate(ast_binary, ctx, ast_binary_delete);
@@ -102,14 +102,14 @@ void ast_binary_delete(ast_binary *self)
     mem_d(self);
 }
 
-ast_block* ast_block_new(filecontext_t ctx)
+ast_block* ast_block_new(lex_ctx_t ctx)
 {
     ast_instantiate(ast_block, ctx, ast_block_delete);
     ast_expression_init((ast_expression*)self,
                         (ast_expression_codegen*)&ast_block_codegen);
 
-    VEC_INIT(self, locals);
-    VEC_INIT(self, exprs);
+    MEM_VECTOR_INIT(self, locals);
+    MEM_VECTOR_INIT(self, exprs);
 
     return self;
 }
@@ -121,20 +121,20 @@ void ast_block_delete(ast_block *self)
     size_t i;
     for (i = 0; i < self->locals_count; ++i)
         ast_delete(self->locals[i]);
-    VEC_CLEAR(self, locals);
+    MEM_VECTOR_CLEAR(self, locals);
     for (i = 0; i < self->exprs_count; ++i)
         ast_delete(self->exprs[i]);
-    VEC_CLEAR(self, exprs);
+    MEM_VECTOR_CLEAR(self, exprs);
     mem_d(self);
 }
 
-ast_function* ast_function_new(filecontext_t ctx, const char *name, ast_value *vtype)
+ast_function* ast_function_new(lex_ctx_t ctx, const char *name, ast_value *vtype)
 {
     ast_instantiate(ast_function, ctx, ast_function_delete);
 
     self->vtype = vtype;
-    self->_name = name ? strdup(name) : NULL;
-    VEC_INIT(self, blocks);
+    self->name = name ? util_strdup(name) : NULL;
+    MEM_VECTOR_INIT(self, blocks);
 
     return self;
 }
@@ -144,12 +144,85 @@ MEM_VEC_FUNCTIONS(ast_function, ast_block*, blocks)
 void ast_function_delete(ast_function *self)
 {
     size_t i;
-    if (self->_name)
-        mem_d((void*)self->_name);
+    if (self->name)
+        mem_d((void*)self->name);
     if (self->vtype)
         ast_value_delete(self->vtype);
     for (i = 0; i < self->blocks_count; ++i)
         ast_delete(self->blocks[i]);
-    VEC_CLEAR(self, blocks);
+    MEM_VECTOR_CLEAR(self, blocks);
     mem_d(self);
 }
+
+/*********************************************************************/
+/* AST codegen aprt
+ */
+
+static qbool ast_value_gen_global(ir_builder *ir, ast_value *self, ir_value **out)
+{
+    ir_value *v;
+    *out = NULL;
+
+    /* Generate functions */
+    if (self->vtype == qc_function && self->has_constval)
+    {
+        /* Without has_constval it would be invalid... function pointers actually have
+         * type qc_pointer and next with type qc_function
+         */
+        ast_function *func = self->cvalue.vfunc;
+        if (!ast_function_codegen(func, ir))
+            return false;
+
+        /* Here we do return NULL anyway */
+        return true;
+    }
+    else if (self->vtype == qc_function && !self->has_constval) {
+        fprintf(stderr,
+        "!v->has_constval <- qc_function body missing - FIXME: remove when implementing prototypes\n");
+        fprintf(stderr, "Value: %s\n", self->_name);
+        abort();
+    }
+
+    v = ir_builder_create_global(ir, self->_name, self->vtype);
+    self->ir_v = v;
+
+    *out = v;
+    return true;
+}
+
+qbool ast_value_codegen(ast_value *self, ast_function *func, ir_value **out)
+{
+    if (!func)
+        return ast_value_gen_global(parser.ir, self, out);
+    return false;
+}
+
+qbool ast_function_codegen(ast_function *self, ir_builder *builder)
+{
+    size_t i;
+    for (i = 0; i < self->blocks_count; ++i)
+    {
+        ast_expression *expr;
+        ir_value *out;
+
+        expr = (ast_expression*)self->blocks[i];
+
+        if (!(expr->expression.codegen)(expr, self, &out))
+        {
+            /* there was an error while building this expression... */
+            return false;
+        }
+        (void)out;
+    }
+    return true;
+}
+
+qbool ast_block_codegen(ast_block *self, ir_function *func, ir_value **out)
+{
+    return false;
+}
+
+qbool ast_bin_store_codegen(ast_binary *self, ir_function *func, ir_value **out)
+{
+    return false;
+}