X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=parser.c;h=c13fb8927decb5e12b8602665f5a734f9e265aac;hb=535fd5744b9a03fa8f2e8ee65976b173f125338c;hp=752d62a2ad3c5358e119facce38d7aa5c6ca2a69;hpb=3424b7227b61ea7aef13a4ff03ff68200d62b5ad;p=xonotic%2Fgmqcc.git diff --git a/parser.c b/parser.c index 752d62a..c13fb89 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; @@ -69,6 +75,7 @@ typedef struct { size_t *_blocklocals; ast_value **_typedefs; size_t *_blocktypedefs; + lex_ctx *_block_ctx; size_t errors; @@ -82,17 +89,13 @@ typedef struct { qcint memberof; } parser_t; -#define CV_NONE 0 -#define CV_CONST 1 -#define CV_VAR -1 - static void parser_enterblock(parser_t *parser); static bool parser_leaveblock(parser_t *parser); static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e); static bool parse_typedef(parser_t *parser); -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int is_const_var, ast_value *cached_typedef); -static ast_block* parse_block(parser_t *parser, bool warnreturn); -static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn); +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef); +static ast_block* parse_block(parser_t *parser); +static bool parse_block_into(parser_t *parser, ast_block *block); static ast_expression* parse_statement_or_block(parser_t *parser); static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases); static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma); @@ -215,7 +218,7 @@ static ast_value* parser_const_float(parser_t *parser, double d) return parser->imm_float[i]; } out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_FLOAT); - out->constant = true; + out->cvq = CV_CONST; out->hasvalue = true; out->constval.vfloat = d; vec_push(parser->imm_float, out); @@ -261,7 +264,7 @@ static ast_value* parser_const_string(parser_t *parser, const char *str, bool do out = ast_value_new(parser_ctx(parser), name, TYPE_STRING); } else out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_STRING); - out->constant = true; + out->cvq = CV_CONST; out->hasvalue = true; out->constval.vstring = parser_strdup(str); vec_push(parser->imm_string, out); @@ -277,7 +280,7 @@ static ast_value* parser_const_vector(parser_t *parser, vector v) return parser->imm_vector[i]; } out = ast_value_new(parser_ctx(parser), "#IMMEDIATE", TYPE_VECTOR); - out->constant = true; + out->cvq = CV_CONST; out->hasvalue = true; out->constval.vvec = v; vec_push(parser->imm_vector, out); @@ -479,6 +482,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ast_expression *exprs[3]; ast_block *blocks[3]; ast_value *asvalue[3]; + ast_binstore *asbinstore; size_t i, assignop, addop, subop; qcint generated_op = 0; @@ -524,7 +528,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) (exprs[0]->expression.vtype != exprs[1]->expression.vtype || \ exprs[0]->expression.vtype != T) #define CanConstFold1(A) \ - (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue && ((ast_value*)(A))->constant) + (ast_istype((A), ast_value) && ((ast_value*)(A))->hasvalue && (((ast_value*)(A))->cvq == CV_CONST)) #define CanConstFold(A, B) \ (CanConstFold1(A) && CanConstFold1(B)) #define ConstV(i) (asvalue[(i)]->constval.vvec) @@ -594,6 +598,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: @@ -838,7 +845,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) if (exprs[1]->expression.vtype != exprs[2]->expression.vtype) { ast_type_to_string(exprs[1], ty1, sizeof(ty1)); ast_type_to_string(exprs[2], ty2, sizeof(ty2)); - parseerror(parser, "iperands of ternary expression must have the same type, got %s and %s", ty1, ty2); + parseerror(parser, "operands of ternary expression must have the same type, got %s and %s", ty1, ty2); return false; } if (CanConstFold1(exprs[0])) @@ -896,7 +903,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) if (!ast_compare_type(field->expression.next, exprs[1])) { ast_type_to_string(field->expression.next, ty1, sizeof(ty1)); ast_type_to_string(exprs[1], ty2, sizeof(ty2)); - if (opts_standard == COMPILER_QCC && + if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) && field->expression.next->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { @@ -930,7 +937,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) 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 && + if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) && exprs[0]->expression.vtype == TYPE_FUNCTION && exprs[1]->expression.vtype == TYPE_FUNCTION) { @@ -944,7 +951,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); } } - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } out = (ast_expression*)ast_store_new(ctx, assignop, exprs[0], exprs[1]); @@ -961,7 +968,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) addop = INSTR_ADD_F; else addop = INSTR_SUB_F; - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) { @@ -989,7 +996,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) addop = INSTR_SUB_F; subop = INSTR_ADD_F; } - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) { @@ -1018,7 +1025,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) @@ -1055,7 +1062,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) @@ -1099,7 +1106,7 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) ty1, ty2); return false; } - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } if (ast_istype(exprs[0], ast_entfield)) @@ -1129,10 +1136,12 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) out = (ast_expression*)ast_binary_new(ctx, INSTR_BITAND, exprs[0], exprs[1]); if (!out) return false; - if (ast_istype(exprs[0], ast_value) && asvalue[0]->constant) { + if (ast_istype(exprs[0], ast_value) && asvalue[0]->cvq == CV_CONST) { parseerror(parser, "assignment to constant `%s`", asvalue[0]->name); } - out = (ast_expression*)ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out); + asbinstore = ast_binstore_new(ctx, assignop, INSTR_SUB_F, exprs[0], out); + asbinstore->keep_dest = true; + out = (ast_expression*)asbinstore; break; } #undef NotSameType @@ -1404,8 +1413,14 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma parseerror(parser, "unexpected ident: %s", parser_tokval(parser)); goto onerr; } - if (ast_istype(var, ast_value)) + if (ast_istype(var, ast_value)) { ((ast_value*)var)->uses++; + } + else if (ast_istype(var, ast_member)) { + ast_member *mem = (ast_member*)var; + if (ast_istype(mem->owner, ast_value)) + ((ast_value*)(mem->owner))->uses++; + } vec_push(sy.out, syexp(parser_ctx(parser), var)); DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser))); } @@ -1422,7 +1437,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"); @@ -1666,6 +1681,7 @@ static void parser_enterblock(parser_t *parser) vec_push(parser->_blocklocals, vec_size(parser->_locals)); vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE)); vec_push(parser->_blocktypedefs, vec_size(parser->_typedefs)); + vec_push(parser->_block_ctx, parser_ctx(parser)); } static bool parser_leaveblock(parser_t *parser) @@ -1692,8 +1708,10 @@ static bool parser_leaveblock(parser_t *parser) ast_value *v = (ast_value*)e; vec_pop(parser->_locals); if (ast_istype(e, ast_value) && !v->uses) { - if (parsewarning(parser, WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name)) + if (compile_warning(ast_ctx(v), WARN_UNUSED_VARIABLE, "unused variable: `%s`", v->name)) { + parser->errors++; rv = false; + } } } @@ -1705,6 +1723,7 @@ static bool parser_leaveblock(parser_t *parser) util_htdel(vec_last(parser->typedefs)); vec_pop(parser->typedefs); + vec_pop(parser->_block_ctx); return rv; } @@ -2027,6 +2046,8 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou ast_return *ret = NULL; ast_value *expected = parser->function->vtype; + lex_ctx ctx = parser_ctx(parser); + (void)block; /* not touching */ if (!parser_next(parser)) { @@ -2057,7 +2078,7 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou else parseerror(parser, "return without value"); } - ret = ast_return_new(parser_ctx(parser), NULL); + ret = ast_return_new(ctx, NULL); } *out = (ast_expression*)ret; return true; @@ -2091,6 +2112,7 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou lex_ctx ctx = parser_ctx(parser); (void)block; /* not touching */ + (void)opval; /* parse over the opening paren */ if (!parser_next(parser) || parser->tok != '(') { @@ -2153,7 +2175,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->cvq != CV_CONST) { */ parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch"); ast_unref(operand); return false; @@ -2227,8 +2249,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,10 +2308,24 @@ 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")) + if (!strcmp(parser_tokval(parser), "local") || + !strcmp(parser_tokval(parser), "const") || + !strcmp(parser_tokval(parser), "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"); return false; @@ -2263,11 +2334,44 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * parseerror(parser, "expected variable declaration"); return false; } - if (!parse_variable(parser, block, true, CV_VAR, NULL)) + if (!parse_variable(parser, block, true, cvq, NULL)) return false; *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); @@ -2313,6 +2417,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)) { @@ -2327,12 +2435,42 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * else if (parser->tok == '{') { ast_block *inner; - inner = parse_block(parser, false); + inner = parse_block(parser); if (!inner) return false; *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)) { @@ -2355,7 +2493,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } } -static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn) +static bool parse_block_into(parser_t *parser, ast_block *block) { bool retval = true; @@ -2385,17 +2523,6 @@ static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn if (parser->tok != '}') { block = NULL; } else { - if (warnreturn && parser->function->vtype->expression.next->expression.vtype != TYPE_VOID) - { - if (!vec_size(block->exprs) || - !ast_istype(vec_last(block->exprs), ast_return)) - { - if (parsewarning(parser, WARN_MISSING_RETURN_VALUES, "control reaches end of non-void function")) { - block = NULL; - goto cleanup; - } - } - } (void)parser_next(parser); } @@ -2405,13 +2532,13 @@ cleanup: return retval && !!block; } -static ast_block* parse_block(parser_t *parser, bool warnreturn) +static ast_block* parse_block(parser_t *parser) { ast_block *block; block = ast_block_new(parser_ctx(parser)); if (!block) return NULL; - if (!parse_block_into(parser, block, warnreturn)) { + if (!parse_block_into(parser, block)) { ast_block_delete(block); return NULL; } @@ -2422,7 +2549,7 @@ static ast_expression* parse_statement_or_block(parser_t *parser) { ast_expression *expr = NULL; if (parser->tok == '{') - return (ast_expression*)parse_block(parser, false); + return (ast_expression*)parse_block(parser); if (!parse_statement(parser, NULL, &expr, false)) return NULL; return expr; @@ -2471,6 +2598,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")) @@ -2699,7 +2831,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) vec_push(parser->functions, func); parser->function = func; - if (!parse_block_into(parser, block, true)) { + if (!parse_block_into(parser, block)) { ast_block_delete(block); goto enderrfn; } @@ -3293,13 +3425,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 */ @@ -3444,7 +3575,7 @@ static bool parse_typedef(parser_t *parser) return true; } -static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int is_const_var, ast_value *cached_typedef) +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef) { ast_value *var; ast_value *proto; @@ -3507,8 +3638,7 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield } } - if (is_const_var == CV_CONST) - var->constant = true; + var->cvq = qualifier; /* Part 1: * check for validity: (end_sys_..., multiple-definitions, prototypes, ...) @@ -3610,6 +3740,15 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield retval = false; goto cleanup; } + proto = (ast_value*)old; + if (!ast_istype(old, ast_value)) { + parseerror(parser, "internal error: not an ast_value"); + retval = false; + proto = NULL; + goto cleanup; + } + ast_delete(var); + var = proto; } } if (opts_standard == COMPILER_QCC && @@ -3839,14 +3978,22 @@ skipvar: } else if (parser->tok == '{' || parser->tok == '[') { + size_t i; if (localblock) { parseerror(parser, "cannot declare functions within functions"); break; } + if (proto) + ast_ctx(proto) = parser_ctx(parser); + 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; @@ -3858,15 +4005,15 @@ skipvar: if (!localblock) { cval = (ast_value*)cexp; - if (!ast_istype(cval, ast_value) || !cval->hasvalue || !cval->constant) + if (!ast_istype(cval, ast_value) || !cval->hasvalue || cval->cvq != CV_CONST) parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); else { if (opts_standard != COMPILER_GMQCC && !OPTS_FLAG(INITIALIZED_NONCONSTANTS) && - is_const_var != CV_VAR) + qualifier != CV_VAR) { - var->constant = true; + var->cvq = CV_CONST; } var->hasvalue = true; if (cval->expression.vtype == TYPE_STRING) @@ -3876,7 +4023,10 @@ skipvar: ast_unref(cval); } } else { + bool cvq; shunt sy = { NULL, NULL }; + cvq = var->cvq; + var->cvq = CV_NONE; vec_push(sy.out, syexp(ast_ctx(var), (ast_expression*)var)); vec_push(sy.out, syexp(ast_ctx(cexp), (ast_expression*)cexp)); vec_push(sy.ops, syop(ast_ctx(var), parser->assign_op)); @@ -3889,6 +4039,7 @@ skipvar: } vec_free(sy.out); vec_free(sy.ops); + var->cvq = cvq; } } @@ -4220,6 +4371,11 @@ void parser_cleanup() vec_free(parser->typedefs); vec_free(parser->_blocktypedefs); + vec_free(parser->_block_ctx); + + vec_free(parser->labels); + vec_free(parser->gotos); + mem_d(parser); }