X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ast.c;h=bcc2f8ef3f4bc4fb3887facfa047a6c6c6fef712;hp=81e1c121231e16bbb9bdde2c92cf72ec642fda1b;hb=a68f0fcb355db42acabe72da5939fbd1b04f6016;hpb=b0a07695344c805381fdca64aac229ee98725130 diff --git a/ast.c b/ast.c index 81e1c12..bcc2f8e 100644 --- a/ast.c +++ b/ast.c @@ -21,12 +21,12 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -#include #include #include #include "gmqcc.h" #include "ast.h" +#include "parser.h" #define ast_instantiate(T, ctx, destroyfn) \ T* self = (T*)mem_a(sizeof(T)); \ @@ -43,6 +43,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*); @@ -83,7 +85,7 @@ static GMQCC_NORETURN void _ast_node_destroy(ast_node *self) } /* Initialize main ast node aprts */ -static void ast_node_init(ast_node *self, lex_ctx ctx, int nodetype) +static void ast_node_init(ast_node *self, lex_ctx_t ctx, int nodetype) { self->context = ctx; self->destroy = &_ast_node_destroy; @@ -173,7 +175,7 @@ void ast_type_adopt_impl(ast_expression *self, const ast_expression *other) } } -static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) +static ast_expression* ast_shallow_type(lex_ctx_t ctx, int vtype) { ast_instantiate(ast_expression, ctx, ast_expression_delete_full); ast_expression_init(self, NULL); @@ -183,7 +185,7 @@ static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) return self; } -ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) +ast_expression* ast_type_copy(lex_ctx_t ctx, const ast_expression *ex) { size_t i; const ast_expression *fromex; @@ -341,7 +343,7 @@ void ast_type_to_string(ast_expression *e, char *buf, size_t bufsize) } static bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_value **out); -ast_value* ast_value_new(lex_ctx ctx, const char *name, int t) +ast_value* ast_value_new(lex_ctx_t ctx, const char *name, int t) { ast_instantiate(ast_value, ctx, ast_value_delete); ast_expression_init((ast_expression*)self, @@ -432,7 +434,7 @@ bool ast_value_set_name(ast_value *self, const char *name) return !!self->name; } -ast_binary* ast_binary_new(lex_ctx ctx, int op, +ast_binary* ast_binary_new(lex_ctx_t ctx, int op, ast_expression* left, ast_expression* right) { ast_instantiate(ast_binary, ctx, ast_binary_delete); @@ -477,7 +479,7 @@ void ast_binary_delete(ast_binary *self) mem_d(self); } -ast_binstore* ast_binstore_new(lex_ctx ctx, int storop, int op, +ast_binstore* ast_binstore_new(lex_ctx_t ctx, int storop, int op, ast_expression* left, ast_expression* right) { ast_instantiate(ast_binstore, ctx, ast_binstore_delete); @@ -505,7 +507,7 @@ void ast_binstore_delete(ast_binstore *self) mem_d(self); } -ast_unary* ast_unary_new(lex_ctx ctx, int op, +ast_unary* ast_unary_new(lex_ctx_t ctx, int op, ast_expression *expr) { ast_instantiate(ast_unary, ctx, ast_unary_delete); @@ -519,7 +521,7 @@ ast_unary* ast_unary_new(lex_ctx ctx, int op, if (op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) { self->expression.vtype = TYPE_FLOAT; } else - compile_error(ctx, "cannot determine type of unary operation %s", asm_instr[op].m); + compile_error(ctx, "cannot determine type of unary operation %s", util_instr_str[op]); return self; } @@ -531,7 +533,7 @@ void ast_unary_delete(ast_unary *self) mem_d(self); } -ast_return* ast_return_new(lex_ctx ctx, ast_expression *expr) +ast_return* ast_return_new(lex_ctx_t ctx, ast_expression *expr) { ast_instantiate(ast_return, ctx, ast_return_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_return_codegen); @@ -552,7 +554,7 @@ void ast_return_delete(ast_return *self) mem_d(self); } -ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expression *field) +ast_entfield* ast_entfield_new(lex_ctx_t ctx, ast_expression *entity, ast_expression *field) { if (field->vtype != TYPE_FIELD) { compile_error(ctx, "ast_entfield_new with expression not of type field"); @@ -561,7 +563,7 @@ ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expressi return ast_entfield_new_force(ctx, entity, field, field->next); } -ast_entfield* ast_entfield_new_force(lex_ctx ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype) +ast_entfield* ast_entfield_new_force(lex_ctx_t ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype) { ast_instantiate(ast_entfield, ctx, ast_entfield_delete); @@ -590,7 +592,7 @@ void ast_entfield_delete(ast_entfield *self) mem_d(self); } -ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int field, const char *name) +ast_member* ast_member_new(lex_ctx_t ctx, ast_expression *owner, unsigned int field, const char *name) { ast_instantiate(ast_member, ctx, ast_member_delete); if (field >= 3) { @@ -652,7 +654,7 @@ bool ast_member_set_name(ast_member *self, const char *name) return !!self->name; } -ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index) +ast_array_index* ast_array_index_new(lex_ctx_t ctx, ast_expression *array, ast_expression *index) { ast_expression *outtype; ast_instantiate(ast_array_index, ctx, ast_array_index_delete); @@ -695,7 +697,24 @@ void ast_array_index_delete(ast_array_index *self) mem_d(self); } -ast_ifthen* ast_ifthen_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) +ast_argpipe* ast_argpipe_new(lex_ctx_t 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_t ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { ast_instantiate(ast_ifthen, ctx, ast_ifthen_delete); if (!ontrue && !onfalse) { @@ -728,7 +747,7 @@ void ast_ifthen_delete(ast_ifthen *self) mem_d(self); } -ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) +ast_ternary* ast_ternary_new(lex_ctx_t ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { ast_expression *exprtype = ontrue; ast_instantiate(ast_ternary, ctx, ast_ternary_delete); @@ -765,7 +784,7 @@ void ast_ternary_delete(ast_ternary *self) mem_d(self); } -ast_loop* ast_loop_new(lex_ctx ctx, +ast_loop* ast_loop_new(lex_ctx_t ctx, ast_expression *initexpr, ast_expression *precond, bool pre_not, ast_expression *postcond, bool post_not, @@ -814,7 +833,7 @@ void ast_loop_delete(ast_loop *self) mem_d(self); } -ast_breakcont* ast_breakcont_new(lex_ctx ctx, bool iscont, unsigned int levels) +ast_breakcont* ast_breakcont_new(lex_ctx_t ctx, bool iscont, unsigned int levels) { ast_instantiate(ast_breakcont, ctx, ast_breakcont_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_breakcont_codegen); @@ -831,7 +850,7 @@ void ast_breakcont_delete(ast_breakcont *self) mem_d(self); } -ast_switch* ast_switch_new(lex_ctx ctx, ast_expression *op) +ast_switch* ast_switch_new(lex_ctx_t ctx, ast_expression *op) { ast_instantiate(ast_switch, ctx, ast_switch_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_switch_codegen); @@ -860,7 +879,7 @@ void ast_switch_delete(ast_switch *self) mem_d(self); } -ast_label* ast_label_new(lex_ctx ctx, const char *name, bool undefined) +ast_label* ast_label_new(lex_ctx_t ctx, const char *name, bool undefined) { ast_instantiate(ast_label, ctx, ast_label_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_label_codegen); @@ -888,7 +907,7 @@ static void ast_label_register_goto(ast_label *self, ast_goto *g) vec_push(self->gotos, g); } -ast_goto* ast_goto_new(lex_ctx ctx, const char *name) +ast_goto* ast_goto_new(lex_ctx_t ctx, const char *name) { ast_instantiate(ast_goto, ctx, ast_goto_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_goto_codegen); @@ -912,7 +931,7 @@ void ast_goto_set_label(ast_goto *self, ast_label *label) self->target = label; } -ast_call* ast_call_new(lex_ctx ctx, +ast_call* ast_call_new(lex_ctx_t ctx, ast_expression *funcexpr) { ast_instantiate(ast_call, ctx, ast_call_delete); @@ -951,7 +970,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 +1025,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 +1047,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; @@ -990,7 +1070,7 @@ bool ast_call_check_types(ast_call *self) return retval; } -ast_store* ast_store_new(lex_ctx ctx, int op, +ast_store* ast_store_new(lex_ctx_t ctx, int op, ast_expression *dest, ast_expression *source) { ast_instantiate(ast_store, ctx, ast_store_delete); @@ -1015,7 +1095,7 @@ void ast_store_delete(ast_store *self) mem_d(self); } -ast_block* ast_block_new(lex_ctx ctx) +ast_block* ast_block_new(lex_ctx_t ctx) { ast_instantiate(ast_block, ctx, ast_block_delete); ast_expression_init((ast_expression*)self, @@ -1069,20 +1149,19 @@ void ast_block_set_type(ast_block *self, ast_expression *from) ast_type_adopt(self, from); } -ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) +ast_function* ast_function_new(lex_ctx_t 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; @@ -1107,6 +1186,10 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) self->return_value = NULL; return self; + +cleanup: + mem_d(self); + return NULL; } void ast_function_delete(ast_function *self) @@ -1139,7 +1222,7 @@ void ast_function_delete(ast_function *self) mem_d(self); } -static const char* ast_function_label(ast_function *self, const char *prefix) +const char* ast_function_label(ast_function *self, const char *prefix) { size_t id; size_t len; @@ -1208,6 +1291,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; @@ -1317,6 +1457,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); @@ -1368,6 +1513,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) { @@ -1384,7 +1536,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"); @@ -1409,16 +1561,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; } @@ -2342,6 +2488,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; @@ -2355,6 +2514,7 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va ir_block *ontrue_endblock = NULL; ir_block *onfalse_endblock = NULL; ir_block *merge = NULL; + int fold = 0; /* We don't output any value, thus also don't care about r/lvalue */ (void)out; @@ -2373,8 +2533,10 @@ bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_va /* update the block which will get the jump - because short-logic or ternaries may have changed this */ cond = func->curblock; - /* on-true path */ - + /* try constant folding away the if */ + if ((fold = fold_cond(condval, func, self)) != -1) + return fold; + if (self->on_true) { /* create on-true block */ ontrue = ir_function_create_block(ast_ctx(self), func->ir_func, ast_function_label(func, "ontrue")); @@ -2725,9 +2887,13 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value /* Now all blocks are in place */ /* From 'bin' we jump to whatever comes first */ if (bprecond) tmpblock = bprecond; - else if (bbody) tmpblock = bbody; + else tmpblock = bbody; /* can never be null */ + + /* DEAD CODE else if (bpostcond) tmpblock = bpostcond; else tmpblock = bout; + */ + if (!ir_block_create_jump(bin, ast_ctx(self), tmpblock)) return false; @@ -2735,10 +2901,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; @@ -2776,9 +2945,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;