array accessor function genaration

ast.c

@@ -563,6 +563,39 @@ void ast_member_delete(ast_member *self)
     mem_d(self);
 }
 
+ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index)
+{
+    const ast_expression *outtype;
+    ast_instantiate(ast_array_index, ctx, ast_array_index_delete);
+
+    outtype = array->expression.next;
+    if (!outtype) {
+        mem_d(self);
+        /* Error: field has no type... */
+        return NULL;
+    }
+
+    ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_array_index_codegen);
+
+    self->array = array;
+    self->index = index;
+
+    if (!ast_type_adopt(self, outtype)) {
+        ast_array_index_delete(self);
+        return NULL;
+    }
+
+    return self;
+}
+
+void ast_array_index_delete(ast_array_index *self)
+{
+    ast_unref(self->array);
+    ast_unref(self->index);
+    ast_expression_delete((ast_expression*)self);
+    mem_d(self);
+}
+
 ast_ifthen* ast_ifthen_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse)
 {
     ast_instantiate(ast_ifthen, ctx, ast_ifthen_delete);
@@ -929,7 +962,6 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
 
         ast_expression_common *elemtype = &self->expression.next->expression;
         int vtype = elemtype->vtype;
-printf("Generating `%s`\n", self->name);
         /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */
         if (!self->expression.count || self->expression.count > opts_max_array_size) {
             asterror(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count);
@@ -1477,6 +1509,48 @@ bool ast_member_codegen(ast_member *self, ast_function *func, bool lvalue, ir_va
     return (*out != NULL);
 }
 
+bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lvalue, ir_value **out)
+{
+    ast_value *arr;
+    ast_value *idx;
+
+    if (!ast_istype(self->array, ast_value)) {
+        asterror(ast_ctx(self), "array indexing this way is not supported");
+        return false;
+    }
+
+    if (!ast_istype(self->index, ast_value)) {
+        if (lvalue) {
+            asterror(ast_ctx(self), "array indexing here needs a compile-time constant");
+            return false;
+        } else {
+            /* Time to use accessor functions */
+            /*
+            ast_expression_codegen *cgen;
+            ir_value               *iridx;
+            */
+        }
+    }
+
+    arr = (ast_value*)self->array;
+    idx = (ast_value*)self->index;
+
+    if (!idx->isconst) {
+        asterror(ast_ctx(self), "(.2) array indexing here needs a compile-time constant");
+        return false;
+    }
+
+    if (idx->expression.vtype == TYPE_FLOAT)
+        *out = arr->ir_values[(int)idx->constval.vfloat];
+    else if (idx->expression.vtype == TYPE_INTEGER)
+        *out = arr->ir_values[idx->constval.vint];
+    else {
+        asterror(ast_ctx(self), "array indexing here needs an integer constant");
+        return false;
+    }
+    return true;
+}
+
 bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_value **out)
 {
     ast_expression_codegen *cgen;

ast.h

@@ -45,6 +45,7 @@ typedef struct ast_call_s       ast_call;
 typedef struct ast_unary_s       ast_unary;
 typedef struct ast_return_s      ast_return;
 typedef struct ast_member_s      ast_member;
+typedef struct ast_array_index_s ast_array_index;
 
 enum {
     TYPE_ast_node,
@@ -62,7 +63,8 @@ enum {
     TYPE_ast_call,
     TYPE_ast_unary,
     TYPE_ast_return,
-    TYPE_ast_member
+    TYPE_ast_member,
+    TYPE_ast_array_index
 };
 
 #define ast_istype(x, t) ( ((ast_node_common*)x)->nodetype == (TYPE_##t) )
@@ -305,6 +307,27 @@ void ast_member_delete(ast_member*);
 
 bool ast_member_codegen(ast_member*, ast_function*, bool lvalue, ir_value**);
 
+/* Array index access:
+ *
+ * QC forces us to take special action on arrays:
+ * an ast_store on an ast_array_index must not codegen the index,
+ * but call its setter - unless we have an instruction set which supports
+ * what we need.
+ * Any other array index access will be codegened to a call to the getter.
+ * In any case, accessing an element via a compiletime-constant index will
+ * result in quick access to that variable.
+ */
+struct ast_array_index_s
+{
+    ast_expression_common expression;
+    ast_expression *array;
+    ast_expression *index;
+};
+ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index);
+void ast_array_index_delete(ast_array_index*);
+
+bool ast_array_index_codegen(ast_array_index*, ast_function*, bool lvalue, ir_value**);
+
 /* Store
  *
  * Stores left<-right and returns left.

parser.c

@@ -2180,6 +2180,317 @@ enderr:
     return false;
 }
 
+static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast_value *index, ast_value *value, size_t from, size_t afterend)
+{
+    lex_ctx ctx = ast_ctx(array);
+
+    if (from+1 == afterend) {
+        // set this value
+        ast_block       *block;
+        ast_return      *ret;
+        ast_array_index *subscript;
+        int assignop = type_store_instr[value->expression.vtype];
+
+        if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR)
+            assignop = INSTR_STORE_V;
+
+        subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from));
+        if (!subscript)
+            return NULL;
+
+        ast_store *st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value);
+        if (!st) {
+            ast_delete(subscript);
+            return NULL;
+        }
+
+        block = ast_block_new(ctx);
+        if (!block) {
+            ast_delete(st);
+            return NULL;
+        }
+
+        if (!ast_block_exprs_add(block, (ast_expression*)st)) {
+            ast_delete(block);
+            return NULL;
+        }
+
+        ret = ast_return_new(ctx, NULL);
+        if (!ret) {
+            ast_delete(block);
+            return NULL;
+        }
+
+        if (!ast_block_exprs_add(block, (ast_expression*)ret)) {
+            ast_delete(block);
+            return NULL;
+        }
+
+        return (ast_expression*)block;
+    } else {
+        ast_ifthen *ifthen;
+        ast_expression *left, *right;
+        ast_binary *cmp;
+
+        size_t diff = afterend - from;
+        size_t middle = from + diff/2;
+
+        left  = array_setter_node(parser, array, index, value, from, middle);
+        right = array_setter_node(parser, array, index, value, middle, afterend);
+        if (!left || !right) {
+            if (left)  ast_delete(left);
+            if (right) ast_delete(right);
+            return NULL;
+        }
+
+        cmp = ast_binary_new(ctx, INSTR_LT,
+                             (ast_expression*)index,
+                             (ast_expression*)parser_const_float(parser, from + diff/2));
+        if (!cmp) {
+            ast_delete(left);
+            ast_delete(right);
+            parseerror(parser, "internal error: failed to create comparison for array setter");
+            return NULL;
+        }
+
+        ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right);
+        if (!ifthen) {
+            ast_delete(cmp); /* will delete left and right */
+            parseerror(parser, "internal error: failed to create conditional jump for array setter");
+            return NULL;
+        }
+
+        return (ast_expression*)ifthen;
+    }
+}
+
+static ast_expression *array_getter_node(parser_t *parser, ast_value *array, ast_value *index, size_t from, size_t afterend)
+{
+    lex_ctx ctx = ast_ctx(array);
+
+    if (from+1 == afterend) {
+        ast_return      *ret;
+        ast_array_index *subscript;
+
+        subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from));
+        if (!subscript)
+            return NULL;
+
+        ret = ast_return_new(ctx, (ast_expression*)subscript);
+        if (!ret) {
+            ast_delete(subscript);
+            return NULL;
+        }
+
+        return (ast_expression*)ret;
+    } else {
+        ast_ifthen *ifthen;
+        ast_expression *left, *right;
+        ast_binary *cmp;
+
+        size_t diff = afterend - from;
+        size_t middle = from + diff/2;
+
+        left  = array_getter_node(parser, array, index, from, middle);
+        right = array_getter_node(parser, array, index, middle, afterend);
+        if (!left || !right) {
+            if (left)  ast_delete(left);
+            if (right) ast_delete(right);
+            return NULL;
+        }
+
+        cmp = ast_binary_new(ctx, INSTR_LT,
+                             (ast_expression*)index,
+                             (ast_expression*)parser_const_float(parser, from + diff/2));
+        if (!cmp) {
+            ast_delete(left);
+            ast_delete(right);
+            parseerror(parser, "internal error: failed to create comparison for array setter");
+            return NULL;
+        }
+
+        ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right);
+        if (!ifthen) {
+            ast_delete(cmp); /* will delete left and right */
+            parseerror(parser, "internal error: failed to create conditional jump for array setter");
+            return NULL;
+        }
+
+        return (ast_expression*)ifthen;
+    }
+}
+
+static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname)
+{
+    ast_expression *root = NULL;
+    ast_function   *func = NULL;
+    ast_value      *fval = NULL;
+    ast_block      *body;
+    ast_value      *index, *value;
+    varentry_t     entry;
+
+    if (!ast_istype(array->expression.next, ast_value)) {
+        parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type");
+        return false;
+    }
+
+    body = ast_block_new(ast_ctx(array));
+    if (!body) {
+        parseerror(parser, "failed to create block for array accessor");
+        return false;
+    }
+
+    index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT);
+    value = ast_value_copy((ast_value*)array->expression.next);
+
+    if (!index || !value) {
+        ast_delete(body);
+        if (index) ast_delete(index);
+        if (value) ast_delete(value);
+        parseerror(parser, "failed to create locals for array accessor");
+        return false;
+    }
+
+    root = array_setter_node(parser, array, index, value, 0, array->expression.count);
+    if (!root) {
+        parseerror(parser, "failed to build accessor search tree");
+        goto cleanup;
+    }
+
+    if (!ast_block_exprs_add(body, root)) {
+        parseerror(parser, "failed to build accessor search block");
+        goto cleanup;
+    }
+
+    fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION);
+    if (!fval) {
+        parseerror(parser, "failed to create accessor function value");
+        goto cleanup;
+    }
+    fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "<void>", TYPE_VOID);
+
+    (void)!ast_value_set_name(value, "value"); /* not important */
+    if (!ast_expression_common_params_add(&fval->expression, index)) {
+        parseerror(parser, "failed to build array setter");
+        goto cleanup;
+    }
+    if (!ast_expression_common_params_add(&fval->expression, value)) {
+        ast_delete(index);
+        parseerror(parser, "failed to build array setter");
+        goto cleanup2;
+    }
+
+    func = ast_function_new(ast_ctx(array), funcname, fval);
+    if (!func) {
+        parseerror(parser, "failed to create accessor function node");
+        goto cleanup2;
+    }
+
+    if (!ast_function_blocks_add(func, body))
+        goto cleanup2;
+
+    entry.name = util_strdup(funcname);
+    entry.var  = (ast_expression*)fval;
+    if (!parser_t_globals_add(parser, entry)) {
+        mem_d(entry.name);
+        goto cleanup2;
+    }
+    if (!parser_t_functions_add(parser, func))
+        goto cleanup2;
+
+    return true;
+cleanup:
+    ast_delete(index);
+    ast_delete(value);
+cleanup2:
+    ast_delete(body);
+    if (root) ast_delete(root);
+    if (func) ast_delete(func);
+    if (fval) ast_delete(fval);
+    return false;
+}
+
+static bool parser_create_array_getter(parser_t *parser, ast_value *array, const char *funcname)
+{
+    ast_expression *root = NULL;
+    ast_function   *func = NULL;
+    ast_value      *fval = NULL;
+    ast_block      *body;
+    ast_value      *index;
+    varentry_t     entry;
+
+    if (!ast_istype(array->expression.next, ast_value)) {
+        parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type");
+        return false;
+    }
+
+    body = ast_block_new(ast_ctx(array));
+    if (!body) {
+        parseerror(parser, "failed to create block for array accessor");
+        return false;
+    }
+
+    index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT);
+
+    if (!index) {
+        ast_delete(body);
+        if (index) ast_delete(index);
+        parseerror(parser, "failed to create locals for array accessor");
+        return false;
+    }
+
+    root = array_getter_node(parser, array, index, 0, array->expression.count);
+    if (!root) {
+        parseerror(parser, "failed to build accessor search tree");
+        goto cleanup;
+    }
+
+    if (!ast_block_exprs_add(body, root)) {
+        parseerror(parser, "failed to build accessor search block");
+        goto cleanup;
+    }
+
+    fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION);
+    if (!fval) {
+        parseerror(parser, "failed to create accessor function value");
+        goto cleanup;
+    }
+    fval->expression.next = ast_type_copy(ast_ctx(array), array->expression.next);
+
+    if (!ast_expression_common_params_add(&fval->expression, index)) {
+        parseerror(parser, "failed to build array setter");
+        goto cleanup;
+    }
+
+    func = ast_function_new(ast_ctx(array), funcname, fval);
+    if (!func) {
+        parseerror(parser, "failed to create accessor function node");
+        goto cleanup2;
+    }
+
+    if (!ast_function_blocks_add(func, body))
+        goto cleanup2;
+
+    entry.name = util_strdup(funcname);
+    entry.var  = (ast_expression*)fval;
+    if (!parser_t_globals_add(parser, entry)) {
+        mem_d(entry.name);
+        goto cleanup2;
+    }
+    if (!parser_t_functions_add(parser, func))
+        goto cleanup2;
+
+    return true;
+cleanup:
+    ast_delete(index);
+cleanup2:
+    ast_delete(body);
+    if (root) ast_delete(root);
+    if (func) ast_delete(func);
+    if (fval) ast_delete(fval);
+    return false;
+}
+
 typedef struct {
     MEM_VECTOR_MAKE(ast_value*, p);
 } paramlist_t;
@@ -2739,6 +3050,18 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
             ve[0].var  = ve[1].var  = ve[2].var  = NULL;
             cleanvar = false;
         }
+        /* Part 2.2
+         * deal with arrays
+         */
+        if (var->expression.vtype == TYPE_ARRAY) {
+            char          name[1024];
+            snprintf(name, sizeof(name), "%s::SET", var->name);
+            if (!parser_create_array_setter(parser, var, name))
+                goto cleanup;
+            snprintf(name, sizeof(name), "%s::GET", var->name);
+            if (!parser_create_array_getter(parser, var, name))
+                goto cleanup;
+        }
 
 skipvar:
         if (parser->tok == ';') {