X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=7b7805f4f439e6c5709c42bb924f17616be193c8;hb=9a42dd1c3a2100cca919ef3e2314c91757542fb7;hp=f1466a1b3a4abfce274150812f3c0b1249e1b0c3;hpb=00a28e48ee7a4d99bad8268709746c3c064917c4;p=xonotic%2Fgmqcc.git

diff --git a/parser.c b/parser.c
index f1466a1..7b7805f 100644
--- a/parser.c
+++ b/parser.c
@@ -326,6 +326,10 @@ typedef struct
 MEM_VEC_FUNCTIONS(shunt, sy_elem, out)
 MEM_VEC_FUNCTIONS(shunt, sy_elem, ops)
 
+#define SY_PAREN_EXPR '('
+#define SY_PAREN_FUNC 'f'
+#define SY_PAREN_INDEX '['
+
 static sy_elem syexp(lex_ctx ctx, ast_expression *v) {
     sy_elem e;
     e.etype = 0;
@@ -387,6 +391,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
     size_t i, assignop;
     qcint  generated_op = 0;
 
+    char ty1[1024];
+    char ty2[1024];
+
     if (!sy->ops_count) {
         parseerror(parser, "internal error: missing operator");
         return false;
@@ -456,6 +463,20 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             }
             break;
 
+        case opid1('['):
+            if (exprs[0]->expression.vtype != TYPE_ARRAY) {
+                ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+                parseerror(parser, "cannot index value of type %s", ty1);
+                return false;
+            }
+            if (exprs[1]->expression.vtype != TYPE_FLOAT) {
+                ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+                parseerror(parser, "index must be of type float, not %s", ty1);
+                return false;
+            }
+            out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]);
+            break;
+
         case opid1(','):
             if (blocks[0]) {
                 if (!ast_block_exprs_add(blocks[0], exprs[1]))
@@ -759,8 +780,6 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                 else
                     assignop = type_storep_instr[exprs[0]->expression.vtype];
                 if (!ast_compare_type(field->expression.next, exprs[1])) {
-                    char ty1[1024];
-                    char ty2[1024];
                     ast_type_to_string(field->expression.next, ty1, sizeof(ty1));
                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
                     if (opts_standard == COMPILER_QCC &&
@@ -785,11 +804,16 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
                 {
                     assignop = type_store_instr[TYPE_VECTOR];
                 }
-                else
+                else {
                     assignop = type_store_instr[exprs[0]->expression.vtype];
-                if (!ast_compare_type(exprs[0], exprs[1])) {
-                    char ty1[1024];
-                    char ty2[1024];
+                }
+
+                if (assignop == AINSTR_END) {
+                    ast_type_to_string(exprs[0], ty1, sizeof(ty1));
+                    ast_type_to_string(exprs[1], ty2, sizeof(ty2));
+                    parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1);
+                }
+                else if (!ast_compare_type(exprs[0], exprs[1])) {
                     ast_type_to_string(exprs[0], ty1, sizeof(ty1));
                     ast_type_to_string(exprs[1], ty2, sizeof(ty2));
                     if (opts_standard == COMPILER_QCC &&
@@ -980,15 +1004,25 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only)
     }
     */
     while (sy->ops_count) {
-        if (sy->ops[sy->ops_count-1].paren == 'f') {
+        if (sy->ops[sy->ops_count-1].paren == SY_PAREN_FUNC) {
             if (!parser_close_call(parser, sy))
                 return false;
             break;
         }
-        if (sy->ops[sy->ops_count-1].paren == 1) {
+        if (sy->ops[sy->ops_count-1].paren == SY_PAREN_EXPR) {
             sy->ops_count--;
             return !functions_only;
         }
+        if (sy->ops[sy->ops_count-1].paren == SY_PAREN_INDEX) {
+            if (functions_only)
+                return false;
+            /* pop off the parenthesis */
+            sy->ops_count--;
+            /* then apply the index operator */
+            if (!parser_sy_pop(parser, sy))
+                return false;
+            return true;
+        }
         if (!parser_sy_pop(parser, sy))
             return false;
     }
@@ -1173,6 +1207,16 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma
             }
             wantop = true;
         }
+        else if (parser->tok == ']') {
+            if (!wantop)
+                parseerror(parser, "operand expected");
+            --parens;
+            if (parens < 0)
+                break;
+            if (!parser_close_paren(parser, &sy, false))
+                goto onerr;
+            wantop = true;
+        }
         else if (parser->tok != TOKEN_OPERATOR) {
             if (wantop) {
                 parseerror(parser, "expected operator or end of statement");
@@ -1247,19 +1291,31 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma
                     DEBUGSHUNTDO(printf("push [op] (\n"));
                     ++parens;
                     /* we expected an operator, this is the function-call operator */
-                    if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) {
+                    if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_FUNC, sy.out_count-1))) {
                         parseerror(parser, "out of memory");
                         goto onerr;
                     }
                 } else {
                     ++parens;
-                    if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) {
+                    if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0))) {
                         parseerror(parser, "out of memory");
                         goto onerr;
                     }
                     DEBUGSHUNTDO(printf("push [nop] (\n"));
                 }
                 wantop = false;
+            } else if (op->id == opid1('[')) {
+                if (!wantop) {
+                    parseerror(parser, "unexpected array subscript");
+                    goto onerr;
+                }
+                ++parens;
+                /* push both the operator and the paren, this makes life easier */
+                if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
+                    goto onerr;
+                if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0)))
+                    goto onerr;
+                wantop = false;
             } else {
                 DEBUGSHUNTDO(printf("push operator %s\n", op->op));
                 if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op)))
@@ -1270,7 +1326,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma
         if (!parser_next(parser)) {
             goto onerr;
         }
-        if (parser->tok == ';' || parser->tok == ']') {
+        if (parser->tok == ';' || (!parens && parser->tok == ']')) {
             break;
         }
     }
@@ -2174,6 +2230,301 @@ 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;
+
+    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;
+
+    array->setter = fval;
+
+    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;
+
+    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;
+
+    array->getter = fval;
+
+    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;
@@ -2233,8 +2584,16 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var)
             param = parse_typename(parser, NULL);
             if (!param)
                 goto on_error;
-            if (!paramlist_t_p_add(&params, param))
+            if (!paramlist_t_p_add(&params, param)) {
+                ast_delete(param);
+                goto on_error;
+            }
+            if (param->expression.vtype >= TYPE_VARIANT) {
+                char typename[1024];
+                ast_type_to_string((ast_expression*)param, typename, sizeof(typename));
+                parseerror(parser, "type not supported as part of a parameter list: %s", typename);
                 goto on_error;
+            }
         }
     }
 
@@ -2284,7 +2643,7 @@ static ast_value *parse_arraysize(parser_t *parser, ast_value *var)
 
     if (!cexp || !ast_istype(cexp, ast_value)) {
         if (cexp)
-            ast_delete(cexp);
+            ast_unref(cexp);
         ast_delete(var);
         parseerror(parser, "expected array-size as constant positive integer");
         return NULL;
@@ -2300,12 +2659,12 @@ static ast_value *parse_arraysize(parser_t *parser, ast_value *var)
     else if (cval->expression.vtype == TYPE_FLOAT)
         tmp->expression.count = cval->constval.vfloat;
     else {
-        ast_delete(cexp);
+        ast_unref(cexp);
         ast_delete(var);
         parseerror(parser, "array-size must be a positive integer constant");
         return NULL;
     }
-    ast_delete(cexp);
+    ast_unref(cexp);
 
     if (parser->tok != ']') {
         ast_delete(var);
@@ -2340,7 +2699,8 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase)
     lex_ctx    ctx;
 
     const char *name = NULL;
-    bool        isfield = false;
+    bool        isfield  = false;
+    bool        wasarray = false;
 
     ctx = parser_ctx(parser);
 
@@ -2406,6 +2766,7 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase)
 
     /* now this may be an array */
     if (parser->tok == '[') {
+        wasarray = true;
         var = parse_arraysize(parser, var);
         if (!var)
             return NULL;
@@ -2422,6 +2783,8 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase)
     /* now there may be function parens again */
     if (parser->tok == '(' && opts_standard == COMPILER_QCC)
         parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
+    if (parser->tok == '(' && wasarray)
+        parseerror(parser, "arrays as part of a return type is not supported");
     while (parser->tok == '(') {
         var = parse_parameter_list(parser, var);
         if (!var) {
@@ -2498,7 +2861,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
             }
         }
         if (parser->tok == '(' && wasarray) {
-            parseerror(parser, "functions cannot return arrays");
+            parseerror(parser, "arrays as part of a return type is not supported");
             /* we'll still parse the type completely for now */
         }
         /* for functions returning functions */
@@ -2721,6 +3084,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 == ';') {
@@ -3204,6 +3579,32 @@ bool parser_finish(const char *output)
                 return false;
             }
         }
+        for (i = 0; i < parser->globals_count; ++i) {
+            ast_value *asvalue;
+            if (!ast_istype(parser->globals[i].var, ast_value))
+                continue;
+            asvalue = (ast_value*)(parser->globals[i].var);
+            if (asvalue->setter) {
+                if (!ast_global_codegen(asvalue->setter, ir, false) ||
+                    !ast_function_codegen(asvalue->setter->constval.vfunc, ir) ||
+                    !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func))
+                {
+                    printf("failed to generate setter for %s\n", parser->globals[i].name);
+                    ir_builder_delete(ir);
+                    return false;
+                }
+            }
+            if (asvalue->getter) {
+                if (!ast_global_codegen(asvalue->getter, ir, false) ||
+                    !ast_function_codegen(asvalue->getter->constval.vfunc, ir) ||
+                    !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func))
+                {
+                    printf("failed to generate getter for %s\n", parser->globals[i].name);
+                    ir_builder_delete(ir);
+                    return false;
+                }
+            }
+        }
         for (i = 0; i < parser->functions_count; ++i) {
             if (!ast_function_codegen(parser->functions[i], ir)) {
                 printf("failed to generate function %s\n", parser->functions[i]->name);