X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ast.c;h=584bda0714a5f923524ff828c66eaa6919ac9c84;hp=50396538a32cba1d1a0e4f699bfd3c80d20a9afc;hb=063c50fce450693f0098cbc4a28efd109cbed01b;hpb=db6ca6c5f8abb2272c9f72bd820fd650bed0783a diff --git a/ast.c b/ast.c index 5039653..584bda0 100644 --- a/ast.c +++ b/ast.c @@ -21,7 +21,6 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -#include #include #include @@ -43,6 +42,8 @@ static bool ast_member_codegen(ast_member*, ast_function*, bool lvalue, ir_value**); static void ast_array_index_delete(ast_array_index*); static bool ast_array_index_codegen(ast_array_index*, ast_function*, bool lvalue, ir_value**); +static void ast_argpipe_delete(ast_argpipe*); +static bool ast_argpipe_codegen(ast_argpipe*, ast_function*, bool lvalue, ir_value**); static void ast_store_delete(ast_store*); static bool ast_store_codegen(ast_store*, ast_function*, bool lvalue, ir_value**); static void ast_ifthen_delete(ast_ifthen*); @@ -695,6 +696,23 @@ void ast_array_index_delete(ast_array_index *self) mem_d(self); } +ast_argpipe* ast_argpipe_new(lex_ctx ctx, ast_expression *index) +{ + ast_instantiate(ast_argpipe, ctx, ast_argpipe_delete); + ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_argpipe_codegen); + self->index = index; + self->expression.vtype = TYPE_NOEXPR; + return self; +} + +void ast_argpipe_delete(ast_argpipe *self) +{ + if (self->index) + ast_unref(self->index); + ast_expression_delete((ast_expression*)self); + mem_d(self); +} + ast_ifthen* ast_ifthen_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { ast_instantiate(ast_ifthen, ctx, ast_ifthen_delete); @@ -951,7 +969,50 @@ void ast_call_delete(ast_call *self) mem_d(self); } -bool ast_call_check_types(ast_call *self) +static bool ast_call_check_vararg(ast_call *self, ast_expression *va_type, ast_expression *exp_type) +{ + char texp[1024]; + char tgot[1024]; + if (!exp_type) + return true; + if (!va_type || !ast_compare_type(va_type, exp_type)) + { + if (va_type && exp_type) + { + ast_type_to_string(va_type, tgot, sizeof(tgot)); + ast_type_to_string(exp_type, texp, sizeof(texp)); + if (OPTS_FLAG(UNSAFE_VARARGS)) { + if (compile_warning(ast_ctx(self), WARN_UNSAFE_TYPES, + "piped variadic argument differs in type: constrained to type %s, expected type %s", + tgot, texp)) + return false; + } else { + compile_error(ast_ctx(self), + "piped variadic argument differs in type: constrained to type %s, expected type %s", + tgot, texp); + return false; + } + } + else + { + ast_type_to_string(exp_type, texp, sizeof(texp)); + if (OPTS_FLAG(UNSAFE_VARARGS)) { + if (compile_warning(ast_ctx(self), WARN_UNSAFE_TYPES, + "piped variadic argument may differ in type: expected type %s", + texp)) + return false; + } else { + compile_error(ast_ctx(self), + "piped variadic argument may differ in type: expected type %s", + texp); + return false; + } + } + } + return true; +} + +bool ast_call_check_types(ast_call *self, ast_expression *va_type) { char texp[1024]; char tgot[1024]; @@ -963,7 +1024,16 @@ bool ast_call_check_types(ast_call *self) count = vec_size(func->params); for (i = 0; i < count; ++i) { - if (!ast_compare_type(self->params[i], (ast_expression*)(func->params[i]))) + if (ast_istype(self->params[i], ast_argpipe)) { + /* warn about type safety instead */ + if (i+1 != count) { + 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])) + retval = false; + } + else if (!ast_compare_type(self->params[i], (ast_expression*)(func->params[i]))) { ast_type_to_string(self->params[i], tgot, sizeof(tgot)); ast_type_to_string((ast_expression*)func->params[i], texp, sizeof(texp)); @@ -976,11 +1046,20 @@ bool ast_call_check_types(ast_call *self) count = vec_size(self->params); if (count > vec_size(func->params) && func->varparam) { for (; i < count; ++i) { - if (!ast_compare_type(self->params[i], func->varparam)) + if (ast_istype(self->params[i], ast_argpipe)) { + /* warn about type safety instead */ + if (i+1 != count) { + 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, func->varparam)) + retval = false; + } + else if (!ast_compare_type(self->params[i], func->varparam)) { ast_type_to_string(self->params[i], tgot, sizeof(tgot)); ast_type_to_string(func->varparam, texp, sizeof(texp)); - compile_error(ast_ctx(self), "invalid type for parameter %u in function call: expected %s, got %s", + compile_error(ast_ctx(self), "invalid type for variadic parameter %u in function call: expected %s, got %s", (unsigned int)(i+1), texp, tgot); /* we don't immediately return */ retval = false; @@ -1073,16 +1152,15 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) { ast_instantiate(ast_function, ctx, ast_function_delete); - if (!vtype || - vtype->hasvalue || - vtype->expression.vtype != TYPE_FUNCTION) - { + if (!vtype) { + compile_error(ast_ctx(self), "internal error: ast_function_new condition 0"); + goto cleanup; + } else if (vtype->hasvalue || vtype->expression.vtype != TYPE_FUNCTION) { compile_error(ast_ctx(self), "internal error: ast_function_new condition %i %i type=%i (probably 2 bodies?)", (int)!vtype, (int)vtype->hasvalue, vtype->expression.vtype); - mem_d(self); - return NULL; + goto cleanup; } self->vtype = vtype; @@ -1104,8 +1182,13 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) self->varargs = NULL; self->argc = NULL; self->fixedparams = NULL; + self->return_value = NULL; return self; + +cleanup: + mem_d(self); + return NULL; } void ast_function_delete(ast_function *self) @@ -1133,6 +1216,8 @@ void ast_function_delete(ast_function *self) ast_delete(self->argc); if (self->fixedparams) ast_unref(self->fixedparams); + if (self->return_value) + ast_unref(self->return_value); mem_d(self); } @@ -1205,6 +1290,63 @@ bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_valu return true; } +static bool ast_global_array_set(ast_value *self) +{ + size_t count = vec_size(self->initlist); + size_t i; + + if (count > self->expression.count) { + compile_error(ast_ctx(self), "too many elements in initializer"); + count = self->expression.count; + } + else if (count < self->expression.count) { + /* add this? + compile_warning(ast_ctx(self), "not all elements are initialized"); + */ + } + + for (i = 0; i != count; ++i) { + switch (self->expression.next->vtype) { + case TYPE_FLOAT: + if (!ir_value_set_float(self->ir_values[i], self->initlist[i].vfloat)) + return false; + break; + case TYPE_VECTOR: + if (!ir_value_set_vector(self->ir_values[i], self->initlist[i].vvec)) + return false; + break; + case TYPE_STRING: + if (!ir_value_set_string(self->ir_values[i], self->initlist[i].vstring)) + return false; + break; + case TYPE_ARRAY: + /* we don't support them in any other place yet either */ + compile_error(ast_ctx(self), "TODO: nested arrays"); + return false; + case TYPE_FUNCTION: + /* this requiers a bit more work - similar to the fields I suppose */ + compile_error(ast_ctx(self), "global of type function not properly generated"); + return false; + case TYPE_FIELD: + if (!self->initlist[i].vfield) { + compile_error(ast_ctx(self), "field constant without vfield set"); + return false; + } + if (!self->initlist[i].vfield->ir_v) { + compile_error(ast_ctx(self), "field constant generated before its field"); + return false; + } + if (!ir_value_set_field(self->ir_values[i], self->initlist[i].vfield->ir_v)) + return false; + break; + default: + compile_error(ast_ctx(self), "TODO: global constant type %i", self->expression.vtype); + break; + } + } + return true; +} + bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) { ir_value *v = NULL; @@ -1314,6 +1456,11 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) ast_expression *elemtype = self->expression.next; int vtype = elemtype->vtype; + if (self->expression.flags & AST_FLAG_ARRAY_INIT && !self->expression.count) { + compile_error(ast_ctx(self), "array `%s' has no size", self->name); + return false; + } + /* same as with field arrays */ if (!self->expression.count || self->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE)) compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count); @@ -1365,6 +1512,13 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) v->context = ast_ctx(self); } + /* link us to the ir_value */ + v->cvq = self->cvq; + self->ir_v = v; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; + + /* initialize */ if (self->hasvalue) { switch (self->expression.vtype) { @@ -1381,7 +1535,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) goto error; break; case TYPE_ARRAY: - compile_error(ast_ctx(self), "TODO: global constant array"); + ast_global_array_set(self); break; case TYPE_FUNCTION: compile_error(ast_ctx(self), "global of type function not properly generated"); @@ -1406,16 +1560,10 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) break; } } - - /* link us to the ir_value */ - v->cvq = self->cvq; - self->ir_v = v; - if (self->expression.flags & AST_FLAG_INCLUDE_DEF) - self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; return true; error: /* clean up */ - ir_value_delete(v); + if(v) ir_value_delete(v); return false; } @@ -1625,6 +1773,12 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) return true; } + /* have a local return value variable? */ + if (self->return_value) { + if (!ast_local_codegen(self->return_value, self->ir_func, false)) + return false; + } + if (!vec_size(self->blocks)) { compile_error(ast_ctx(self), "function `%s` has no body", self->name); return false; @@ -1676,8 +1830,13 @@ bool ast_function_codegen(ast_function *self, ir_builder *ir) } else if (vec_size(self->curblock->entries) || self->curblock == irf->first) { - /* error("missing return"); */ - if (compile_warning(ast_ctx(self), WARN_MISSING_RETURN_VALUES, + if (self->return_value) { + cgen = self->return_value->expression.codegen; + if (!(*cgen)((ast_expression*)(self->return_value), self, false, &dummy)) + return false; + return ir_block_create_return(self->curblock, ast_ctx(self), dummy); + } + else if (compile_warning(ast_ctx(self), WARN_MISSING_RETURN_VALUES, "control reaches end of non-void function (`%s`) via %s", self->name, self->curblock->label)) { @@ -2328,6 +2487,19 @@ bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lva return true; } +bool ast_argpipe_codegen(ast_argpipe *self, ast_function *func, bool lvalue, ir_value **out) +{ + *out = NULL; + if (lvalue) { + compile_error(ast_ctx(self), "argpipe node: not an lvalue"); + return false; + } + (void)func; + (void)out; + compile_error(ast_ctx(self), "TODO: argpipe codegen not implemented"); + return false; +} + bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_value **out) { ast_expression_codegen *cgen; @@ -2721,10 +2893,13 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value if (bprecond) { ir_block *ontrue, *onfalse; - if (bbody) ontrue = bbody; + ontrue = bbody; /* can never be null */ + + /* all of this is dead code else if (bincrement) ontrue = bincrement; - else if (bpostcond) ontrue = bpostcond; - else ontrue = bprecond; + else ontrue = bpostcond; + */ + onfalse = bout; if (self->pre_not) { tmpblock = ontrue; @@ -2762,9 +2937,13 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value { ir_block *ontrue, *onfalse; if (bprecond) ontrue = bprecond; - else if (bbody) ontrue = bbody; + else ontrue = bbody; /* can never be null */ + + /* all of this is dead code else if (bincrement) ontrue = bincrement; else ontrue = bpostcond; + */ + onfalse = bout; if (self->post_not) { tmpblock = ontrue;