fix

[xonotic/gmqcc.git] / parser.c

diff --git a/parser.c b/parser.c
index 3eaef0c5d87f835dc0b9da3d5d53a3ced016261c..681207c192c01d55b74f565856ae537d78b6fdaa 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -319,6 +319,9 @@ static ast_expression* parser_find_label(parser_t *parser, const char *name)
 
 static ast_expression* parser_find_global(parser_t *parser, const char *name)
 {
+    ast_expression *var = (ast_expression*)util_htget(parser->aliases, parser_tokval(parser));
+    if (var)
+        return var;
     return (ast_expression*)util_htget(parser->htglobals, name);
 }
 
@@ -1088,7 +1091,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
             } else {
                 ast_binary *eq = ast_binary_new(ctx, INSTR_EQ_F, exprs[0], exprs[1]);
 
-                eq->refs = false; /* references nothing */
+                eq->refs = (ast_binary_ref)false; /* references nothing */
 
                     /* if (lt) { */
                 out = (ast_expression*)ast_ternary_new(ctx,
@@ -1826,8 +1829,6 @@ static bool parse_sya_operand(parser_t *parser, shunt *sy, bool with_labels)
             /* intrinsics */
             if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) {
                 var = (ast_expression*)intrinsic_debug_typestring;
-            } else {
-                var = (ast_expression*)parser_find_var(parser, (const char *)util_htget(parser->aliases, parser_tokval(parser)));
             }
                 
             if (!var) {
@@ -5275,15 +5276,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
                             }
                         }
                     } else {
-                        void           *entry = (void*)var->desc;
-                        ast_expression *find  = parser_find_var(parser, var->desc);
-
-                        /* aliases to aliases are also allowed */
-                        if (!find) {
-                            char *name = NULL;
-                            if ((find = parser_find_var(parser, (const char *)(name = util_htget(parser->aliases, var->desc)))))
-                                entry = (void*)name;
-                        }
+                        ast_expression *find  = parser_find_global(parser, var->desc);
 
                         if (!find) {
                             compile_error(parser_ctx(parser), "undeclared variable `%s` for alias `%s`", var->desc, var->name);
@@ -5303,11 +5296,58 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
                             return false;
                         }
 
-                        util_htset(parser->aliases, var->name, entry);
                         /*
-                         * TODO: vector, find . or _ (last of), and build
-                         * [._]x, [._]y, [._]z  aliases too.
+                         * add alias to aliases table and to corrector
+                         * so corrections can apply for aliases as well.
                          */  
+                        util_htset(parser->aliases, var->name, find);
+
+                        /*
+                         * add to corrector so corrections can work
+                         * even for aliases too.
+                         */ 
+                        correct_add (
+                             vec_last(parser->correct_variables),
+                            &vec_last(parser->correct_variables_score),
+                            var->name
+                        );
+
+                        /* generate aliases for vector components */
+                        if (isvector) {
+                            char *buffer[3];
+
+                            util_asprintf(&buffer[0], "%s_x", var->desc);
+                            util_asprintf(&buffer[1], "%s_y", var->desc);
+                            util_asprintf(&buffer[2], "%s_z", var->desc);
+
+                            util_htset(parser->aliases, me[0]->name, parser_find_global(parser, buffer[0]));
+                            util_htset(parser->aliases, me[1]->name, parser_find_global(parser, buffer[1]));
+                            util_htset(parser->aliases, me[2]->name, parser_find_global(parser, buffer[2]));
+
+                            mem_d(buffer[0]);
+                            mem_d(buffer[1]);
+                            mem_d(buffer[2]);
+
+                            /*
+                             * add to corrector so corrections can work
+                             * even for aliases too.
+                             */  
+                            correct_add (
+                                 vec_last(parser->correct_variables),
+                                &vec_last(parser->correct_variables_score),
+                                me[0]->name
+                            );
+                            correct_add (
+                                 vec_last(parser->correct_variables),
+                                &vec_last(parser->correct_variables_score),
+                                me[1]->name
+                            );
+                            correct_add (
+                                 vec_last(parser->correct_variables),
+                                &vec_last(parser->correct_variables_score),
+                                me[2]->name
+                            );
+                        }
                     }
                 }
             } else {