X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ast.c;h=995ba094efa04432e655135b489e7e61fb3b7148;hp=3894cdefaad6e8fe4fb5ff6a38154e320fee2784;hb=52312791130eff70f21c428b23756a1b49e67804;hpb=7998a98818d38858405698a9c7029d3bea8e4e7b diff --git a/ast.c b/ast.c index 3894cde..995ba09 100644 --- a/ast.c +++ b/ast.c @@ -1,6 +1,7 @@ /* - * Copyright (C) 2012 + * Copyright (C) 2012, 2013 * Wolfgang Bumiller + * Dale Weiler * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in @@ -203,14 +204,20 @@ ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) bool ast_compare_type(ast_expression *a, ast_expression *b) { + if (a->expression.vtype == TYPE_NIL || + b->expression.vtype == TYPE_NIL) + return true; if (a->expression.vtype != b->expression.vtype) return false; if (!a->expression.next != !b->expression.next) return false; if (vec_size(a->expression.params) != vec_size(b->expression.params)) return false; - if (a->expression.flags != b->expression.flags) + if ((a->expression.flags & AST_FLAG_TYPE_MASK) != + (b->expression.flags & AST_FLAG_TYPE_MASK) ) + { return false; + } if (vec_size(a->expression.params)) { size_t i; for (i = 0; i < vec_size(a->expression.params); ++i) { @@ -338,6 +345,7 @@ ast_value* ast_value_new(lex_ctx ctx, const char *name, int t) self->setter = NULL; self->getter = NULL; + self->desc = NULL; return self; } @@ -365,6 +373,10 @@ void ast_value_delete(ast_value* self) } if (self->ir_values) mem_d(self->ir_values); + + if (self->desc) + mem_d(self->desc); + ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -570,7 +582,8 @@ ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int fiel self->expression.next = ast_shallow_type(ctx, TYPE_FLOAT); } - self->owner = owner; + self->rvalue = false; + self->owner = owner; ast_propagate_effects(self, owner); self->field = field; @@ -596,6 +609,14 @@ void ast_member_delete(ast_member *self) mem_d(self); } +bool ast_member_set_name(ast_member *self, const char *name) +{ + if (self->name) + mem_d((void*)self->name); + self->name = util_strdup(name); + return !!self->name; +} + ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index) { ast_expression *outtype; @@ -675,6 +696,7 @@ void ast_ifthen_delete(ast_ifthen *self) ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { + ast_expression *exprtype = ontrue; ast_instantiate(ast_ternary, ctx, ast_ternary_delete); /* This time NEITHER must be NULL */ if (!ontrue || !onfalse) { @@ -690,7 +712,9 @@ ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression * ast_propagate_effects(self, ontrue); ast_propagate_effects(self, onfalse); - if (!ast_type_adopt(self, ontrue)) { + if (ontrue->expression.vtype == TYPE_NIL) + exprtype = onfalse; + if (!ast_type_adopt(self, exprtype)) { ast_ternary_delete(self); return NULL; } @@ -700,9 +724,12 @@ ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression * void ast_ternary_delete(ast_ternary *self) { - ast_unref(self->cond); - ast_unref(self->on_true); - ast_unref(self->on_false); + /* the if()s are only there because computed-gotos can set them + * to NULL + */ + if (self->cond) ast_unref(self->cond); + if (self->on_true) ast_unref(self->on_true); + if (self->on_false) ast_unref(self->on_false); ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -756,12 +783,13 @@ void ast_loop_delete(ast_loop *self) mem_d(self); } -ast_breakcont* ast_breakcont_new(lex_ctx ctx, bool iscont) +ast_breakcont* ast_breakcont_new(lex_ctx 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); self->is_continue = iscont; + self->levels = levels; return self; } @@ -801,14 +829,17 @@ void ast_switch_delete(ast_switch *self) mem_d(self); } -ast_label* ast_label_new(lex_ctx ctx, const char *name) +ast_label* ast_label_new(lex_ctx 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); - self->name = util_strdup(name); - self->irblock = NULL; - self->gotos = NULL; + self->expression.vtype = TYPE_NOEXPR; + + self->name = util_strdup(name); + self->irblock = NULL; + self->gotos = NULL; + self->undefined = undefined; return self; } @@ -890,7 +921,8 @@ bool ast_call_check_types(ast_call *self) count = vec_size(func->expression.params); for (i = 0; i < count; ++i) { - if (!ast_compare_type(self->params[i], (ast_expression*)(func->expression.params[i]))) { + if (!ast_compare_type(self->params[i], (ast_expression*)(func->expression.params[i]))) + { char texp[1024]; char tgot[1024]; ast_type_to_string(self->params[i], tgot, sizeof(tgot)); @@ -1017,8 +1049,8 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) self->ir_func = NULL; self->curblock = NULL; - self->breakblock = NULL; - self->continueblock = NULL; + self->breakblocks = NULL; + self->continueblocks = NULL; vtype->hasvalue = true; vtype->constval.vfunc = self; @@ -1043,6 +1075,8 @@ void ast_function_delete(ast_function *self) for (i = 0; i < vec_size(self->blocks); ++i) ast_delete(self->blocks[i]); vec_free(self->blocks); + vec_free(self->breakblocks); + vec_free(self->continueblocks); mem_d(self); } @@ -1090,6 +1124,10 @@ bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_valu { (void)func; (void)lvalue; + if (self->expression.vtype == TYPE_NIL) { + *out = func->ir_func->owner->nil; + return true; + } /* NOTE: This is the codegen for a variable used in an expression. * It is not the codegen to generate the value. For this purpose, * ast_local_codegen and ast_global_codegen are to be used before this @@ -1111,6 +1149,11 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) { ir_value *v = NULL; + if (self->expression.vtype == TYPE_NIL) { + compile_error(ast_ctx(self), "internal error: trying to generate a variable of TYPE_NIL"); + return false; + } + if (self->hasvalue && self->expression.vtype == TYPE_FUNCTION) { ir_function *func = ir_builder_create_function(ir, self->name, self->expression.next->expression.vtype); @@ -1121,6 +1164,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) self->constval.vfunc->ir_func = func; self->ir_v = func->value; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; /* The function is filled later on ast_function_codegen... */ return true; } @@ -1161,7 +1206,10 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) } v->context = ast_ctx(self); v->unique_life = true; + v->locked = true; array->ir_v = self->ir_v = v; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); @@ -1179,6 +1227,9 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) } array->ir_values[ai]->context = ast_ctx(self); array->ir_values[ai]->unique_life = true; + array->ir_values[ai]->locked = true; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_values[ai]->flags |= IR_FLAG_INCLUDE_DEF; } mem_d(name); } @@ -1189,6 +1240,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) return false; v->context = ast_ctx(self); self->ir_v = v; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_v->flags |= IR_FLAG_INCLUDE_DEF; } return true; } @@ -1212,6 +1265,9 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) } v->context = ast_ctx(self); v->unique_life = true; + v->locked = true; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + v->flags |= IR_FLAG_INCLUDE_DEF; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); @@ -1229,6 +1285,9 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) } self->ir_values[ai]->context = ast_ctx(self); self->ir_values[ai]->unique_life = true; + self->ir_values[ai]->locked = true; + if (self->expression.flags & AST_FLAG_INCLUDE_DEF) + self->ir_values[ai]->flags |= IR_FLAG_INCLUDE_DEF; } mem_d(name); } @@ -1291,6 +1350,8 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) /* 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 */ @@ -1301,6 +1362,12 @@ error: /* clean up */ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) { ir_value *v = NULL; + + if (self->expression.vtype == TYPE_NIL) { + compile_error(ast_ctx(self), "internal error: trying to generate a variable of TYPE_NIL"); + return false; + } + if (self->hasvalue && self->expression.vtype == TYPE_FUNCTION) { /* Do we allow local functions? I think not... @@ -1342,6 +1409,7 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) } v->context = ast_ctx(self); v->unique_life = true; + v->locked = true; namelen = strlen(self->name); name = (char*)mem_a(namelen + 16); @@ -1357,6 +1425,7 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) } self->ir_values[ai]->context = ast_ctx(self); self->ir_values[ai]->unique_life = true; + self->ir_values[ai]->locked = true; } } else @@ -1797,6 +1866,7 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va } self->expression.outr = *out; + codegen_output_type(self, *out); return true; } @@ -1813,6 +1883,7 @@ bool ast_binary_codegen(ast_binary *self, ast_function *func, bool lvalue, ir_va if (!*out) return false; self->expression.outr = *out; + codegen_output_type(self, *out); return true; } @@ -2050,14 +2121,17 @@ bool ast_member_codegen(ast_member *self, ast_function *func, bool lvalue, ir_va ir_value *vec; /* in QC this is always an lvalue */ - (void)lvalue; + if (lvalue && self->rvalue) { + compile_error(ast_ctx(self), "not an l-value (member access)"); + return false; + } if (self->expression.outl) { *out = self->expression.outl; return true; } cgen = self->owner->expression.codegen; - if (!(*cgen)((ast_expression*)(self->owner), func, true, &vec)) + if (!(*cgen)((ast_expression*)(self->owner), func, false, &vec)) return false; if (vec->vtype != TYPE_VECTOR && @@ -2347,15 +2421,18 @@ bool ast_ternary_codegen(ast_ternary *self, ast_function *func, bool lvalue, ir_ /* Here, now, we need a PHI node * but first some sanity checking... */ - if (trueval->vtype != falseval->vtype) { + if (trueval->vtype != falseval->vtype && trueval->vtype != TYPE_NIL && falseval->vtype != TYPE_NIL) { /* error("ternary with different types on the two sides"); */ + compile_error(ast_ctx(self), "internal error: ternary operand types invalid"); return false; } /* create PHI */ - phi = ir_block_create_phi(merge, ast_ctx(self), ast_function_label(func, "phi"), trueval->vtype); - if (!phi) + phi = ir_block_create_phi(merge, ast_ctx(self), ast_function_label(func, "phi"), self->expression.vtype); + if (!phi) { + compile_error(ast_ctx(self), "internal error: failed to generate phi node"); return false; + } ir_phi_add(phi, ontrue_out, trueval); ir_phi_add(phi, onfalse_out, falseval); @@ -2392,9 +2469,6 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value ir_block *bcontinue = NULL; ir_block *bbreak = NULL; - ir_block *old_bcontinue = NULL; - ir_block *old_bbreak = NULL; - ir_block *tmpblock = NULL; (void)lvalue; @@ -2487,12 +2561,11 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value /* enter */ func->curblock = bbody; - old_bbreak = func->breakblock; - old_bcontinue = func->continueblock; - func->breakblock = bbreak; - func->continueblock = bcontinue; - if (!func->continueblock) - func->continueblock = bbody; + vec_push(func->breakblocks, bbreak); + if (bcontinue) + vec_push(func->continueblocks, bcontinue); + else + vec_push(func->continueblocks, bbody); /* generate */ if (self->body) { @@ -2502,8 +2575,8 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value } end_bbody = func->curblock; - func->breakblock = old_bbreak; - func->continueblock = old_bcontinue; + vec_pop(func->breakblocks); + vec_pop(func->continueblocks); } /* post-loop-condition */ @@ -2629,9 +2702,9 @@ bool ast_breakcont_codegen(ast_breakcont *self, ast_function *func, bool lvalue, self->expression.outr = (ir_value*)1; if (self->is_continue) - target = func->continueblock; + target = func->continueblocks[vec_size(func->continueblocks)-1-self->levels]; else - target = func->breakblock; + target = func->breakblocks[vec_size(func->breakblocks)-1-self->levels]; if (!target) { compile_error(ast_ctx(self), "%s is lacking a target block", (self->is_continue ? "continue" : "break")); @@ -2654,7 +2727,6 @@ bool ast_switch_codegen(ast_switch *self, ast_function *func, bool lvalue, ir_va ir_value *dummy = NULL; ir_value *irop = NULL; - ir_block *old_break = NULL; ir_block *bout = NULL; ir_block *bfall = NULL; size_t bout_id; @@ -2697,8 +2769,7 @@ bool ast_switch_codegen(ast_switch *self, ast_function *func, bool lvalue, ir_va return false; /* setup the break block */ - old_break = func->breakblock; - func->breakblock = bout; + vec_push(func->breakblocks, bout); /* Now create all cases */ for (c = 0; c < vec_size(self->cases); ++c) { @@ -2803,7 +2874,7 @@ bool ast_switch_codegen(ast_switch *self, ast_function *func, bool lvalue, ir_va func->curblock = bout; /* restore the break block */ - func->breakblock = old_break; + vec_pop(func->breakblocks); /* Move 'bout' to the end, it's nicer */ vec_remove(func->ir_func->blocks, bout_id, 1); @@ -2817,6 +2888,11 @@ bool ast_label_codegen(ast_label *self, ast_function *func, bool lvalue, ir_valu size_t i; ir_value *dummy; + if (self->undefined) { + compile_error(ast_ctx(self), "internal error: ast_label never defined"); + return false; + } + *out = NULL; if (lvalue) { compile_error(ast_ctx(self), "internal error: ast_label cannot be an lvalue");