* 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)); \
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*);
}
/* 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;
}
}
-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;
}
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,
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);
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);
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;
}
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);
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_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;
self->return_value = NULL;
return self;
+
+cleanup:
+ mem_d(self);
+ return NULL;
}
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;
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;
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);
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)
{
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;
}
}
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;
}
+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 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"));
/* 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;
projects / xonotic / gmqcc.git / blobdiff