From: Wolfgang (Blub) Bumiller Date: Sat, 10 Nov 2012 10:54:30 +0000 (+0100) Subject: Removing old commented-out parsing code X-Git-Tag: 0.1~19^2~56 X-Git-Url: https://git.rm.cloudns.org/?a=commitdiff_plain;h=0fc3a0c517ee44a8c836319871d6b33587780ad4;p=xonotic%2Fgmqcc.git Removing old commented-out parsing code --- diff --git a/parser.c b/parser.c index 27583ae..ab1abeb 100644 --- a/parser.c +++ b/parser.c @@ -306,133 +306,6 @@ static ast_expression* parser_find_var(parser_t *parser, const char *name) return v; } -#if 0 -typedef struct { - MEM_VECTOR_MAKE(ast_value*, p); -} paramlist_t; -MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p) - -static ast_value *parse_type(parser_t *parser, int basetype, bool *isfunc) -{ - paramlist_t params; - ast_value *var; - lex_ctx ctx = parser_ctx(parser); - int vtype = basetype; - int temptype; - size_t i; - bool variadic = false; - - MEM_VECTOR_INIT(¶ms, p); - - *isfunc = false; - - if (parser->tok == '(') { - *isfunc = true; - while (true) { - ast_value *param; - ast_value *fld; - bool isfield = false; - bool isfuncparam = false; - - if (!parser_next(parser)) - goto on_error; - - if (parser->tok == ')') - break; - - if (parser->tok == '.') { - isfield = true; - if (!parser_next(parser)) { - parseerror(parser, "expected field parameter type"); - goto on_error; - } - } - - if (parser->tok == TOKEN_DOTS) { - /* variadic args */ - variadic = true; - if (!parser_next(parser)) - goto on_error; - if (parser->tok != ')') { - parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); - goto on_error; - } - if (opts_standard == COMPILER_QCC) { - if (parsewarning(parser, WARN_EXTENSIONS, "variadic functions are not available in this standard")) - goto on_error; - } - break; - } - - temptype = parser_token(parser)->constval.t; - if (!parser_next(parser)) - goto on_error; - - param = parse_type(parser, temptype, &isfuncparam); - - if (!param) - goto on_error; - - if (parser->tok == TOKEN_IDENT) { - /* named parameter */ - if (!ast_value_set_name(param, parser_tokval(parser))) - goto on_error; - if (!parser_next(parser)) - goto on_error; - } - - /* This comes before the isfield part! */ - if (isfuncparam) { - ast_value *fval = ast_value_new(ast_ctx(param), param->name, TYPE_FUNCTION); - if (!fval) { - ast_delete(param); - goto on_error; - } - fval->expression.next = (ast_expression*)param; - MEM_VECTOR_MOVE(¶m->expression, params, &fval->expression, params); - fval->expression.variadic = param->expression.variadic; - param = fval; - } - - if (isfield) { - fld = ast_value_new(ctx, param->name, TYPE_FIELD); - fld->expression.next = (ast_expression*)param; - param = fld; - } - - if (!paramlist_t_p_add(¶ms, param)) { - parseerror(parser, "Out of memory while parsing typename"); - goto on_error; - } - - if (parser->tok == ',') - continue; - if (parser->tok == ')') - break; - parseerror(parser, "Unexpected token"); - goto on_error; - } - if (!parser_next(parser)) - goto on_error; - } - - if (params.p_count > 8) - parseerror(parser, "more than 8 parameters are currently not supported"); - - var = ast_value_new(ctx, "", vtype); - if (!var) - goto on_error; - var->expression.variadic = variadic; - MEM_VECTOR_MOVE(¶ms, p, &var->expression, params); - return var; -on_error: - for (i = 0; i < params.p_count; ++i) - ast_value_delete(params.p[i]); - MEM_VECTOR_CLEAR(¶ms, p); - return NULL; -} -#endif - typedef struct { size_t etype; /* 0 = expression, others are operators */ @@ -2901,529 +2774,6 @@ cleanup: if (ve[1].var) mem_d(ve[1].var); if (ve[2].var) mem_d(ve[2].var); return retval; - -#if 0 - bool isfunc = false; - lex_ctx ctx; - - ast_value *var = NULL; - ast_value *fld = NULL; - bool cleanvar = false; - - varentry_t varent; - varentry_t ve[3]; - - ast_expression *olddecl; - - ast_value *typevar; - - bool hadproto; - bool isparam; - - bool retval = true; - bool isfield = false; - - /* go */ - - int basetype; - - if (parser->tok == '.') { - isfield = true; - if (!parser_next(parser)) { - parseerror(parser, "expected typename for field definition"); - return false; - } - } - - basetype = parser_token(parser)->constval.t; - - if (!parser_next(parser)) { - parseerror(parser, "expected variable definition"); - return false; - } - - typevar = parse_type(parser, basetype, &isfunc); - if (!typevar) - return false; - - while (true) - { - hadproto = false; - olddecl = NULL; - isparam = false; - varent.name = NULL; - - ve[0].name = ve[1].name = ve[2].name = NULL; - ve[0].var = ve[1].var = ve[2].var = NULL; - - ctx = parser_ctx(parser); - var = ast_value_copy(typevar); - cleanvar = true; - - if (!var) { - parseerror(parser, "failed to create variable"); - retval = false; - goto cleanup; - } - - if (parser->tok != TOKEN_IDENT) { - parseerror(parser, "expected variable name"); - retval = false; - goto cleanup; - } - - if (!localblock) { - bool was_end = false; - if (!strcmp(parser_tokval(parser), "end_sys_globals")) { - parser->crc_globals = parser->globals_count; - was_end = true; - } - else if (!strcmp(parser_tokval(parser), "end_sys_fields")) { - parser->crc_fields = parser->fields_count; - was_end = true; - } - if (isfield && was_end) { - if (parsewarning(parser, WARN_END_SYS_FIELDS, - "global '%s' hint should not be a field", - parser_tokval(parser))) - { - retval = false; - goto cleanup; - } - - } - } - - if (!ast_value_set_name(var, parser_tokval(parser))) { - parseerror(parser, "failed to set variable name\n"); - retval = false; - goto cleanup; - } - - if (isfunc) { - /* a function was defined */ - ast_value *fval; - ast_value *proto = NULL; - bool dummy; - - if (!localblock) - olddecl = parser_find_global(parser, parser_tokval(parser)); - else - olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal, &dummy); - - if (olddecl) { - /* we had a prototype */ - if (!ast_istype(olddecl, ast_value)) { - /* vector v; - * void() v_x = {} - */ - parseerror(parser, "cannot declare a function with the same name as a vector's member: %s", - parser_tokval(parser)); - retval = false; - goto cleanup; - } - - proto = (ast_value*)olddecl; - } - - /* turn var into a value of TYPE_FUNCTION, with the old var - * as return type - */ - fval = ast_value_new(ctx, var->name, TYPE_FUNCTION); - if (!fval) { - retval = false; - goto cleanup; - } - - fval->expression.next = (ast_expression*)var; - MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params); - fval->expression.variadic = var->expression.variadic; - var = NULL; - - /* we compare the type late here, but it's easier than - * messing with the parameter-vector etc. earlier - */ - if (proto) { - size_t param; - if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) { - parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i", - proto->name, - ast_ctx(proto).file, ast_ctx(proto).line); - ast_value_delete(fval); - retval = false; - goto cleanup; - } - /* copy over the parameter names */ - for (param = 0; param < fval->expression.params_count; ++param) - ast_value_set_name(proto->expression.params[param], fval->expression.params[param]->name); - /* copy the new context */ - ast_ctx(proto) = ast_ctx(fval); - - /* now ditch the rest of the new data */ - ast_value_delete(fval); - fval = proto; - hadproto = true; - } - - var = fval; - } - - if (isfield) { - ast_value *tmp; - fld = ast_value_new(ctx, var->name, TYPE_FIELD); - fld->expression.next = (ast_expression*)var; - tmp = var; - var = fld; - fld = tmp; - } - else - fld = var; - - if (!isfunc) { - if (!localblock) - { - olddecl = parser_find_global(parser, var->name); - if (olddecl) { - if (!isfield) { - parseerror(parser, "global `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - else if (opts_standard == COMPILER_QCC) { - parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); - parseerror(parser, "global `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - } - olddecl = parser_find_field(parser, var->name); - if (olddecl && opts_standard == COMPILER_QCC) { - if (!isfield) { - parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); - parseerror(parser, "field `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - else - { - if (parsewarning(parser, WARN_FIELD_REDECLARED, "field `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line)) - { - retval = false; - goto cleanup; - } - if (!ast_compare_type(olddecl, (ast_expression*)var)) { - parseerror(parser, "field %s has previously been declared with a different type here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - ast_delete(var); - var = NULL; - goto nextvar; - } - } - else if (olddecl) { - parseerror(parser, "field `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - } - } - if (localblock) /* if it's a local: */ - { - olddecl = parser_find_local(parser, var->name, parser->blocklocal, &isparam); - if (opts_standard == COMPILER_GMQCC) - { - if (olddecl) - { - if (!isparam) { - parseerror(parser, "local `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - } - - if( (!isparam && olddecl) || - (olddecl = parser_find_local(parser, var->name, 0, &isparam)) - ) - { - if (parsewarning(parser, WARN_LOCAL_SHADOWS, - "local `%s` is shadowing a parameter", var->name)) - { - parseerror(parser, "local `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - } - } - else - { - if (olddecl) - { - if (isparam && - parsewarning(parser, WARN_LOCAL_SHADOWS, - "a parameter is shadowing local `%s`", var->name)) - { - ast_value_delete(var); - var = NULL; - retval = false; - goto cleanup; - } - else if (!isparam) - { - parseerror(parser, "local `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - ast_value_delete(var); - var = NULL; - retval = false; - goto cleanup; - } - ast_value_delete(var); - var = NULL; - goto nextvar; - } - } - } - - - if (!hadproto) { - varent.name = util_strdup(var->name); - varent.var = (ast_expression*)var; - - if (!localblock) { - if (!isfield) { - if (!(retval = parser_t_globals_add(parser, varent))) - goto cleanup; - } - else { - if (!(retval = parser_t_fields_add(parser, varent))) - goto cleanup; - } - } else { - if (!(retval = parser_t_locals_add(parser, varent))) - goto cleanup; - if (!(retval = ast_block_locals_add(localblock, var))) { - parser->locals_count--; - goto cleanup; - } - } - - if (fld->expression.vtype == TYPE_VECTOR) - { - size_t e; - if (!create_vector_members(parser, var, ve)) { - retval = false; - goto cleanup; - } - - if (!localblock) { - for (e = 0; e < 3; ++e) { - if (!isfield) { - if (!(retval = parser_t_globals_add(parser, ve[e]))) - break; - } - else { - if (!(retval = parser_t_fields_add(parser, ve[e]))) - break; - } - } - if (!retval) { - parser->globals_count -= e+1; - goto cleanup; - } - } else { - for (e = 0; e < 3; ++e) { - if (!(retval = parser_t_locals_add(parser, ve[e]))) - break; - if (!(retval = ast_block_collect(localblock, ve[e].var))) - break; - ve[e].var = NULL; /* from here it's being collected in the block */ - } - if (!retval) { - parser->locals_count -= e+1; - localblock->locals_count--; - goto cleanup; - } - } - ve[0].name = ve[1].name = ve[2].name = NULL; - ve[0].var = ve[1].var = ve[2].var = NULL; - } - cleanvar = false; - varent.name = NULL; - } - -nextvar: - if (!(retval = parser_next(parser))) - goto cleanup; - - if (parser->tok == ';') { - ast_value_delete(typevar); - return parser_next(parser); - } - - if (parser->tok == ',') { - /* another var */ - if (!(retval = parser_next(parser))) - goto cleanup; - continue; - } - - if (!localblock && isfield) { - parseerror(parser, "missing semicolon"); - ast_value_delete(typevar); - return false; - } - - /* NOTE: only 'typevar' needs to be deleted from here on, so 'cleanup' won't be used - * to avoid having too many gotos - */ - if (localblock && opts_standard == COMPILER_QCC) { - if (parsewarning(parser, WARN_LOCAL_CONSTANTS, - "initializing expression turns variable `%s` into a constant in this standard", - var->name) ) - { - ast_value_delete(typevar); - return false; - } - } - - if (parser->tok != '=') { - if (opts_standard == COMPILER_QCC) - parseerror(parser, "missing semicolon"); - else - parseerror(parser, "missing semicolon or initializer"); - ast_value_delete(typevar); - return false; - } - - if (!parser_next(parser)) { - ast_value_delete(typevar); - return false; - } - - if (parser->tok == '#') { - ast_function *func; - - if (localblock) { - parseerror(parser, "cannot declare builtins within functions"); - ast_value_delete(typevar); - return false; - } - if (!isfunc) { - parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name); - ast_value_delete(typevar); - return false; - } - if (!parser_next(parser)) { - parseerror(parser, "expected builtin number"); - ast_value_delete(typevar); - return false; - } - if (parser->tok != TOKEN_INTCONST) { - parseerror(parser, "builtin number must be an integer constant"); - ast_value_delete(typevar); - return false; - } - if (parser_token(parser)->constval.i <= 0) { - parseerror(parser, "builtin number must be positive integer greater than zero"); - ast_value_delete(typevar); - return false; - } - - func = ast_function_new(ast_ctx(var), var->name, var); - if (!func) { - parseerror(parser, "failed to allocate function for `%s`", var->name); - ast_value_delete(typevar); - return false; - } - if (!parser_t_functions_add(parser, func)) { - parseerror(parser, "failed to allocate slot for function `%s`", var->name); - ast_function_delete(func); - var->constval.vfunc = NULL; - ast_value_delete(typevar); - return false; - } - - func->builtin = -parser_token(parser)->constval.i; - - if (!parser_next(parser)) { - ast_value_delete(typevar); - return false; - } - } - else if (parser->tok == '{' || parser->tok == '[') - { - ast_value_delete(typevar); - if (localblock) { - parseerror(parser, "cannot declare functions within functions"); - return false; - } - - if (!parse_function_body(parser, var)) { - return false; - } - return true; - } else { - ast_expression *cexp; - ast_value *cval; - - cexp = parse_expression_leave(parser, true); - if (!cexp) { - ast_value_delete(typevar); - return false; - } - - cval = (ast_value*)cexp; - if (!ast_istype(cval, ast_value) || !cval->isconst) - parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); - else - { - var->isconst = true; - if (cval->expression.vtype == TYPE_STRING) - var->constval.vstring = parser_strdup(cval->constval.vstring); - else - memcpy(&var->constval, &cval->constval, sizeof(var->constval)); - ast_unref(cval); - } - } - - if (parser->tok == ',') { - /* another */ - continue; - } - - if (parser->tok != ';') { - parseerror(parser, "missing semicolon"); - ast_value_delete(typevar); - return false; - } - - (void)parser_next(parser); - - ast_value_delete(typevar); - return true; - } - -cleanup: - ast_delete(typevar); - if (var && cleanvar) ast_delete(var); - if (varent.name) mem_d(varent.name); - if (ve[0].name) mem_d(ve[0].name); - if (ve[1].name) mem_d(ve[1].name); - if (ve[2].name) mem_d(ve[2].name); - if (ve[0].var) mem_d(ve[0].var); - if (ve[1].var) mem_d(ve[1].var); - if (ve[2].var) mem_d(ve[2].var); - - return retval; -#endif } static bool parser_global_statement(parser_t *parser)