From dedb3a49bdb619bf4fc303e0da6d4740fc9a4527 Mon Sep 17 00:00:00 2001 From: Wolfgang Bumiller Date: Mon, 19 Jan 2015 13:46:10 +0100 Subject: [PATCH] ast_expression: params -> type_params --- ast.cpp | 48 ++++++++++++++++++++++++------------------------ ast.h | 2 +- intrin.cpp | 42 +++++++++++++++++++++--------------------- parser.cpp | 46 +++++++++++++++++++++++----------------------- 4 files changed, 69 insertions(+), 69 deletions(-) diff --git a/ast.cpp b/ast.cpp index 73f9b12..d71c471 100644 --- a/ast.cpp +++ b/ast.cpp @@ -104,7 +104,7 @@ static void ast_expression_delete(ast_expression *self) { if (self->next) ast_delete(self->next); - for (auto &it : self->params) + for (auto &it : self->type_params) ast_delete(it); if (self->varparam) ast_delete(self->varparam); @@ -128,9 +128,9 @@ ast_value* ast_value_copy(const ast_value *self) selfex = &cp->expression; selfex->count = fromex->count; selfex->flags = fromex->flags; - for (auto &it : fromex->params) { + for (auto &it : fromex->type_params) { ast_value *v = ast_value_copy(it); - selfex->params.push_back(v); + selfex->type_params.push_back(v); } return cp; } @@ -147,9 +147,9 @@ void ast_type_adopt_impl(ast_expression *self, const ast_expression *other) selfex = self; selfex->count = fromex->count; selfex->flags = fromex->flags; - for (auto &it : fromex->params) { + for (auto &it : fromex->type_params) { ast_value *v = ast_value_copy(it); - selfex->params.push_back(v); + selfex->type_params.push_back(v); } } @@ -189,9 +189,9 @@ ast_expression* ast_type_copy(lex_ctx_t ctx, const ast_expression *ex) selfex->count = fromex->count; selfex->flags = fromex->flags; - for (auto &it : fromex->params) { + for (auto &it : fromex->type_params) { ast_value *v = ast_value_copy(it); - selfex->params.push_back(v); + selfex->type_params.push_back(v); } return self; @@ -207,18 +207,18 @@ bool ast_compare_type(ast_expression *a, ast_expression *b) return false; if (!a->next != !b->next) return false; - if (a->params.size() != b->params.size()) + if (a->type_params.size() != b->type_params.size()) return false; if ((a->flags & AST_FLAG_TYPE_MASK) != (b->flags & AST_FLAG_TYPE_MASK) ) { return false; } - if (a->params.size()) { + if (a->type_params.size()) { size_t i; - for (i = 0; i < a->params.size(); ++i) { - if (!ast_compare_type((ast_expression*)a->params[i], - (ast_expression*)b->params[i])) + for (i = 0; i < a->type_params.size(); ++i) { + if (!ast_compare_type((ast_expression*)a->type_params[i], + (ast_expression*)b->type_params[i])) return false; } } @@ -267,19 +267,19 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi pos = ast_type_to_string_impl(e->next, buf, bufsize, pos); if (pos + 2 >= bufsize) goto full; - if (e->params.empty()) { + if (e->type_params.empty()) { buf[pos++] = '('; buf[pos++] = ')'; return pos; } buf[pos++] = '('; - pos = ast_type_to_string_impl((ast_expression*)(e->params[0]), buf, bufsize, pos); - for (i = 1; i < e->params.size(); ++i) { + pos = ast_type_to_string_impl((ast_expression*)(e->type_params[0]), buf, bufsize, pos); + for (i = 1; i < e->type_params.size(); ++i) { if (pos + 2 >= bufsize) goto full; buf[pos++] = ','; buf[pos++] = ' '; - pos = ast_type_to_string_impl((ast_expression*)(e->params[i]), buf, bufsize, pos); + pos = ast_type_to_string_impl((ast_expression*)(e->type_params[i]), buf, bufsize, pos); } if (pos + 1 >= bufsize) goto full; @@ -394,7 +394,7 @@ void ast_value_delete(ast_value* self) void ast_value_params_add(ast_value *self, ast_value *p) { - self->expression.params.push_back(p); + self->expression.type_params.push_back(p); } bool ast_value_set_name(ast_value *self, const char *name) @@ -1042,8 +1042,8 @@ bool ast_call_check_types(ast_call *self, ast_expression *va_type) bool retval = true; const ast_expression *func = self->func; size_t count = self->params.size(); - if (count > func->params.size()) - count = func->params.size(); + if (count > func->type_params.size()) + count = func->type_params.size(); for (i = 0; i < count; ++i) { if (ast_istype(self->params[i], ast_argpipe)) { @@ -1052,13 +1052,13 @@ bool ast_call_check_types(ast_call *self, ast_expression *va_type) compile_error(ast_ctx(self), "argpipe must be the last parameter to a function call"); return false; } - if (!ast_call_check_vararg(self, va_type, (ast_expression*)func->params[i])) + if (!ast_call_check_vararg(self, va_type, (ast_expression*)func->type_params[i])) retval = false; } - else if (!ast_compare_type(self->params[i], (ast_expression*)(func->params[i]))) + else if (!ast_compare_type(self->params[i], (ast_expression*)(func->type_params[i]))) { ast_type_to_string(self->params[i], tgot, sizeof(tgot)); - ast_type_to_string((ast_expression*)func->params[i], texp, sizeof(texp)); + ast_type_to_string((ast_expression*)func->type_params[i], texp, sizeof(texp)); compile_error(ast_ctx(self), "invalid type for parameter %u in function call: expected %s, got %s", (unsigned int)(i+1), texp, tgot); /* we don't immediately return */ @@ -1066,7 +1066,7 @@ bool ast_call_check_types(ast_call *self, ast_expression *va_type) } } count = self->params.size(); - if (count > func->params.size() && func->varparam) { + if (count > func->type_params.size() && func->varparam) { for (; i < count; ++i) { if (ast_istype(self->params[i], ast_argpipe)) { /* warn about type safety instead */ @@ -1782,7 +1782,7 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) /* fill the parameter list */ ec = &self->function_type->expression; - for (auto &it : ec->params) { + for (auto &it : ec->type_params) { if (it->expression.vtype == TYPE_FIELD) vec_push(irf->params, it->expression.next->vtype); else diff --git a/ast.h b/ast.h index dcfffba..69e0392 100644 --- a/ast.h +++ b/ast.h @@ -149,7 +149,7 @@ struct ast_expression : ast_node { ast_expression *next; /* arrays get a member-count */ size_t count; - std::vector params; + std::vector type_params; ast_flag_t flags; /* void foo(string...) gets varparam set as a restriction diff --git a/intrin.cpp b/intrin.cpp index e55cf0f..80fa2ea 100644 --- a/intrin.cpp +++ b/intrin.cpp @@ -55,7 +55,7 @@ ast_expression *intrin::isfinite_() { ast_block *block = ast_block_new(ctx()); /* float x; */ - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); /* = isnan(x); */ callisnan->params.push_back((ast_expression*)x); @@ -124,7 +124,7 @@ ast_expression *intrin::isinf_() { ) ); - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); func->blocks.push_back(body); reg(val, func); @@ -169,7 +169,7 @@ ast_expression *intrin::isnan_() { ) ); - val->expression.params.push_back(arg1); + val->expression.type_params.push_back(arg1); func->blocks.push_back(body); reg(val, func); @@ -189,7 +189,7 @@ ast_expression *intrin::isnormal_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "isnormal", TYPE_FLOAT); - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); callisfinite->params.push_back((ast_expression*)x); /* return */ @@ -216,7 +216,7 @@ ast_expression *intrin::signbit_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "signbit", TYPE_FLOAT); - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); /* return (x < 0); */ body->exprs.push_back( @@ -254,7 +254,7 @@ ast_expression *intrin::acosh_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "acosh", TYPE_FLOAT); - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); /* = sqrt((x * x) - 1); */ callsqrt->params.push_back( @@ -307,7 +307,7 @@ ast_expression *intrin::asinh_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "asinh", TYPE_FLOAT); - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); /* = sqrt((x * x) + 1); */ callsqrt->params.push_back( @@ -359,7 +359,7 @@ ast_expression *intrin::atanh_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "atanh", TYPE_FLOAT); - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); /* = log((1 + x) / (1 - x)); */ calllog->params.push_back( @@ -416,7 +416,7 @@ ast_expression *intrin::exp_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "exp", TYPE_FLOAT); - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); body->locals.push_back(sum); body->locals.push_back(acc); @@ -521,7 +521,7 @@ ast_expression *intrin::exp2_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "exp2", TYPE_FLOAT); - val->expression.params.push_back(arg1); + val->expression.type_params.push_back(arg1); callpow->params.push_back((ast_expression*)m_fold->m_imm_float[3]); callpow->params.push_back((ast_expression*)arg1); @@ -551,7 +551,7 @@ ast_expression *intrin::expm1_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "expm1", TYPE_FLOAT); - val->expression.params.push_back(x); + val->expression.type_params.push_back(x); /* = exp(x); */ callexp->params.push_back((ast_expression*)x); @@ -659,8 +659,8 @@ ast_expression *intrin::pow_() { body->locals.push_back(accumulate); body->locals.push_back(mid); - val->expression.params.push_back(base); - val->expression.params.push_back(exp); + val->expression.type_params.push_back(base); + val->expression.type_params.push_back(exp); /* * if (exp == 0.0) @@ -1036,8 +1036,8 @@ ast_expression *intrin::mod_() { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, "mod", TYPE_FLOAT); - val->expression.params.push_back(a); - val->expression.params.push_back(b); + val->expression.type_params.push_back(a); + val->expression.type_params.push_back(b); body->locals.push_back(div); body->locals.push_back(sign); @@ -1147,7 +1147,7 @@ ast_expression *intrin::fabs_() { ) ); - val->expression.params.push_back(arg1); + val->expression.type_params.push_back(arg1); func->blocks.push_back(body); reg(val, func); @@ -1406,8 +1406,8 @@ ast_expression *intrin::ln_() { ast_function *func = value(&val, "ln", TYPE_FLOAT); size_t i; - val->expression.params.push_back(power); - val->expression.params.push_back(base); + val->expression.type_params.push_back(power); + val->expression.type_params.push_back(base); block->locals.push_back(whole); block->locals.push_back(nth); @@ -1864,7 +1864,7 @@ ast_expression *intrin::log_variant(const char *name, float base) { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, name, TYPE_FLOAT); - val->expression.params.push_back(arg1); + val->expression.type_params.push_back(arg1); callln->params.push_back((ast_expression*)arg1); callln->params.push_back((ast_expression*)m_fold->constgen_float(base, false)); @@ -1908,8 +1908,8 @@ ast_expression *intrin::shift_variant(const char *name, size_t instr) { ast_block *body = ast_block_new(ctx()); ast_function *func = value(&val, name, TYPE_FLOAT); - val->expression.params.push_back(a); - val->expression.params.push_back(b); + val->expression.type_params.push_back(a); + val->expression.type_params.push_back(b); /* = pow(2, b) */ callpow->params.push_back((ast_expression*)m_fold->m_imm_float[3]); diff --git a/parser.cpp b/parser.cpp index 01067a1..ba08ec8 100644 --- a/parser.cpp +++ b/parser.cpp @@ -103,7 +103,7 @@ static ast_expression* parser_find_param(parser_t *parser, const char *name) if (!parser->function) return nullptr; fun = parser->function->function_type; - for (auto &it : fun->expression.params) { + for (auto &it : fun->expression.type_params) { if (!strcmp(it->name, name)) return (ast_expression*)it; } @@ -1316,22 +1316,22 @@ static bool parser_close_call(parser_t *parser, shunt *sy) ast_ctx(fun).line); } - if (fun->params.size() != paramcount && + if (fun->type_params.size() != paramcount && !((fun->flags & AST_FLAG_VARIADIC) && - fun->params.size() < paramcount)) + fun->type_params.size() < paramcount)) { - const char *fewmany = (fun->params.size() > paramcount) ? "few" : "many"; + const char *fewmany = (fun->type_params.size() > paramcount) ? "few" : "many"; if (fval) return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT, "too %s parameters for call to %s: expected %i, got %i\n" " -> `%s` has been declared here: %s:%i", - fewmany, fval->name, (int)fun->params.size(), (int)paramcount, + fewmany, fval->name, (int)fun->type_params.size(), (int)paramcount, fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); else return !parsewarning(parser, WARN_INVALID_PARAMETER_COUNT, "too %s parameters for function call: expected %i, got %i\n" " -> it has been declared here: %s:%i", - fewmany, (int)fun->params.size(), (int)paramcount, + fewmany, (int)fun->type_params.size(), (int)paramcount, ast_ctx(fun).file, (int)ast_ctx(fun).line); } } @@ -4032,7 +4032,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) parser_enterblock(parser); - for (auto &it : var->expression.params) { + for (auto &it : var->expression.type_params) { size_t e; ast_member *me[3]; @@ -4079,7 +4079,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) goto enderrfn; } func->varargs = varargs; - func->fixedparams = (ast_value*)parser->m_fold.constgen_float(var->expression.params.size(), false); + func->fixedparams = (ast_value*)parser->m_fold.constgen_float(var->expression.type_params.size(), false); } parser->function = func; @@ -4381,8 +4381,8 @@ static ast_value* parser_create_array_setter_proto(parser_t *parser, ast_value * goto cleanup; } (void)!ast_value_set_name(value, "value"); /* not important */ - fval->expression.params.push_back(index); - fval->expression.params.push_back(value); + fval->expression.type_params.push_back(index); + fval->expression.type_params.push_back(value); array->setter = fval; return fval; @@ -4398,8 +4398,8 @@ static bool parser_create_array_setter_impl(parser_t *parser, ast_value *array) { ast_expression *root = nullptr; root = array_setter_node(parser, array, - array->setter->expression.params[0], - array->setter->expression.params[1], + array->setter->expression.type_params[0], + array->setter->expression.type_params[1], 0, array->expression.count); if (!root) { parseerror(parser, "failed to build accessor search tree"); @@ -4446,9 +4446,9 @@ static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, goto cleanup; } (void)!ast_value_set_name(value, "value"); /* not important */ - fval->expression.params.push_back(entity); - fval->expression.params.push_back(index); - fval->expression.params.push_back(value); + fval->expression.type_params.push_back(entity); + fval->expression.type_params.push_back(index); + fval->expression.type_params.push_back(value); root = array_field_setter_node(parser, array, entity, index, value, 0, array->expression.count); if (!root) { @@ -4493,7 +4493,7 @@ static ast_value* parser_create_array_getter_proto(parser_t *parser, ast_value * parseerror(parser, "failed to create locals for array accessor"); goto cleanup; } - fval->expression.params.push_back(index); + fval->expression.type_params.push_back(index); array->getter = fval; return fval; @@ -4508,7 +4508,7 @@ static bool parser_create_array_getter_impl(parser_t *parser, ast_value *array) { ast_expression *root = nullptr; - root = array_getter_node(parser, array, array->getter->expression.params[0], 0, array->expression.count); + root = array_getter_node(parser, array, array->getter->expression.type_params[0], 0, array->expression.count); if (!root) { parseerror(parser, "failed to build accessor search tree"); return false; @@ -4631,7 +4631,7 @@ static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) fval->expression.flags |= AST_FLAG_VARIADIC; var = fval; - var->expression.params = params; + var->expression.type_params = params; var->expression.varparam = (ast_expression*)varparam; var->argcounter = argcounter; @@ -5234,8 +5234,8 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield goto cleanup; } /* we need the new parameter-names */ - for (i = 0; i < proto->expression.params.size(); ++i) - ast_value_set_name(proto->expression.params[i], var->expression.params[i]->name); + for (i = 0; i < proto->expression.type_params.size(); ++i) + ast_value_set_name(proto->expression.type_params[i], var->expression.type_params[i]->name); if (!parser_check_qualifiers(parser, var, proto)) { retval = false; if (proto->desc) @@ -6153,7 +6153,7 @@ static bool parser_set_coverage_func(parser_t *parser, ir_builder *ir) { cov = func->function_type; expr = (ast_expression*)cov; - if (expr->vtype != TYPE_FUNCTION || expr->params.size()) { + if (expr->vtype != TYPE_FUNCTION || expr->type_params.size()) { char ty[1024]; ast_type_to_string(expr, ty, sizeof(ty)); con_out("invalid type for coverage(): %s\n", ty); @@ -6226,8 +6226,8 @@ bool parser_finish(parser_t *parser, const char *output) */ for (auto &f : parser->functions) { if (f->varargs) { - if (parser->max_param_count > f->function_type->expression.params.size()) { - f->varargs->expression.count = parser->max_param_count - f->function_type->expression.params.size(); + if (parser->max_param_count > f->function_type->expression.type_params.size()) { + f->varargs->expression.count = parser->max_param_count - f->function_type->expression.type_params.size(); if (!parser_create_array_setter_impl(parser, f->varargs)) { con_out("failed to generate vararg setter for %s\n", f->name); ir_builder_delete(ir); -- 2.39.2