+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_expression *left, *right;
+ 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);
+ return array_accessor_split(parser, array, index, middle, left, right);
+ }
+}
+
+static bool parser_create_array_accessor(parser_t *parser, ast_value *array, const char *funcname, ast_value **out)
+{
+ ast_function *func = NULL;
+ ast_value *fval = NULL;
+
+ fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION);
+ if (!fval) {
+ parseerror(parser, "failed to create accessor function value");
+ return false;
+ }
+
+ func = ast_function_new(ast_ctx(array), funcname, fval);
+ if (!func) {
+ ast_delete(fval);
+ parseerror(parser, "failed to create accessor function node");
+ return false;
+ }
+
+ *out = fval;
+
+ return true;
+}
+
+static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname)
+{
+ ast_expression *root = NULL;
+ ast_block *body = NULL;
+ ast_value *index = NULL;
+ ast_value *value = NULL;
+ ast_function *func;
+ ast_value *fval;
+
+ 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;
+ }
+
+ if (!parser_create_array_accessor(parser, array, funcname, &fval))
+ return false;
+ func = fval->constval.vfunc;
+ fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "<void>", TYPE_VOID);
+
+ body = ast_block_new(ast_ctx(array));
+ if (!body) {
+ parseerror(parser, "failed to create block for array accessor");
+ goto cleanup;
+ }
+
+ index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT);
+ value = ast_value_copy((ast_value*)array->expression.next);
+
+ if (!index || !value) {
+ parseerror(parser, "failed to create locals for array accessor");
+ goto cleanup;
+ }
+ (void)!ast_value_set_name(value, "value"); /* not important */
+ vec_push(fval->expression.params, index);
+ vec_push(fval->expression.params, value);
+
+ root = array_setter_node(parser, array, index, value, 0, array->expression.count);
+ if (!root) {
+ parseerror(parser, "failed to build accessor search tree");
+ goto cleanup;
+ }
+
+ vec_push(body->exprs, root);
+ vec_push(func->blocks, body);
+ array->setter = fval;
+ return true;
+cleanup:
+ if (body) ast_delete(body);
+ if (index) ast_delete(index);
+ if (value) ast_delete(value);
+ if (root) ast_delete(root);
+ ast_delete(func);
+ ast_delete(fval);
+ return false;
+}
+
+static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, const char *funcname)
+{
+ ast_expression *root = NULL;
+ ast_block *body = NULL;
+ ast_value *entity = NULL;
+ ast_value *index = NULL;
+ ast_value *value = NULL;
+ ast_function *func;
+ ast_value *fval;
+
+ 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;
+ }
+
+ if (!parser_create_array_accessor(parser, array, funcname, &fval))
+ return false;
+ func = fval->constval.vfunc;
+ fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "<void>", TYPE_VOID);
+
+ body = ast_block_new(ast_ctx(array));
+ if (!body) {
+ parseerror(parser, "failed to create block for array accessor");
+ goto cleanup;
+ }
+
+ entity = ast_value_new(ast_ctx(array), "entity", TYPE_ENTITY);
+ index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT);
+ value = ast_value_copy((ast_value*)array->expression.next);
+ if (!entity || !index || !value) {
+ parseerror(parser, "failed to create locals for array accessor");
+ goto cleanup;
+ }
+ (void)!ast_value_set_name(value, "value"); /* not important */
+ vec_push(fval->expression.params, entity);
+ vec_push(fval->expression.params, index);
+ vec_push(fval->expression.params, value);
+
+ root = array_field_setter_node(parser, array, entity, index, value, 0, array->expression.count);
+ if (!root) {
+ parseerror(parser, "failed to build accessor search tree");
+ goto cleanup;
+ }
+
+ vec_push(body->exprs, root);
+ vec_push(func->blocks, body);
+ array->setter = fval;
+ return true;
+cleanup:
+ if (body) ast_delete(body);
+ if (entity) ast_delete(entity);
+ if (index) ast_delete(index);
+ if (value) ast_delete(value);
+ if (root) ast_delete(root);
+ ast_delete(func);
+ ast_delete(fval);
+ return false;
+}
+
+static bool parser_create_array_getter(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname)
+{
+ ast_expression *root = NULL;
+ ast_block *body = NULL;
+ ast_value *index = NULL;
+ ast_value *fval;
+ ast_function *func;
+
+ /* NOTE: checking array->expression.next rather than elemtype since
+ * for fields elemtype is a temporary fieldtype.
+ */
+ 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;
+ }
+
+ if (!parser_create_array_accessor(parser, array, funcname, &fval))
+ return false;
+ func = fval->constval.vfunc;
+ fval->expression.next = ast_type_copy(ast_ctx(array), elemtype);