/*
- * Copyright (C) 2012, 2013
+ * Copyright (C) 2012, 2013, 2014, 2015
* Wolfgang Bumiller
* Dale Weiler
*
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "gmqcc.h"
#include "ast.h"
+#include "parser.h"
#define ast_instantiate(T, ctx, destroyfn) \
T* self = (T*)mem_a(sizeof(T)); \
ast_node_init((ast_node*)self, ctx, TYPE_##T); \
( (ast_node*)self )->destroy = (ast_node_delete*)destroyfn
+/*
+ * forward declarations, these need not be in ast.h for obvious
+ * static reasons.
+ */
+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*);
+static bool ast_ifthen_codegen(ast_ifthen*, ast_function*, bool lvalue, ir_value**);
+static void ast_ternary_delete(ast_ternary*);
+static bool ast_ternary_codegen(ast_ternary*, ast_function*, bool lvalue, ir_value**);
+static void ast_loop_delete(ast_loop*);
+static bool ast_loop_codegen(ast_loop*, ast_function*, bool lvalue, ir_value**);
+static void ast_breakcont_delete(ast_breakcont*);
+static bool ast_breakcont_codegen(ast_breakcont*, ast_function*, bool lvalue, ir_value**);
+static void ast_switch_delete(ast_switch*);
+static bool ast_switch_codegen(ast_switch*, ast_function*, bool lvalue, ir_value**);
+static void ast_label_delete(ast_label*);
+static void ast_label_register_goto(ast_label*, ast_goto*);
+static bool ast_label_codegen(ast_label*, ast_function*, bool lvalue, ir_value**);
+static bool ast_goto_codegen(ast_goto*, ast_function*, bool lvalue, ir_value**);
+static void ast_goto_delete(ast_goto*);
+static void ast_call_delete(ast_call*);
+static bool ast_call_codegen(ast_call*, ast_function*, bool lvalue, ir_value**);
+static bool ast_block_codegen(ast_block*, ast_function*, bool lvalue, ir_value**);
+static void ast_unary_delete(ast_unary*);
+static bool ast_unary_codegen(ast_unary*, ast_function*, bool lvalue, ir_value**);
+static void ast_entfield_delete(ast_entfield*);
+static bool ast_entfield_codegen(ast_entfield*, ast_function*, bool lvalue, ir_value**);
+static void ast_return_delete(ast_return*);
+static bool ast_return_codegen(ast_return*, ast_function*, bool lvalue, ir_value**);
+static void ast_binstore_delete(ast_binstore*);
+static bool ast_binstore_codegen(ast_binstore*, ast_function*, bool lvalue, ir_value**);
+static void ast_binary_delete(ast_binary*);
+static bool ast_binary_codegen(ast_binary*, ast_function*, bool lvalue, ir_value**);
+static bool ast_state_codegen(ast_state*, ast_function*, bool lvalue, ir_value**);
/* It must not be possible to get here. */
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;
self->outr = NULL;
self->params = NULL;
self->count = 0;
- self->flags = 0;
self->varparam = NULL;
+ self->flags = 0;
+ if (OPTS_OPTION_BOOL(OPTION_COVERAGE))
+ self->flags |= AST_FLAG_BLOCK_COVERAGE;
}
static void ast_expression_delete(ast_expression *self)
}
}
-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);
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;
buf[pos] = 0;
}
-ast_value* ast_value_new(lex_ctx ctx, const char *name, int t)
+static bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_value **out);
+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,
self->cvq = CV_NONE;
self->hasvalue = false;
self->isimm = false;
+ self->inexact = false;
self->uses = 0;
memset(&self->constval, 0, sizeof(self->constval));
self->initlist = NULL;
self->getter = NULL;
self->desc = NULL;
- self->argcounter = NULL;
+ self->argcounter = NULL;
+ self->intrinsic = false;
return self;
}
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);
ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_binary_codegen);
+ if (ast_istype(right, ast_unary) && OPTS_OPTIMIZATION(OPTIM_PEEPHOLE)) {
+ ast_unary *unary = ((ast_unary*)right);
+ ast_expression *normal = unary->operand;
+
+ /* make a-(-b) => a + b */
+ if (unary->op == VINSTR_NEG_F || unary->op == VINSTR_NEG_V) {
+ if (op == INSTR_SUB_F) {
+ op = INSTR_ADD_F;
+ right = normal;
+ ++opts_optimizationcount[OPTIM_PEEPHOLE];
+ } else if (op == INSTR_SUB_V) {
+ op = INSTR_ADD_V;
+ right = normal;
+ ++opts_optimizationcount[OPTIM_PEEPHOLE];
+ }
+ }
+ }
+
self->op = op;
self->left = left;
self->right = right;
+ self->right_first = false;
ast_propagate_effects(self, left);
ast_propagate_effects(self, right);
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);
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);
ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_unary_codegen);
- self->op = op;
+ self->op = op;
self->operand = expr;
+
+ if (ast_istype(expr, ast_unary) && OPTS_OPTIMIZATION(OPTIM_PEEPHOLE)) {
+ ast_unary *prev = (ast_unary*)((ast_unary*)expr)->operand;
+
+ /* Handle for double negation */
+ if (((ast_unary*)expr)->op == op)
+ prev = (ast_unary*)((ast_unary*)expr)->operand;
+
+ if (ast_istype(prev, ast_unary)) {
+ ast_expression_delete((ast_expression*)self);
+ mem_d(self);
+ ++opts_optimizationcount[OPTIM_PEEPHOLE];
+ return prev;
+ }
+ }
+
ast_propagate_effects(self, expr);
- if (op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) {
+ if ((op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) || op == VINSTR_NEG_F) {
self->expression.vtype = TYPE_FLOAT;
- } else
- compile_error(ctx, "cannot determine type of unary operation %s", asm_instr[op].m);
+ } else if (op == VINSTR_NEG_V) {
+ self->expression.vtype = TYPE_VECTOR;
+ } else {
+ compile_error(ctx, "cannot determine type of unary operation %s", util_instr_str[op]);
+ }
return 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);
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");
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);
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) {
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);
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) {
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);
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,
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);
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);
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);
mem_d(self);
}
-void ast_label_register_goto(ast_label *self, ast_goto *g)
+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);
self->target = label;
}
-ast_call* ast_call_new(lex_ctx ctx,
+ast_state* ast_state_new(lex_ctx_t ctx, ast_expression *frame, ast_expression *think)
+{
+ ast_instantiate(ast_state, ctx, ast_state_delete);
+ ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_state_codegen);
+ self->framenum = frame;
+ self->nextthink = think;
+ return self;
+}
+
+void ast_state_delete(ast_state *self)
+{
+ if (self->framenum)
+ ast_unref(self->framenum);
+ if (self->nextthink)
+ ast_unref(self->nextthink);
+
+ ast_expression_delete((ast_expression*)self);
+ mem_d(self);
+}
+
+ast_call* ast_call_new(lex_ctx_t ctx,
ast_expression *funcexpr)
{
ast_instantiate(ast_call, ctx, ast_call_delete);
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];
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));
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;
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);
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,
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;
vtype->hasvalue = true;
vtype->constval.vfunc = self;
- self->varargs = NULL;
- self->argc = NULL;
- self->fixedparams = NULL;
+ self->varargs = NULL;
+ self->argc = NULL;
+ self->fixedparams = NULL;
+ self->return_value = NULL;
+
+ self->static_names = NULL;
+ self->static_count = 0;
return self;
+
+cleanup:
+ mem_d(self);
+ return NULL;
}
void ast_function_delete(ast_function *self)
*/
ast_unref(self->vtype);
}
+ for (i = 0; i < vec_size(self->static_names); ++i)
+ mem_d(self->static_names[i]);
+ vec_free(self->static_names);
for (i = 0; i < vec_size(self->blocks); ++i)
ast_delete(self->blocks[i]);
vec_free(self->blocks);
ast_delete(self->argc);
if (self->fixedparams)
ast_unref(self->fixedparams);
+ if (self->return_value)
+ ast_unref(self->return_value);
mem_d(self);
}
* But I can't imagine a pituation where the output is truly unnecessary.
*/
-void _ast_codegen_output_type(ast_expression *self, ir_value *out)
+static void _ast_codegen_output_type(ast_expression *self, ir_value *out)
{
if (out->vtype == TYPE_FIELD)
out->fieldtype = self->next->vtype;
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;
+}
+
+static bool check_array(ast_value *self, ast_value *array)
+{
+ if (array->expression.flags & AST_FLAG_ARRAY_INIT && !array->initlist) {
+ compile_error(ast_ctx(self), "array without size: %s", self->name);
+ return false;
+ }
+ /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */
+ if (!array->expression.count || array->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE)) {
+ compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)array->expression.count);
+ return false;
+ }
+ return true;
+}
+
bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield)
{
ir_value *v = NULL;
self->ir_v = func->value;
if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
self->ir_v->flags |= IR_FLAG_INCLUDE_DEF;
+ if (self->expression.flags & AST_FLAG_ERASEABLE)
+ self->ir_v->flags |= IR_FLAG_ERASABLE;
+ if (self->expression.flags & AST_FLAG_BLOCK_COVERAGE)
+ func->flags |= IR_FLAG_BLOCK_COVERAGE;
/* The function is filled later on ast_function_codegen... */
return true;
}
return false;
}
- /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */
- if (!array->expression.count || array->expression.count > OPTS_OPTION_U32(OPTION_MAX_ARRAY_SIZE))
- compile_error(ast_ctx(self), "Invalid array of size %lu", (unsigned long)array->expression.count);
+ if (!check_array(self, array))
+ return false;
elemtype = array->expression.next;
vtype = elemtype->vtype;
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;
+ if (self->expression.flags & AST_FLAG_ERASEABLE)
+ self->ir_v->flags |= IR_FLAG_ERASABLE;
namelen = strlen(self->name);
name = (char*)mem_a(namelen + 16);
self->ir_v = v;
if (self->expression.flags & AST_FLAG_INCLUDE_DEF)
self->ir_v->flags |= IR_FLAG_INCLUDE_DEF;
+
+ if (self->expression.flags & AST_FLAG_ERASEABLE)
+ self->ir_v->flags |= IR_FLAG_ERASABLE;
}
return true;
}
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);
+ if (!check_array(self, self))
+ return false;
v = ir_builder_create_global(ir, self->name, vtype);
if (!v) {
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;
+ if (self->expression.flags & AST_FLAG_ERASEABLE)
+ self->ir_v->flags |= IR_FLAG_ERASABLE;
namelen = strlen(self->name);
name = (char*)mem_a(namelen + 16);
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;
+ if (self->expression.flags & AST_FLAG_ERASEABLE)
+ self->ir_v->flags |= IR_FLAG_ERASABLE;
+
+ /* initialize */
if (self->hasvalue) {
switch (self->expression.vtype)
{
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");
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;
}
-bool ast_local_codegen(ast_value *self, ir_function *func, bool param)
+static bool ast_local_codegen(ast_value *self, ir_function *func, bool param)
{
ir_value *v = NULL;
}
/* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */
- 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);
- }
+ if (!check_array(self, self))
+ return false;
self->ir_values = (ir_value**)mem_a(sizeof(self->ir_values[0]) * self->expression.count);
if (!self->ir_values) {
ir_value *dummy;
ast_expression *ec;
ast_expression_codegen *cgen;
+
size_t i;
(void)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;
}
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))
{
return true;
}
+static bool starts_a_label(ast_expression *ex)
+{
+ while (ex && ast_istype(ex, ast_block)) {
+ ast_block *b = (ast_block*)ex;
+ ex = b->exprs[0];
+ }
+ if (!ex)
+ return false;
+ return ast_istype(ex, ast_label);
+}
+
/* Note, you will not see ast_block_codegen generate ir_blocks.
* To the AST and the IR, blocks are 2 different things.
* In the AST it represents a block of code, usually enclosed in
for (i = 0; i < vec_size(self->exprs); ++i)
{
ast_expression_codegen *gen;
- if (func->curblock->final && !ast_istype(self->exprs[i], ast_label)) {
+ if (func->curblock->final && !starts_a_label(self->exprs[i])) {
if (compile_warning(ast_ctx(self->exprs[i]), WARN_UNREACHABLE_CODE, "unreachable statement"))
return false;
continue;
if ((OPTS_FLAG(SHORT_LOGIC) || OPTS_FLAG(PERL_LOGIC)) &&
(self->op == INSTR_AND || self->op == INSTR_OR))
{
+ /* NOTE: The short-logic path will ignore right_first */
+
/* short circuit evaluation */
ir_block *other, *merge;
ir_block *from_left, *from_right;
return true;
}
- cgen = self->left->codegen;
- if (!(*cgen)((ast_expression*)(self->left), func, false, &left))
- return false;
-
- cgen = self->right->codegen;
- if (!(*cgen)((ast_expression*)(self->right), func, false, &right))
- return false;
+ if (self->right_first) {
+ cgen = self->right->codegen;
+ if (!(*cgen)((ast_expression*)(self->right), func, false, &right))
+ return false;
+ cgen = self->left->codegen;
+ if (!(*cgen)((ast_expression*)(self->left), func, false, &left))
+ return false;
+ } else {
+ cgen = self->left->codegen;
+ if (!(*cgen)((ast_expression*)(self->left), func, false, &left))
+ return false;
+ cgen = self->right->codegen;
+ if (!(*cgen)((ast_expression*)(self->right), func, false, &right))
+ return false;
+ }
*out = ir_block_create_binop(func->curblock, ast_ctx(self), ast_function_label(func, "bin"),
self->op, left, right);
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;
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;
/* 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 condition */
+ if ((fold = fold_cond_ifthen(condval, func, self)) != -1)
+ return fold;
if (self->on_true) {
/* create on-true block */
ir_block *ontrue, *ontrue_out = NULL;
ir_block *onfalse, *onfalse_out = NULL;
ir_block *merge;
+ int fold = 0;
/* Ternary can never create an lvalue... */
if (lvalue)
return false;
cond_out = func->curblock;
+ /* try constant folding away the condition */
+ if ((fold = fold_cond_ternary(condval, func, self)) != -1)
+ return fold;
+
/* create on-true block */
ontrue = ir_function_create_block(ast_ctx(self), func->ir_func, ast_function_label(func, "tern_T"));
if (!ontrue)
/* 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;
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;
{
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;
return true;
}
+#include <stdio.h>
+bool ast_state_codegen(ast_state *self, ast_function *func, bool lvalue, ir_value **out)
+{
+ ast_expression_codegen *cgen;
+
+ ir_value *frameval, *thinkval;
+
+ if (lvalue) {
+ compile_error(ast_ctx(self), "not an l-value (state operation)");
+ return false;
+ }
+ if (self->expression.outr) {
+ compile_error(ast_ctx(self), "internal error: ast_state cannot be reused!");
+ return false;
+ }
+ *out = NULL;
+
+ cgen = self->framenum->codegen;
+ if (!(*cgen)((ast_expression*)(self->framenum), func, false, &frameval))
+ return false;
+ if (!frameval)
+ return false;
+
+ cgen = self->nextthink->codegen;
+ if (!(*cgen)((ast_expression*)(self->nextthink), func, false, &thinkval))
+ return false;
+ if (!frameval)
+ return false;
+
+ if (!ir_block_create_state_op(func->curblock, ast_ctx(self), frameval, thinkval)) {
+ compile_error(ast_ctx(self), "failed to create STATE instruction");
+ return false;
+ }
+
+ self->expression.outr = (ir_value*)1;
+ return true;
+}
+
bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value **out)
{
ast_expression_codegen *cgen;
projects / xonotic / gmqcc.git / blobdiff