X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;ds=sidebyside;f=parser.c;h=fb4f8671f3534cbe658ba13e3bbc8e4e04cb96fc;hb=2f5a26a4de1b8fdb8876f5b1efc34ec52127cdec;hp=945ddbf76c8ee0b4ff513e3f339b1ea4a6ddd9ee;hpb=336d91494fd5c09226a21fdc2b54852f59dce27a;p=xonotic%2Fgmqcc.git

diff --git a/parser.c b/parser.c
index 945ddbf..fb4f867 100644
--- a/parser.c
+++ b/parser.c
@@ -58,6 +58,12 @@ typedef struct {
 
     ast_function *function;
 
+    /* All the labels the function defined...
+     * Should they be in ast_function instead?
+     */
+    ast_label **labels;
+    ast_goto  **gotos;
+
     /* A list of hashtables for each scope */
     ht *variables;
     ht htfields;
@@ -594,6 +600,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy)
             vec_push(sy->out, syblock(ctx, blocks[0]));
             return true;
 
+        case opid2('+','P'):
+            out = exprs[0];
+            break;
         case opid2('-','P'):
             switch (exprs[0]->expression.vtype) {
                 case TYPE_FLOAT:
@@ -1422,7 +1431,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma
             vec_push(sy.out, syexp(parser_ctx(parser), (ast_expression*)val));
             DEBUGSHUNTDO(con_out("push %g\n", parser_token(parser)->constval.f));
         }
-        else if (parser->tok == TOKEN_INTCONST) {
+        else if (parser->tok == TOKEN_INTCONST || parser->tok == TOKEN_CHARCONST) {
             ast_value *val;
             if (wantop) {
                 parseerror(parser, "expected operator or end of statement, got constant");
@@ -2153,7 +2162,7 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou
             }
             if (!OPTS_FLAG(RELAXED_SWITCH)) {
                 opval = (ast_value*)swcase.value;
-                if (!ast_istype(swcase.value, ast_value) || !opval->constant) {
+                if (!ast_istype(swcase.value, ast_value)) { /* || !opval->constant) { */
                     parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch");
                     ast_unref(operand);
                     return false;
@@ -2227,8 +2236,43 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou
     return true;
 }
 
+static bool parse_goto(parser_t *parser, ast_expression **out)
+{
+    size_t    i;
+    ast_goto *gt;
+
+    if (!parser_next(parser) || parser->tok != TOKEN_IDENT) {
+        parseerror(parser, "expected label name after `goto`");
+        return false;
+    }
+
+    gt = ast_goto_new(parser_ctx(parser), parser_tokval(parser));
+
+    for (i = 0; i < vec_size(parser->labels); ++i) {
+        if (!strcmp(parser->labels[i]->name, parser_tokval(parser))) {
+            ast_goto_set_label(gt, parser->labels[i]);
+            break;
+        }
+    }
+    if (i == vec_size(parser->labels))
+        vec_push(parser->gotos, gt);
+
+    if (!parser_next(parser) || parser->tok != ';') {
+        parseerror(parser, "semicolon expected after goto label");
+        return false;
+    }
+    if (!parser_next(parser)) {
+        parseerror(parser, "parse error after goto");
+        return false;
+    }
+
+    *out = (ast_expression*)gt;
+    return true;
+}
+
 static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases)
 {
+    int cvq;
     ast_value *typevar = NULL;
     *out = NULL;
 
@@ -2251,12 +2295,23 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression *
         *out = NULL;
         return true;
     }
+    else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var"))
+    {
+        goto ident_var;
+    }
     else if (parser->tok == TOKEN_KEYWORD)
     {
         if (!strcmp(parser_tokval(parser), "local") ||
-            !strcmp(parser_tokval(parser), "const"))
+            !strcmp(parser_tokval(parser), "const") ||
+            !strcmp(parser_tokval(parser), "var"))
         {
-            int cvq = parser_tokval(parser)[0] == 'c' ? CV_CONST : CV_VAR;
+ident_var:
+            if (parser_tokval(parser)[0] == 'c')
+                cvq = CV_CONST;
+            else if (parser_tokval(parser)[0] == 'v')
+                cvq = CV_VAR;
+            else
+                cvq = CV_NONE;
 
             if (!block) {
                 parseerror(parser, "cannot declare a local variable here");
@@ -2271,6 +2326,39 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression *
             *out = NULL;
             return true;
         }
+        else if (!strcmp(parser_tokval(parser), "__builtin_debug_printtype"))
+        {
+            char ty[1024];
+            ast_value *tdef;
+
+            if (!parser_next(parser)) {
+                parseerror(parser, "parse error after __builtin_debug_printtype");
+                return false;
+            }
+
+            if (parser->tok == TOKEN_IDENT && (tdef = parser_find_typedef(parser, parser_tokval(parser), 0)))
+            {
+                ast_type_to_string((ast_expression*)tdef, ty, sizeof(ty));
+                con_out("__builtin_debug_printtype: `%s`=`%s`\n", tdef->name, ty);
+                if (!parser_next(parser)) {
+                    parseerror(parser, "parse error after __builtin_debug_printtype typename argument");
+                    return false;
+                }
+            }
+            else
+            {
+                if (!parse_statement(parser, block, out, allow_cases))
+                    return false;
+                if (!*out)
+                    con_out("__builtin_debug_printtype: got no output node\n");
+                else
+                {
+                    ast_type_to_string(*out, ty, sizeof(ty));
+                    con_out("__builtin_debug_printtype: `%s`\n", ty);
+                }
+            }
+            return true;
+        }
         else if (!strcmp(parser_tokval(parser), "return"))
         {
             return parse_return(parser, block, out);
@@ -2316,6 +2404,10 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression *
             }
             return true;
         }
+        else if (!strcmp(parser_tokval(parser), "goto"))
+        {
+            return parse_goto(parser, out);
+        }
         else if (!strcmp(parser_tokval(parser), "typedef"))
         {
             if (!parser_next(parser)) {
@@ -2336,6 +2428,36 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression *
         *out = (ast_expression*)inner;
         return true;
     }
+    else if (parser->tok == ':')
+    {
+        size_t i;
+        ast_label *label;
+        if (!parser_next(parser)) {
+            parseerror(parser, "expected label name");
+            return false;
+        }
+        if (parser->tok != TOKEN_IDENT) {
+            parseerror(parser, "label must be an identifier");
+            return false;
+        }
+        label = ast_label_new(parser_ctx(parser), parser_tokval(parser));
+        if (!label)
+            return false;
+        vec_push(parser->labels, label);
+        *out = (ast_expression*)label;
+        if (!parser_next(parser)) {
+            parseerror(parser, "parse error after label");
+            return false;
+        }
+        for (i = 0; i < vec_size(parser->gotos); ++i) {
+            if (!strcmp(parser->gotos[i]->name, label->name)) {
+                ast_goto_set_label(parser->gotos[i], label);
+                vec_remove(parser->gotos, i, 1);
+                --i;
+            }
+        }
+        return true;
+    }
     else if (parser->tok == ';')
     {
         if (!parser_next(parser)) {
@@ -2474,6 +2596,11 @@ static bool parse_function_body(parser_t *parser, ast_value *var)
     has_frame_think = false;
     old = parser->function;
 
+    if (vec_size(parser->gotos) || vec_size(parser->labels)) {
+        parseerror(parser, "gotos/labels leaking");
+        return false;
+    }
+
     if (var->expression.variadic) {
         if (parsewarning(parser, WARN_VARIADIC_FUNCTION,
                          "variadic function with implementation will not be able to access additional parameters"))
@@ -3296,13 +3423,12 @@ static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_va
                 return NULL;
             }
         }
-
-        if (parser->tok == TOKEN_IDENT)
-            cached_typedef = parser_find_typedef(parser, parser_tokval(parser), 0);
-        if (!cached_typedef && parser->tok != TOKEN_TYPENAME) {
-            parseerror(parser, "expected typename");
-            return NULL;
-        }
+    }
+    if (parser->tok == TOKEN_IDENT)
+        cached_typedef = parser_find_typedef(parser, parser_tokval(parser), 0);
+    if (!cached_typedef && parser->tok != TOKEN_TYPENAME) {
+        parseerror(parser, "expected typename");
+        return NULL;
     }
 
     /* generate the basic type value */
@@ -3842,6 +3968,7 @@ skipvar:
         }
         else if (parser->tok == '{' || parser->tok == '[')
         {
+            size_t i;
             if (localblock) {
                 parseerror(parser, "cannot declare functions within functions");
                 break;
@@ -3850,6 +3977,10 @@ skipvar:
             if (!parse_function_body(parser, var))
                 break;
             ast_delete(basetype);
+            for (i = 0; i < vec_size(parser->gotos); ++i)
+                parseerror(parser, "undefined label: `%s`", parser->gotos[i]->name);
+            vec_free(parser->gotos);
+            vec_free(parser->labels);
             return true;
         } else {
             ast_expression *cexp;
@@ -4227,6 +4358,9 @@ void parser_cleanup()
     vec_free(parser->typedefs);
     vec_free(parser->_blocktypedefs);
 
+    vec_free(parser->labels);
+    vec_free(parser->gotos);
+
     mem_d(parser);
 }