block and value codegen protos

[xonotic/gmqcc.git] / ast.c

diff --git a/ast.c b/ast.c
index 05fdae1c37badb57c2c19bb3db12f8cd3974a45f..5b4b1de228c95244430d9a65570b2f9e6e6553c8 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -1,15 +1,38 @@
+/*
+ * Copyright (C) 2012 
+ *     Wolfgang Bumiller
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "gmqcc.h"
 #include "ast.h"
 
 #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)
@@ -32,7 +55,7 @@ static void ast_expression_init(ast_expression *self,
     ast_setfunc(&self->expression, codegen, codegen);
 }
 
-ast_value* ast_value_new(lex_ctx_t ctx, const char *name, qc_type_t t)
+ast_value* ast_value_new(lex_ctx_t ctx, const char *name, int t)
 {
     ast_instantiate(ast_value, ctx, ast_value_delete);
     ast_expression_init((ast_expression*)self,
@@ -41,9 +64,9 @@ 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;
-    memset(&self->cvalue, 0, sizeof(self->cvalue));
+    MEM_VECTOR_INIT(self, params);
+    self->isconst = false;
+    memset(&self->constval, 0, sizeof(self->constval));
 
     self->ir_v = NULL;
 
@@ -58,14 +81,14 @@ void ast_value_delete(ast_value* self)
         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) {
+    if (self->isconst) {
         switch (self->vtype)
         {
         case qc_string:
-            mem_d((void*)self->cvalue.vstring);
+            mem_d((void*)self->constval.vstring);
             break;
         /* NOTE: delete function? currently collected in
          * the parser structure
@@ -84,11 +107,11 @@ void ast_value_set_name(ast_value *self, const char *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, int op,
                            ast_value* left, ast_value* right)
 {
     ast_instantiate(ast_binary, ctx, ast_binary_delete);
-    ast_expression_init((ast_expression*)self, (ast_expression_codegen*)codegen);
+    ast_expression_init((ast_expression*)self, NULL); /* FIXME */
 
     self->op = op;
     self->left = left;
@@ -102,14 +125,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 +144,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 ? util_strdup(name) : NULL;
-    VEC_INIT(self, blocks);
+    MEM_VECTOR_INIT(self, blocks);
 
     return self;
 }
@@ -150,6 +173,21 @@ void ast_function_delete(ast_function *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
+ */
+
+/* Some dummies so it compiles... */
+bool ast_value_codegen(ast_value *self, ast_function *func, ir_value **out)
+{
+    return false;
+}
+
+bool ast_block_codegen(ast_block *self, ast_function *func, ir_value **out)
+{
+    return false;
+}