#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)
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;
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) {
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;
}
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);
}
self->vtype = vtype;
self->name = name ? util_strdup(name) : NULL;
- VEC_INIT(self, blocks);
+ MEM_VECTOR_INIT(self, blocks);
return self;
}
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;
+}