diff --git a/Makefile b/Makefile index c800eca..ce0bc86 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ CC ?= clang -CFLAGS += -Wall -I. -fomit-frame-pointer -fno-stack-protector -O3 +CFLAGS += -Wall -I. -fomit-frame-pointer -fno-stack-protector #turn on tons of warnings if clang is present ifeq ($(CC), clang) CFLAGS += \ @@ -29,7 +29,7 @@ OBJ = \ OBJ_A = test/ast-test.o OBJ_I = test/ir-test.o OBJ_C = main.o lexer.o parser.o -OBJ_X = exec-standalone.o util.o +OBJ_X = exec-standalone.o util.o con.o #default is compiler only default: gmqcc diff --git a/ast.c b/ast.c index 9172a81..3f6c59e 100644 --- a/ast.c +++ b/ast.c @@ -276,6 +276,17 @@ static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsi buf[pos++] = ')'; return pos; + case TYPE_ARRAY: + pos = ast_type_to_string_impl(e->expression.next, buf, bufsize, pos); + if (pos + 1 >= bufsize) + goto full; + buf[pos++] = '['; + pos += snprintf(buf + pos, bufsize - pos - 1, "%i", (int)e->expression.count); + if (pos + 1 >= bufsize) + goto full; + buf[pos++] = ']'; + return pos; + default: typestr = type_name[e->expression.vtype]; typelen = strlen(typestr); @@ -312,7 +323,12 @@ ast_value* ast_value_new(lex_ctx ctx, const char *name, int t) self->uses = 0; memset(&self->constval, 0, sizeof(self->constval)); - self->ir_v = NULL; + self->ir_v = NULL; + self->ir_values = NULL; + self->ir_value_count = 0; + + self->setter = NULL; + self->getter = NULL; return self; } @@ -338,6 +354,8 @@ void ast_value_delete(ast_value* self) break; } } + if (self->ir_values) + mem_d(self->ir_values); ast_expression_delete((ast_expression*)self); mem_d(self); } @@ -465,16 +483,17 @@ void ast_return_delete(ast_return *self) ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expression *field) { - const ast_expression *outtype; - - ast_instantiate(ast_entfield, ctx, ast_entfield_delete); - if (field->expression.vtype != TYPE_FIELD) { - mem_d(self); + asterror(ctx, "ast_entfield_new with expression not of type field"); return NULL; } + return ast_entfield_new_force(ctx, entity, field, field->expression.next); +} + +ast_entfield* ast_entfield_new_force(lex_ctx ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype) +{ + ast_instantiate(ast_entfield, ctx, ast_entfield_delete); - outtype = field->expression.next; if (!outtype) { mem_d(self); /* Error: field has no type... */ @@ -548,6 +567,48 @@ void ast_member_delete(ast_member *self) mem_d(self); } +ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index) +{ + ast_expression *outtype; + ast_instantiate(ast_array_index, ctx, ast_array_index_delete); + + outtype = array->expression.next; + if (!outtype) { + mem_d(self); + /* Error: field has no type... */ + return NULL; + } + + ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_array_index_codegen); + + self->array = array; + self->index = index; + + if (!ast_type_adopt(self, outtype)) { + ast_array_index_delete(self); + return NULL; + } + if (array->expression.vtype == TYPE_FIELD && outtype->expression.vtype == TYPE_ARRAY) { + if (self->expression.vtype != TYPE_ARRAY) { + asterror(ast_ctx(self), "array_index node on type"); + ast_array_index_delete(self); + return NULL; + } + self->array = outtype; + self->expression.vtype = TYPE_FIELD; + } + + return self; +} + +void ast_array_index_delete(ast_array_index *self) +{ + ast_unref(self->array); + 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); @@ -870,16 +931,19 @@ bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_valu * on all the globals. */ if (!self->ir_v) { - asterror(ast_ctx(self), "ast_value used before generated (%s)", self->name); + char typename[1024]; + ast_type_to_string((ast_expression*)self, typename, sizeof(typename)); + asterror(ast_ctx(self), "ast_value used before generated %s %s", typename, self->name); return false; } *out = self->ir_v; return true; } -bool ast_global_codegen(ast_value *self, ir_builder *ir) +bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield) { ir_value *v = NULL; + if (self->isconst && self->expression.vtype == TYPE_FUNCTION) { ir_function *func = ir_builder_create_function(ir, self->name, self->expression.next->expression.vtype); @@ -894,25 +958,131 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) return true; } - if (self->expression.vtype == TYPE_FIELD) { - v = ir_builder_create_field(ir, self->name, self->expression.next->expression.vtype); - if (!v) - return false; - v->context = ast_ctx(self); + if (isfield && self->expression.vtype == TYPE_FIELD) { + ast_expression *fieldtype = self->expression.next; + if (self->isconst) { asterror(ast_ctx(self), "TODO: constant field pointers with value"); goto error; } - self->ir_v = v; + + if (fieldtype->expression.vtype == TYPE_ARRAY) { + size_t ai; + char *name; + size_t namelen; + + ast_expression_common *elemtype; + int vtype; + ast_value *array = (ast_value*)fieldtype; + + if (!ast_istype(fieldtype, ast_value)) { + asterror(ast_ctx(self), "internal error: ast_value required"); + 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_max_array_size) + asterror(ast_ctx(self), "Invalid array of size %lu", (unsigned long)array->expression.count); + + elemtype = &array->expression.next->expression; + vtype = elemtype->vtype; + + v = ir_builder_create_field(ir, self->name, vtype); + if (!v) { + asterror(ast_ctx(self), "ir_builder_create_global failed"); + return false; + } + if (vtype == TYPE_FIELD) + v->fieldtype = elemtype->next->expression.vtype; + v->context = ast_ctx(self); + array->ir_v = self->ir_v = v; + + namelen = strlen(self->name); + name = (char*)mem_a(namelen + 16); + strcpy(name, self->name); + + array->ir_values = (ir_value**)mem_a(sizeof(array->ir_values[0]) * array->expression.count); + array->ir_values[0] = v; + for (ai = 1; ai < array->expression.count; ++ai) { + snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); + array->ir_values[ai] = ir_builder_create_field(ir, name, vtype); + if (!array->ir_values[ai]) { + mem_d(name); + asterror(ast_ctx(self), "ir_builder_create_global failed"); + return false; + } + if (vtype == TYPE_FIELD) + array->ir_values[ai]->fieldtype = elemtype->next->expression.vtype; + array->ir_values[ai]->context = ast_ctx(self); + } + mem_d(name); + } + else + { + v = ir_builder_create_field(ir, self->name, self->expression.next->expression.vtype); + if (!v) + return false; + v->context = ast_ctx(self); + self->ir_v = v; + } return true; } - v = ir_builder_create_global(ir, self->name, self->expression.vtype); - if (!v) { - asterror(ast_ctx(self), "ir_builder_create_global failed"); - return false; + if (self->expression.vtype == TYPE_ARRAY) { + size_t ai; + char *name; + size_t namelen; + + ast_expression_common *elemtype = &self->expression.next->expression; + int vtype = elemtype->vtype; + + /* same as with field arrays */ + if (!self->expression.count || self->expression.count > opts_max_array_size) + asterror(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count); + + v = ir_builder_create_global(ir, self->name, vtype); + if (!v) { + asterror(ast_ctx(self), "ir_builder_create_global failed"); + return false; + } + if (vtype == TYPE_FIELD) + v->fieldtype = elemtype->next->expression.vtype; + v->context = ast_ctx(self); + + namelen = strlen(self->name); + name = (char*)mem_a(namelen + 16); + strcpy(name, self->name); + + self->ir_values = (ir_value**)mem_a(sizeof(self->ir_values[0]) * self->expression.count); + self->ir_values[0] = v; + for (ai = 1; ai < self->expression.count; ++ai) { + snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); + self->ir_values[ai] = ir_builder_create_global(ir, name, vtype); + if (!self->ir_values[ai]) { + mem_d(name); + asterror(ast_ctx(self), "ir_builder_create_global failed"); + return false; + } + if (vtype == TYPE_FIELD) + self->ir_values[ai]->fieldtype = elemtype->next->expression.vtype; + self->ir_values[ai]->context = ast_ctx(self); + } + mem_d(name); + } + else + { + /* Arrays don't do this since there's no "array" value which spans across the + * whole thing. + */ + v = ir_builder_create_global(ir, self->name, self->expression.vtype); + if (!v) { + asterror(ast_ctx(self), "ir_builder_create_global failed"); + return false; + } + if (self->expression.vtype == TYPE_FIELD) + v->fieldtype = self->expression.next->expression.vtype; + v->context = ast_ctx(self); } - v->context = ast_ctx(self); if (self->isconst) { switch (self->expression.vtype) @@ -929,6 +1099,9 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir) if (!ir_value_set_string(v, self->constval.vstring)) goto error; break; + case TYPE_ARRAY: + asterror(ast_ctx(self), "TODO: global constant array"); + break; case TYPE_FUNCTION: asterror(ast_ctx(self), "global of type function not properly generated"); goto error; @@ -961,10 +1134,65 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) return false; } - v = ir_function_create_local(func, self->name, self->expression.vtype, param); - if (!v) - return false; - v->context = ast_ctx(self); + if (self->expression.vtype == TYPE_ARRAY) { + size_t ai; + char *name; + size_t namelen; + + ast_expression_common *elemtype = &self->expression.next->expression; + int vtype = elemtype->vtype; + + if (param) { + asterror(ast_ctx(self), "array-parameters are not supported"); + return false; + } + + /* we are lame now - considering the way QC works we won't tolerate arrays > 1024 elements */ + if (!self->expression.count || self->expression.count > opts_max_array_size) { + asterror(ast_ctx(self), "Invalid array of size %lu", (unsigned long)self->expression.count); + } + + self->ir_values = (ir_value**)mem_a(sizeof(self->ir_values[0]) * self->expression.count); + if (!self->ir_values) { + asterror(ast_ctx(self), "failed to allocate array values"); + return false; + } + + v = ir_function_create_local(func, self->name, vtype, param); + if (!v) { + asterror(ast_ctx(self), "ir_function_create_local failed"); + return false; + } + if (vtype == TYPE_FIELD) + v->fieldtype = elemtype->next->expression.vtype; + v->context = ast_ctx(self); + + namelen = strlen(self->name); + name = (char*)mem_a(namelen + 16); + strcpy(name, self->name); + + self->ir_values[0] = v; + for (ai = 1; ai < self->expression.count; ++ai) { + snprintf(name + namelen, 16, "[%u]", (unsigned int)ai); + self->ir_values[ai] = ir_function_create_local(func, name, vtype, param); + if (!self->ir_values[ai]) { + asterror(ast_ctx(self), "ir_builder_create_global failed"); + return false; + } + if (vtype == TYPE_FIELD) + self->ir_values[ai]->fieldtype = elemtype->next->expression.vtype; + self->ir_values[ai]->context = ast_ctx(self); + } + } + else + { + v = ir_function_create_local(func, self->name, self->expression.vtype, param); + if (!v) + return false; + if (self->expression.vtype == TYPE_FIELD) + v->fieldtype = self->expression.next->expression.vtype; + v->context = ast_ctx(self); + } /* A constant local... hmmm... * I suppose the IR will have to deal with this @@ -992,6 +1220,19 @@ bool ast_local_codegen(ast_value *self, ir_function *func, bool param) /* link us to the ir_value */ self->ir_v = v; + + if (self->setter) { + if (!ast_global_codegen(self->setter, func->owner, false) || + !ast_function_codegen(self->setter->constval.vfunc, func->owner) || + !ir_function_finalize(self->setter->constval.vfunc->ir_func)) + return false; + } + if (self->getter) { + if (!ast_global_codegen(self->getter, func->owner, false) || + !ast_function_codegen(self->getter->constval.vfunc, func->owner) || + !ir_function_finalize(self->getter->constval.vfunc->ir_func)) + return false; + } return true; error: /* clean up */ @@ -1127,6 +1368,10 @@ bool ast_store_codegen(ast_store *self, ast_function *func, bool lvalue, ir_valu ast_expression_codegen *cgen; ir_value *left, *right; + ast_value *arr; + ast_value *idx; + ast_array_index *ai = NULL; + if (lvalue && self->expression.outl) { *out = self->expression.outl; return true; @@ -1137,20 +1382,72 @@ bool ast_store_codegen(ast_store *self, ast_function *func, bool lvalue, ir_valu return true; } - cgen = self->dest->expression.codegen; - /* lvalue! */ - if (!(*cgen)((ast_expression*)(self->dest), func, true, &left)) - return false; - self->expression.outl = left; + if (ast_istype(self->dest, ast_array_index)) + { - cgen = self->source->expression.codegen; - /* rvalue! */ - if (!(*cgen)((ast_expression*)(self->source), func, false, &right)) - return false; + ai = (ast_array_index*)self->dest; + idx = (ast_value*)ai->index; - if (!ir_block_create_store_op(func->curblock, self->op, left, right)) - return false; - self->expression.outr = right; + if (ast_istype(ai->index, ast_value) && idx->isconst) + ai = NULL; + } + + if (ai) { + /* we need to call the setter */ + ir_value *iridx, *funval; + ir_instr *call; + + if (lvalue) { + asterror(ast_ctx(self), "array-subscript assignment cannot produce lvalues"); + return false; + } + + arr = (ast_value*)ai->array; + if (!ast_istype(ai->array, ast_value) || !arr->setter) { + asterror(ast_ctx(self), "value has no setter (%s)", arr->name); + return false; + } + + cgen = idx->expression.codegen; + if (!(*cgen)((ast_expression*)(idx), func, false, &iridx)) + return false; + + cgen = arr->setter->expression.codegen; + if (!(*cgen)((ast_expression*)(arr->setter), func, true, &funval)) + return false; + + cgen = self->source->expression.codegen; + if (!(*cgen)((ast_expression*)(self->source), func, false, &right)) + return false; + + call = ir_block_create_call(func->curblock, ast_function_label(func, "store"), funval); + if (!call) + return false; + if (!ir_call_param(call, iridx)) + return false; + if (!ir_call_param(call, right)) + return false; + self->expression.outr = right; + } + else + { + /* regular code */ + + cgen = self->dest->expression.codegen; + /* lvalue! */ + if (!(*cgen)((ast_expression*)(self->dest), func, true, &left)) + return false; + self->expression.outl = left; + + cgen = self->source->expression.codegen; + /* rvalue! */ + if (!(*cgen)((ast_expression*)(self->source), func, false, &right)) + return false; + + if (!ir_block_create_store_op(func->curblock, self->op, left, right)) + return false; + self->expression.outr = right; + } /* Theoretically, an assinment returns its left side as an * lvalue, if we don't need an lvalue though, we return @@ -1398,6 +1695,77 @@ bool ast_member_codegen(ast_member *self, ast_function *func, bool lvalue, ir_va return (*out != NULL); } +bool ast_array_index_codegen(ast_array_index *self, ast_function *func, bool lvalue, ir_value **out) +{ + ast_value *arr; + ast_value *idx; + + if (!lvalue && self->expression.outr) { + *out = self->expression.outr; + } + if (lvalue && self->expression.outl) { + *out = self->expression.outl; + } + + if (!ast_istype(self->array, ast_value)) { + asterror(ast_ctx(self), "array indexing this way is not supported"); + /* note this would actually be pointer indexing because the left side is + * not an actual array but (hopefully) an indexable expression. + * Once we get integer arithmetic, and GADDRESS/GSTORE/GLOAD instruction + * support this path will be filled. + */ + return false; + } + + arr = (ast_value*)self->array; + idx = (ast_value*)self->index; + + if (!ast_istype(self->index, ast_value) || !idx->isconst) { + /* Time to use accessor functions */ + ast_expression_codegen *cgen; + ir_value *iridx, *funval; + ir_instr *call; + + if (lvalue) { + asterror(ast_ctx(self), "(.2) array indexing here needs a compile-time constant"); + return false; + } + + if (!arr->getter) { + asterror(ast_ctx(self), "value has no getter, don't know how to index it"); + return false; + } + + cgen = self->index->expression.codegen; + if (!(*cgen)((ast_expression*)(self->index), func, true, &iridx)) + return false; + + cgen = arr->getter->expression.codegen; + if (!(*cgen)((ast_expression*)(arr->getter), func, true, &funval)) + return false; + + call = ir_block_create_call(func->curblock, ast_function_label(func, "fetch"), funval); + if (!call) + return false; + if (!ir_call_param(call, iridx)) + return false; + + *out = ir_call_value(call); + self->expression.outr = *out; + return true; + } + + if (idx->expression.vtype == TYPE_FLOAT) + *out = arr->ir_values[(int)idx->constval.vfloat]; + else if (idx->expression.vtype == TYPE_INTEGER) + *out = arr->ir_values[idx->constval.vint]; + else { + asterror(ast_ctx(self), "array indexing here needs an integer constant"); + return false; + } + return true; +} + bool ast_ifthen_codegen(ast_ifthen *self, ast_function *func, bool lvalue, ir_value **out) { ast_expression_codegen *cgen; diff --git a/ast.h b/ast.h index 725f123..f2f05d6 100644 --- a/ast.h +++ b/ast.h @@ -31,20 +31,21 @@ typedef union ast_node_u ast_node; typedef union ast_expression_u ast_expression; -typedef struct ast_value_s ast_value; -typedef struct ast_function_s ast_function; -typedef struct ast_block_s ast_block; -typedef struct ast_binary_s ast_binary; -typedef struct ast_store_s ast_store; -typedef struct ast_binstore_s ast_binstore; -typedef struct ast_entfield_s ast_entfield; -typedef struct ast_ifthen_s ast_ifthen; -typedef struct ast_ternary_s ast_ternary; -typedef struct ast_loop_s ast_loop; -typedef struct ast_call_s ast_call; -typedef struct ast_unary_s ast_unary; -typedef struct ast_return_s ast_return; -typedef struct ast_member_s ast_member; +typedef struct ast_value_s ast_value; +typedef struct ast_function_s ast_function; +typedef struct ast_block_s ast_block; +typedef struct ast_binary_s ast_binary; +typedef struct ast_store_s ast_store; +typedef struct ast_binstore_s ast_binstore; +typedef struct ast_entfield_s ast_entfield; +typedef struct ast_ifthen_s ast_ifthen; +typedef struct ast_ternary_s ast_ternary; +typedef struct ast_loop_s ast_loop; +typedef struct ast_call_s ast_call; +typedef struct ast_unary_s ast_unary; +typedef struct ast_return_s ast_return; +typedef struct ast_member_s ast_member; +typedef struct ast_array_index_s ast_array_index; enum { TYPE_ast_node, @@ -62,7 +63,8 @@ enum { TYPE_ast_call, TYPE_ast_unary, TYPE_ast_return, - TYPE_ast_member + TYPE_ast_member, + TYPE_ast_array_index }; #define ast_istype(x, t) ( ((ast_node_common*)x)->nodetype == (TYPE_##t) ) @@ -116,6 +118,8 @@ typedef struct ast_expression_codegen *codegen; int vtype; ast_expression *next; + /* arrays get a member-count */ + size_t count; MEM_VECTOR_MAKE(ast_value*, params); bool variadic; /* The codegen functions should store their output values @@ -160,6 +164,12 @@ struct ast_value_s size_t uses; ir_value *ir_v; + ir_value **ir_values; + size_t ir_value_count; + + /* ONLY for arrays in progs version up to 6 */ + ast_value *setter; + ast_value *getter; }; ast_value* ast_value_new(lex_ctx ctx, const char *name, int qctype); @@ -171,7 +181,7 @@ bool ast_value_set_name(ast_value*, const char *name); bool ast_value_codegen(ast_value*, ast_function*, bool lvalue, ir_value**); bool ast_local_codegen(ast_value *self, ir_function *func, bool isparam); -bool ast_global_codegen(ast_value *self, ir_builder *ir); +bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield); bool GMQCC_WARN ast_value_params_add(ast_value*, ast_value*); @@ -281,6 +291,7 @@ struct ast_entfield_s ast_expression *field; }; ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expression *field); +ast_entfield* ast_entfield_new_force(lex_ctx ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype); void ast_entfield_delete(ast_entfield*); bool ast_entfield_codegen(ast_entfield*, ast_function*, bool lvalue, ir_value**); @@ -301,6 +312,27 @@ void ast_member_delete(ast_member*); bool ast_member_codegen(ast_member*, ast_function*, bool lvalue, ir_value**); +/* Array index access: + * + * QC forces us to take special action on arrays: + * an ast_store on an ast_array_index must not codegen the index, + * but call its setter - unless we have an instruction set which supports + * what we need. + * Any other array index access will be codegened to a call to the getter. + * In any case, accessing an element via a compiletime-constant index will + * result in quick access to that variable. + */ +struct ast_array_index_s +{ + ast_expression_common expression; + ast_expression *array; + ast_expression *index; +}; +ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index); +void ast_array_index_delete(ast_array_index*); + +bool ast_array_index_codegen(ast_array_index*, ast_function*, bool lvalue, ir_value**); + /* Store * * Stores left<-right and returns left. diff --git a/exec.c b/exec.c index ee0fb1b..872475b 100644 --- a/exec.c +++ b/exec.c @@ -50,6 +50,8 @@ MEM_VEC_FUN_RESIZE(qc_program, size_t, profile) MEM_VEC_FUNCTIONS(qc_program, prog_builtin, builtins) +MEM_VEC_FUNCTIONS(qc_program, const char*, function_stack) + static void loaderror(const char *fmt, ...) { int err = errno; @@ -375,7 +377,7 @@ static void trace_print_global(qc_program *prog, unsigned int glob, int vtype) len = printf("$"); else len = printf("%s ", name); - vtype = def->type; + vtype = def->type & DEF_TYPEMASK; } else len = printf("[@%u] ", glob); @@ -417,6 +419,12 @@ static void prog_print_statement(qc_program *prog, prog_section_statement *st) printf("\n", st->opcode); return; } + if ((prog->xflags & VMXF_TRACE) && prog->function_stack_count) { + size_t i; + for (i = 0; i < prog->function_stack_count; ++i) + printf("->"); + printf("%s:", prog->function_stack[prog->function_stack_count-1]); + } printf(" <> %-12s", asm_instr[st->opcode].m); if (st->opcode >= INSTR_IF && st->opcode <= INSTR_IFNOT) @@ -427,6 +435,7 @@ static void prog_print_statement(qc_program *prog, prog_section_statement *st) else if (st->opcode >= INSTR_CALL0 && st->opcode <= INSTR_CALL8) { + trace_print_global(prog, st->o1.u1, TYPE_FUNCTION); printf("\n"); } else if (st->opcode == INSTR_GOTO) @@ -513,6 +522,10 @@ static qcint prog_enterfunction(qc_program *prog, prog_section_function *func) st.stmt = prog->statement; st.function = func; + if (prog->xflags & VMXF_TRACE) { + (void)!qc_program_function_stack_add(prog, prog_getstring(prog, func->name)); + } + #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS if (prog->stack_count) { @@ -565,6 +578,11 @@ static qcint prog_leavefunction(qc_program *prog) qc_exec_stack st = prog->stack[prog->stack_count-1]; + if (prog->xflags & VMXF_TRACE) { + if (prog->function_stack_count) + prog->function_stack_count--; + } + #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS if (prog->stack_count > 1) { prev = prog->stack[prog->stack_count-2].function; @@ -1197,8 +1215,7 @@ while (1) { } ed = prog_getedict(prog, OPA->edict); - OPC->_int = ((qcint*)ed) - prog->entitydata; - OPC->_int += OPB->_int; + OPC->_int = ((qcint*)ed) - prog->entitydata + OPB->_int; break; case INSTR_STORE_F: diff --git a/gmqcc.h b/gmqcc.h index c8d1649..9770929 100644 --- a/gmqcc.h +++ b/gmqcc.h @@ -290,6 +290,9 @@ enum { TYPE_POINTER , TYPE_INTEGER , TYPE_VARIANT , + TYPE_STRUCT , + TYPE_UNION , + TYPE_ARRAY , TYPE_COUNT }; @@ -298,6 +301,7 @@ extern const char *type_name[TYPE_COUNT]; extern size_t type_sizeof[TYPE_COUNT]; extern uint16_t type_store_instr[TYPE_COUNT]; +extern uint16_t field_store_instr[TYPE_COUNT]; /* could use type_store_instr + INSTR_STOREP_F - INSTR_STORE_F * but this breaks when TYPE_INTEGER is added, since with the enhanced * instruction set, the old ones are left untouched, thus the _I instructions @@ -881,6 +885,8 @@ typedef struct qc_program_s { MEM_VECTOR_MAKE(qcint, entitydata); MEM_VECTOR_MAKE(bool, entitypool); + MEM_VECTOR_MAKE(const char*, function_stack); + uint16_t crc16; size_t tempstring_start; @@ -1023,6 +1029,7 @@ extern bool opts_werror; extern bool opts_forcecrc; extern uint16_t opts_forced_crc; extern bool opts_pp_only; +extern size_t opts_max_array_size; /*===================================================================*/ #define OPTS_FLAG(i) (!! (opts_flags[(i)/32] & (1<< ((i)%32)))) diff --git a/ir.c b/ir.c index 940cfbb..7af6162 100644 --- a/ir.c +++ b/ir.c @@ -38,10 +38,11 @@ const char *type_name[TYPE_COUNT] = { "field", "function", "pointer", -#if 0 "integer", -#endif - "variant" + "variant", + "struct", + "union", + "array" }; size_t type_sizeof[TYPE_COUNT] = { @@ -53,10 +54,11 @@ size_t type_sizeof[TYPE_COUNT] = { 1, /* TYPE_FIELD */ 1, /* TYPE_FUNCTION */ 1, /* TYPE_POINTER */ -#if 0 1, /* TYPE_INTEGER */ -#endif 3, /* TYPE_VARIANT */ + 0, /* TYPE_STRUCT */ + 0, /* TYPE_UNION */ + 0, /* TYPE_ARRAY */ }; uint16_t type_store_instr[TYPE_COUNT] = { @@ -70,9 +72,15 @@ uint16_t type_store_instr[TYPE_COUNT] = { INSTR_STORE_ENT, /* should use I */ #if 0 INSTR_STORE_I, /* integer type */ +#else + INSTR_STORE_F, #endif INSTR_STORE_V, /* variant, should never be accessed */ + + AINSTR_END, /* struct */ + AINSTR_END, /* union */ + AINSTR_END, /* array */ }; uint16_t field_store_instr[TYPE_COUNT] = { @@ -86,9 +94,15 @@ uint16_t field_store_instr[TYPE_COUNT] = { INSTR_STORE_FLD, #if 0 INSTR_STORE_FLD, /* integer type */ +#else + INSTR_STORE_FLD, #endif INSTR_STORE_V, /* variant, should never be accessed */ + + AINSTR_END, /* struct */ + AINSTR_END, /* union */ + AINSTR_END, /* array */ }; uint16_t type_storep_instr[TYPE_COUNT] = { @@ -102,9 +116,15 @@ uint16_t type_storep_instr[TYPE_COUNT] = { INSTR_STOREP_ENT, /* should use I */ #if 0 INSTR_STOREP_ENT, /* integer type */ +#else + INSTR_STOREP_F, #endif INSTR_STOREP_V, /* variant, should never be accessed */ + + AINSTR_END, /* struct */ + AINSTR_END, /* union */ + AINSTR_END, /* array */ }; uint16_t type_eq_instr[TYPE_COUNT] = { @@ -118,9 +138,15 @@ uint16_t type_eq_instr[TYPE_COUNT] = { INSTR_EQ_E, /* should use I */ #if 0 INSTR_EQ_I, +#else + INSTR_EQ_F, #endif INSTR_EQ_V, /* variant, should never be accessed */ + + AINSTR_END, /* struct */ + AINSTR_END, /* union */ + AINSTR_END, /* array */ }; uint16_t type_ne_instr[TYPE_COUNT] = { @@ -134,9 +160,15 @@ uint16_t type_ne_instr[TYPE_COUNT] = { INSTR_NE_E, /* should use I */ #if 0 INSTR_NE_I, +#else + INSTR_NE_F, #endif INSTR_NE_V, /* variant, should never be accessed */ + + AINSTR_END, /* struct */ + AINSTR_END, /* union */ + AINSTR_END, /* array */ }; MEM_VEC_FUNCTIONS(ir_value_vector, ir_value*, v) @@ -1561,6 +1593,7 @@ ir_value* ir_block_create_load_from_ent(ir_block *self, const char *label, ir_va case TYPE_INTEGER: op = INSTR_LOAD_I; break; #endif default: + irerror(self->context, "invalid type for ir_block_create_load_from_ent: %s", type_name[outype]); return NULL; } @@ -1577,6 +1610,7 @@ ir_value* ir_block_create_add(ir_block *self, if (l == r) { switch (l) { default: + irerror(self->context, "invalid type for ir_block_create_add: %s", type_name[l]); return NULL; case TYPE_FLOAT: op = INSTR_ADD_F; @@ -1598,7 +1632,10 @@ ir_value* ir_block_create_add(ir_block *self, op = INSTR_ADD_IF; else #endif + { + irerror(self->context, "invalid type for ir_block_create_add: %s", type_name[l]); return NULL; + } } return ir_block_create_binop(self, label, op, left, right); } @@ -1614,6 +1651,7 @@ ir_value* ir_block_create_sub(ir_block *self, switch (l) { default: + irerror(self->context, "invalid type for ir_block_create_sub: %s", type_name[l]); return NULL; case TYPE_FLOAT: op = INSTR_SUB_F; @@ -1635,7 +1673,10 @@ ir_value* ir_block_create_sub(ir_block *self, op = INSTR_SUB_IF; else #endif + { + irerror(self->context, "invalid type for ir_block_create_sub: %s", type_name[l]); return NULL; + } } return ir_block_create_binop(self, label, op, left, right); } @@ -1651,6 +1692,7 @@ ir_value* ir_block_create_mul(ir_block *self, switch (l) { default: + irerror(self->context, "invalid type for ir_block_create_mul: %s", type_name[l]); return NULL; case TYPE_FLOAT: op = INSTR_MUL_F; @@ -1679,8 +1721,10 @@ ir_value* ir_block_create_mul(ir_block *self, else if ( (l == TYPE_INTEGER && r == TYPE_FLOAT) ) op = INSTR_MUL_IF; #endif - else + else { + irerror(self->context, "invalid type for ir_block_create_mul: %s", type_name[l]); return NULL; + } } return ir_block_create_binop(self, label, op, left, right); } @@ -1696,6 +1740,7 @@ ir_value* ir_block_create_div(ir_block *self, switch (l) { default: + irerror(self->context, "invalid type for ir_block_create_div: %s", type_name[l]); return NULL; case TYPE_FLOAT: op = INSTR_DIV_F; @@ -1716,7 +1761,10 @@ ir_value* ir_block_create_div(ir_block *self, op = INSTR_DIV_IF; else #endif + { + irerror(self->context, "invalid type for ir_block_create_div: %s", type_name[l]); return NULL; + } } return ir_block_create_binop(self, label, op, left, right); } diff --git a/lexer.c b/lexer.c index 8485192..e190da0 100644 --- a/lexer.c +++ b/lexer.c @@ -892,6 +892,7 @@ int lex_do(lex_file *lex) /* single-character tokens */ switch (ch) { + case '[': case '(': if (!lex_tokench(lex, ch) || !lex_endtoken(lex)) @@ -906,7 +907,6 @@ int lex_do(lex_file *lex) case ';': case '{': case '}': - case '[': case ']': case '#': @@ -1095,7 +1095,8 @@ int lex_do(lex_file *lex) !strcmp(v, "struct") || !strcmp(v, "union") || !strcmp(v, "break") || - !strcmp(v, "continue")) + !strcmp(v, "continue") || + !strcmp(v, "var")) { lex->tok.ttype = TOKEN_KEYWORD; } diff --git a/lexer.h b/lexer.h index 0fbe61f..a3b9833 100644 --- a/lexer.h +++ b/lexer.h @@ -167,6 +167,7 @@ static const oper_info c_operators[] = { { ".", 2, opid1('.'), ASSOC_LEFT, 15, 0 }, { "(", 0, opid1('('), ASSOC_LEFT, 15, 0 }, /* function call */ + { "[", 2, opid1('['), ASSOC_LEFT, 15, 0 }, /* array subscript */ { "!", 1, opid2('!', 'P'), ASSOC_RIGHT, 14, OP_PREFIX }, { "~", 1, opid2('~', 'P'), ASSOC_RIGHT, 14, OP_PREFIX }, @@ -227,6 +228,7 @@ static const oper_info qcc_operators[] = { { ".", 2, opid1('.'), ASSOC_LEFT, 15, 0 }, { "(", 0, opid1('('), ASSOC_LEFT, 15, 0 }, /* function call */ + { "[", 2, opid1('['), ASSOC_LEFT, 15, 0 }, /* array subscript */ { "!", 1, opid2('!', 'P'), ASSOC_RIGHT, 14, OP_PREFIX }, { "+", 1, opid2('+','P'), ASSOC_RIGHT, 14, OP_PREFIX }, diff --git a/main.c b/main.c index d8a097c..0b9d726 100644 --- a/main.c +++ b/main.c @@ -35,6 +35,7 @@ bool opts_dump = false; bool opts_werror = false; bool opts_forcecrc = false; bool opts_pp_only = false; +size_t opts_max_array_size = 1024; uint16_t opts_forced_crc; @@ -161,6 +162,22 @@ static bool options_long_gcc(const char *optname, int *argc_, char ***argv_, cha return options_long_witharg_all(optname, argc_, argv_, out, 1, false); } +static void options_set(uint32_t *flags, size_t idx, bool on) +{ + longbit lb = LONGBIT(idx); +#if 0 + if (on) + flags[lb.idx] |= (1<<(lb.bit)); + else + flags[lb.idx] &= ~(1<<(lb.bit)); +#else + if (on) + flags[0] |= (1<<(lb)); + else + flags[0] &= ~(1<<(lb)); +#endif +} + static bool options_parse(int argc, char **argv) { bool argend = false; size_t itr; @@ -175,15 +192,19 @@ static bool options_parse(int argc, char **argv) { if (argv[0][0] == '-') { /* All gcc-type long options */ if (options_long_gcc("std", &argc, &argv, &argarg)) { - if (!strcmp(argarg, "gmqcc") || !strcmp(argarg, "default")) + if (!strcmp(argarg, "gmqcc") || !strcmp(argarg, "default")) { + options_set(opts_flags, ADJUST_VECTOR_FIELDS, true); opts_standard = COMPILER_GMQCC; - else if (!strcmp(argarg, "qcc")) + } else if (!strcmp(argarg, "qcc")) { + options_set(opts_flags, ADJUST_VECTOR_FIELDS, false); opts_standard = COMPILER_QCC; - else if (!strcmp(argarg, "fte") || !strcmp(argarg, "fteqcc")) + } else if (!strcmp(argarg, "fte") || !strcmp(argarg, "fteqcc")) { + options_set(opts_flags, ADJUST_VECTOR_FIELDS, false); opts_standard = COMPILER_FTEQCC; - else if (!strcmp(argarg, "qccx")) + } else if (!strcmp(argarg, "qccx")) { + options_set(opts_flags, ADJUST_VECTOR_FIELDS, false); opts_standard = COMPILER_QCCX; - else { + } else { con_out("Unknown standard: %s\n", argarg); return false; } @@ -349,22 +370,6 @@ static bool options_parse(int argc, char **argv) { return true; } -static void options_set(uint32_t *flags, size_t idx, bool on) -{ - longbit lb = LONGBIT(idx); -#if 0 - if (on) - flags[lb.idx] |= (1<<(lb.bit)); - else - flags[lb.idx] &= ~(1<<(lb.bit)); -#else - if (on) - flags[0] |= (1<<(lb)); - else - flags[0] &= ~(1<<(lb)); -#endif -} - /* returns the line number, or -1 on error */ static bool progs_nextline(char **out, size_t *alen,FILE *src) { @@ -417,6 +422,8 @@ int main(int argc, char **argv) { options_set(opts_warn, WARN_END_SYS_FIELDS, true); options_set(opts_warn, WARN_ASSIGN_FUNCTION_TYPES, true); + options_set(opts_flags, ADJUST_VECTOR_FIELDS, true); + if (!options_parse(argc, argv)) { return usage(); } diff --git a/parser.c b/parser.c index ce3c778..534f007 100644 --- a/parser.c +++ b/parser.c @@ -32,6 +32,9 @@ typedef struct { size_t errors; + /* we store the '=' operator info */ + const oper_info *assign_op; + /* TYPE_FIELD -> parser_find_fields is used instead of find_var * TODO: TYPE_VECTOR -> x, y and z are accepted in the gmqcc standard * anything else: type error @@ -48,7 +51,7 @@ MEM_VEC_FUNCTIONS(parser_t, varentry_t, locals) MEM_VEC_FUNCTIONS(parser_t, ast_function*, functions) static bool GMQCC_WARN parser_pop_local(parser_t *parser); -static bool parse_variable(parser_t *parser, ast_block *localblock); +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields); static ast_block* parse_block(parser_t *parser, bool warnreturn); static bool parse_block_into(parser_t *parser, ast_block *block, bool warnreturn); static ast_expression* parse_statement_or_block(parser_t *parser); @@ -306,131 +309,6 @@ static ast_expression* parser_find_var(parser_t *parser, const char *name) return v; } -typedef struct { - MEM_VECTOR_MAKE(ast_value*, p); -} paramlist_t; -MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p) - -static ast_value *parse_type(parser_t *parser, int basetype, bool *isfunc) -{ - paramlist_t params; - ast_value *var; - lex_ctx ctx = parser_ctx(parser); - int vtype = basetype; - int temptype; - size_t i; - bool variadic = false; - - MEM_VECTOR_INIT(¶ms, p); - - *isfunc = false; - - if (parser->tok == '(') { - *isfunc = true; - while (true) { - ast_value *param; - ast_value *fld; - bool isfield = false; - bool isfuncparam = false; - - if (!parser_next(parser)) - goto on_error; - - if (parser->tok == ')') - break; - - if (parser->tok == '.') { - isfield = true; - if (!parser_next(parser)) { - parseerror(parser, "expected field parameter type"); - goto on_error; - } - } - - if (parser->tok == TOKEN_DOTS) { - /* variadic args */ - variadic = true; - if (!parser_next(parser)) - goto on_error; - if (parser->tok != ')') { - parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); - goto on_error; - } - if (opts_standard == COMPILER_QCC) { - if (parsewarning(parser, WARN_EXTENSIONS, "variadic functions are not available in this standard")) - goto on_error; - } - break; - } - - temptype = parser_token(parser)->constval.t; - if (!parser_next(parser)) - goto on_error; - - param = parse_type(parser, temptype, &isfuncparam); - - if (!param) - goto on_error; - - if (parser->tok == TOKEN_IDENT) { - /* named parameter */ - if (!ast_value_set_name(param, parser_tokval(parser))) - goto on_error; - if (!parser_next(parser)) - goto on_error; - } - - /* This comes before the isfield part! */ - if (isfuncparam) { - ast_value *fval = ast_value_new(ast_ctx(param), param->name, TYPE_FUNCTION); - if (!fval) { - ast_delete(param); - goto on_error; - } - fval->expression.next = (ast_expression*)param; - MEM_VECTOR_MOVE(¶m->expression, params, &fval->expression, params); - fval->expression.variadic = param->expression.variadic; - param = fval; - } - - if (isfield) { - fld = ast_value_new(ctx, param->name, TYPE_FIELD); - fld->expression.next = (ast_expression*)param; - param = fld; - } - - if (!paramlist_t_p_add(¶ms, param)) { - parseerror(parser, "Out of memory while parsing typename"); - goto on_error; - } - - if (parser->tok == ',') - continue; - if (parser->tok == ')') - break; - parseerror(parser, "Unexpected token"); - goto on_error; - } - if (!parser_next(parser)) - goto on_error; - } - - if (params.p_count > 8) - parseerror(parser, "more than 8 parameters are currently not supported"); - - var = ast_value_new(ctx, "", vtype); - if (!var) - goto on_error; - var->expression.variadic = variadic; - MEM_VECTOR_MOVE(¶ms, p, &var->expression, params); - return var; -on_error: - for (i = 0; i < params.p_count; ++i) - ast_value_delete(params.p[i]); - MEM_VECTOR_CLEAR(¶ms, p); - return NULL; -} - typedef struct { size_t etype; /* 0 = expression, others are operators */ @@ -448,6 +326,10 @@ typedef struct MEM_VEC_FUNCTIONS(shunt, sy_elem, out) MEM_VEC_FUNCTIONS(shunt, sy_elem, ops) +#define SY_PAREN_EXPR '(' +#define SY_PAREN_FUNC 'f' +#define SY_PAREN_INDEX '[' + static sy_elem syexp(lex_ctx ctx, ast_expression *v) { sy_elem e; e.etype = 0; @@ -498,6 +380,44 @@ static sy_elem syparen(lex_ctx ctx, int p, size_t off) { # define DEBUGSHUNTDO(x) #endif +/* With regular precedence rules, ent.foo[n] is the same as (ent.foo)[n], + * so we need to rotate it to become ent.(foo[n]). + */ +static bool rotate_entfield_array_index_nodes(ast_expression **out) +{ + ast_array_index *index; + ast_entfield *entfield; + + ast_value *field; + ast_expression *sub; + ast_expression *entity; + + lex_ctx ctx = ast_ctx(*out); + + if (!ast_istype(*out, ast_array_index)) + return false; + index = (ast_array_index*)*out; + + if (!ast_istype(index->array, ast_entfield)) + return false; + entfield = (ast_entfield*)index->array; + + if (!ast_istype(entfield->field, ast_value)) + return false; + field = (ast_value*)entfield->field; + + sub = index->index; + entity = entfield->entity; + + ast_delete(index); + + index = ast_array_index_new(ctx, (ast_expression*)field, sub); + entfield = ast_entfield_new(ctx, entity, (ast_expression*)index); + *out = (ast_expression*)entfield; + + return true; +} + static bool parser_sy_pop(parser_t *parser, shunt *sy) { const oper_info *op; @@ -509,6 +429,9 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) size_t i, assignop; qcint generated_op = 0; + char ty1[1024]; + char ty2[1024]; + if (!sy->ops_count) { parseerror(parser, "internal error: missing operator"); return false; @@ -578,6 +501,32 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) } break; + case opid1('['): + if (exprs[0]->expression.vtype != TYPE_ARRAY && + !(exprs[0]->expression.vtype == TYPE_FIELD && + exprs[0]->expression.next->expression.vtype == TYPE_ARRAY)) + { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + parseerror(parser, "cannot index value of type %s", ty1); + return false; + } + if (exprs[1]->expression.vtype != TYPE_FLOAT) { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + parseerror(parser, "index must be of type float, not %s", ty1); + return false; + } + out = (ast_expression*)ast_array_index_new(ctx, exprs[0], exprs[1]); + if (rotate_entfield_array_index_nodes(&out)) + { + if (opts_standard != COMPILER_GMQCC) { + /* this error doesn't need to make us bail out */ + (void)!parsewarning(parser, WARN_EXTENSIONS, + "accessing array-field members of an entity without parenthesis\n" + " -> this is an extension from -std=gmqcc"); + } + } + break; + case opid1(','): if (blocks[0]) { if (!ast_block_exprs_add(blocks[0], exprs[1])) @@ -872,10 +821,15 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) case opid1('='): if (ast_istype(exprs[0], ast_entfield)) { ast_expression *field = ((ast_entfield*)exprs[0])->field; - assignop = type_storep_instr[exprs[0]->expression.vtype]; + if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) && + exprs[0]->expression.vtype == TYPE_FIELD && + exprs[0]->expression.next->expression.vtype == TYPE_VECTOR) + { + assignop = type_storep_instr[TYPE_VECTOR]; + } + else + assignop = type_storep_instr[exprs[0]->expression.vtype]; if (!ast_compare_type(field->expression.next, exprs[1])) { - char ty1[1024]; - char ty2[1024]; ast_type_to_string(field->expression.next, ty1, sizeof(ty1)); ast_type_to_string(exprs[1], ty2, sizeof(ty2)); if (opts_standard == COMPILER_QCC && @@ -894,10 +848,22 @@ static bool parser_sy_pop(parser_t *parser, shunt *sy) } else { - assignop = type_store_instr[exprs[0]->expression.vtype]; - if (!ast_compare_type(exprs[0], exprs[1])) { - char ty1[1024]; - char ty2[1024]; + if (OPTS_FLAG(ADJUST_VECTOR_FIELDS) && + exprs[0]->expression.vtype == TYPE_FIELD && + exprs[0]->expression.next->expression.vtype == TYPE_VECTOR) + { + assignop = type_store_instr[TYPE_VECTOR]; + } + else { + assignop = type_store_instr[exprs[0]->expression.vtype]; + } + + if (assignop == AINSTR_END) { + ast_type_to_string(exprs[0], ty1, sizeof(ty1)); + ast_type_to_string(exprs[1], ty2, sizeof(ty2)); + parseerror(parser, "invalid types in assignment: cannot assign %s to %s", ty2, ty1); + } + else if (!ast_compare_type(exprs[0], exprs[1])) { ast_type_to_string(exprs[0], ty1, sizeof(ty1)); ast_type_to_string(exprs[1], ty2, sizeof(ty2)); if (opts_standard == COMPILER_QCC && @@ -1088,15 +1054,25 @@ static bool parser_close_paren(parser_t *parser, shunt *sy, bool functions_only) } */ while (sy->ops_count) { - if (sy->ops[sy->ops_count-1].paren == 'f') { + if (sy->ops[sy->ops_count-1].paren == SY_PAREN_FUNC) { if (!parser_close_call(parser, sy)) return false; break; } - if (sy->ops[sy->ops_count-1].paren == 1) { + if (sy->ops[sy->ops_count-1].paren == SY_PAREN_EXPR) { sy->ops_count--; return !functions_only; } + if (sy->ops[sy->ops_count-1].paren == SY_PAREN_INDEX) { + if (functions_only) + return false; + /* pop off the parenthesis */ + sy->ops_count--; + /* then apply the index operator */ + if (!parser_sy_pop(parser, sy)) + return false; + return true; + } if (!parser_sy_pop(parser, sy)) return false; } @@ -1256,6 +1232,10 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma parseerror(parser, "internal error: '(' should be classified as operator"); goto onerr; } + else if (parser->tok == '[') { + parseerror(parser, "internal error: '[' should be classified as operator"); + goto onerr; + } else if (parser->tok == ')') { if (wantop) { DEBUGSHUNTDO(con_out("do[op] )\n")); @@ -1277,6 +1257,16 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma } wantop = true; } + else if (parser->tok == ']') { + if (!wantop) + parseerror(parser, "operand expected"); + --parens; + if (parens < 0) + break; + if (!parser_close_paren(parser, &sy, false)) + goto onerr; + wantop = true; + } else if (parser->tok != TOKEN_OPERATOR) { if (wantop) { parseerror(parser, "expected operator or end of statement"); @@ -1351,19 +1341,31 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma DEBUGSHUNTDO(con_out("push [op] (\n")); ++parens; /* we expected an operator, this is the function-call operator */ - if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 'f', sy.out_count-1))) { + if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_FUNC, sy.out_count-1))) { parseerror(parser, "out of memory"); goto onerr; } } else { ++parens; - if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), 1, 0))) { + if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0))) { parseerror(parser, "out of memory"); goto onerr; } DEBUGSHUNTDO(con_out("push [nop] (\n")); } wantop = false; + } else if (op->id == opid1('[')) { + if (!wantop) { + parseerror(parser, "unexpected array subscript"); + goto onerr; + } + ++parens; + /* push both the operator and the paren, this makes life easier */ + if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op))) + goto onerr; + if (!shunt_ops_add(&sy, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0))) + goto onerr; + wantop = false; } else { DEBUGSHUNTDO(con_out("push operator %s\n", op->op)); if (!shunt_ops_add(&sy, syop(parser_ctx(parser), op))) @@ -1374,7 +1376,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma if (!parser_next(parser)) { goto onerr; } - if (parser->tok == ';' || parser->tok == ']') { + if (parser->tok == ';' || (!parens && parser->tok == ']')) { break; } } @@ -1638,7 +1640,7 @@ static bool parse_for(parser_t *parser, ast_block *block, ast_expression **out) parseerror(parser, "TODO: assignment of new variables to be non-const"); goto onerr; - if (!parse_variable(parser, block)) + if (!parse_variable(parser, block, true)) goto onerr; } else if (parser->tok != ';') @@ -1723,7 +1725,7 @@ onerr: static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out) { - if (parser->tok == TOKEN_TYPENAME) + if (parser->tok == TOKEN_TYPENAME || parser->tok == '.') { /* local variable */ if (!block) { @@ -1734,7 +1736,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable")) return false; } - if (!parse_variable(parser, block)) + if (!parse_variable(parser, block, false)) return false; *out = NULL; return true; @@ -1751,7 +1753,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * parseerror(parser, "expected variable declaration"); return false; } - if (!parse_variable(parser, block)) + if (!parse_variable(parser, block, true)) return false; *out = NULL; return true; @@ -2293,88 +2295,765 @@ enderr: return false; } -static bool parse_variable(parser_t *parser, ast_block *localblock) +static ast_expression *array_accessor_split( + parser_t *parser, + ast_value *array, + ast_value *index, + size_t middle, + ast_expression *left, + ast_expression *right + ) { - bool isfunc = false; - lex_ctx ctx; + ast_ifthen *ifthen; + ast_binary *cmp; - ast_value *var = NULL; - ast_value *fld = NULL; - bool cleanvar = false; + lex_ctx ctx = ast_ctx(array); - varentry_t varent; - varentry_t ve[3]; + if (!left || !right) { + if (left) ast_delete(left); + if (right) ast_delete(right); + return NULL; + } - ast_expression *olddecl; + cmp = ast_binary_new(ctx, INSTR_LT, + (ast_expression*)index, + (ast_expression*)parser_const_float(parser, middle)); + if (!cmp) { + ast_delete(left); + ast_delete(right); + parseerror(parser, "internal error: failed to create comparison for array setter"); + return NULL; + } - ast_value *typevar; + ifthen = ast_ifthen_new(ctx, (ast_expression*)cmp, left, right); + if (!ifthen) { + ast_delete(cmp); /* will delete left and right */ + parseerror(parser, "internal error: failed to create conditional jump for array setter"); + return NULL; + } - bool hadproto; - bool isparam; + return (ast_expression*)ifthen; +} - bool retval = true; - bool isfield = false; +static ast_expression *array_setter_node(parser_t *parser, ast_value *array, ast_value *index, ast_value *value, size_t from, size_t afterend) +{ + lex_ctx ctx = ast_ctx(array); - /* go */ + if (from+1 == afterend) { + // set this value + ast_block *block; + ast_return *ret; + ast_array_index *subscript; + int assignop = type_store_instr[value->expression.vtype]; - int basetype; + if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR) + assignop = INSTR_STORE_V; - if (parser->tok == '.') { - isfield = true; - if (!parser_next(parser)) { - parseerror(parser, "expected typename for field definition"); - return false; + subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from)); + if (!subscript) + return NULL; + + ast_store *st = ast_store_new(ctx, assignop, (ast_expression*)subscript, (ast_expression*)value); + if (!st) { + ast_delete(subscript); + return NULL; + } + + block = ast_block_new(ctx); + if (!block) { + ast_delete(st); + return NULL; + } + + if (!ast_block_exprs_add(block, (ast_expression*)st)) { + ast_delete(block); + return NULL; + } + + ret = ast_return_new(ctx, NULL); + if (!ret) { + ast_delete(block); + return NULL; + } + + if (!ast_block_exprs_add(block, (ast_expression*)ret)) { + ast_delete(block); + return NULL; + } + + return (ast_expression*)block; + } else { + ast_expression *left, *right; + size_t diff = afterend - from; + size_t middle = from + diff/2; + left = array_setter_node(parser, array, index, value, from, middle); + right = array_setter_node(parser, array, index, value, middle, afterend); + return array_accessor_split(parser, array, index, middle, left, right); + } +} + +static ast_expression *array_field_setter_node( + parser_t *parser, + ast_value *array, + ast_value *entity, + ast_value *index, + ast_value *value, + size_t from, + size_t afterend) +{ + lex_ctx ctx = ast_ctx(array); + + if (from+1 == afterend) { + // set this value + ast_block *block; + ast_return *ret; + ast_entfield *entfield; + ast_array_index *subscript; + int assignop = type_storep_instr[value->expression.vtype]; + + if (value->expression.vtype == TYPE_FIELD && value->expression.next->expression.vtype == TYPE_VECTOR) + assignop = INSTR_STOREP_V; + + subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from)); + if (!subscript) + return NULL; + + entfield = ast_entfield_new_force(ctx, + (ast_expression*)entity, + (ast_expression*)subscript, + (ast_expression*)subscript); + if (!entfield) { + ast_delete(subscript); + return NULL; + } + + ast_store *st = ast_store_new(ctx, assignop, (ast_expression*)entfield, (ast_expression*)value); + if (!st) { + ast_delete(entfield); + return NULL; + } + + block = ast_block_new(ctx); + if (!block) { + ast_delete(st); + return NULL; + } + + if (!ast_block_exprs_add(block, (ast_expression*)st)) { + ast_delete(block); + return NULL; + } + + ret = ast_return_new(ctx, NULL); + if (!ret) { + ast_delete(block); + return NULL; + } + + if (!ast_block_exprs_add(block, (ast_expression*)ret)) { + ast_delete(block); + return NULL; + } + + return (ast_expression*)block; + } else { + ast_expression *left, *right; + size_t diff = afterend - from; + size_t middle = from + diff/2; + left = array_field_setter_node(parser, array, entity, index, value, from, middle); + right = array_field_setter_node(parser, array, entity, index, value, middle, afterend); + return array_accessor_split(parser, array, index, middle, left, right); + } +} + +static ast_expression *array_getter_node(parser_t *parser, ast_value *array, ast_value *index, size_t from, size_t afterend) +{ + lex_ctx ctx = ast_ctx(array); + + if (from+1 == afterend) { + ast_return *ret; + ast_array_index *subscript; + + subscript = ast_array_index_new(ctx, (ast_expression*)array, (ast_expression*)parser_const_float(parser, from)); + if (!subscript) + return NULL; + + ret = ast_return_new(ctx, (ast_expression*)subscript); + if (!ret) { + ast_delete(subscript); + return NULL; + } + + return (ast_expression*)ret; + } else { + ast_expression *left, *right; + size_t diff = afterend - from; + size_t middle = from + diff/2; + left = array_getter_node(parser, array, index, from, middle); + right = array_getter_node(parser, array, index, middle, afterend); + return array_accessor_split(parser, array, index, middle, left, right); + } +} + +static bool parser_create_array_accessor(parser_t *parser, ast_value *array, const char *funcname, ast_value **out) +{ + ast_function *func = NULL; + ast_value *fval = NULL; + + fval = ast_value_new(ast_ctx(array), funcname, TYPE_FUNCTION); + if (!fval) { + parseerror(parser, "failed to create accessor function value"); + return false; + } + + func = ast_function_new(ast_ctx(array), funcname, fval); + if (!func) { + ast_delete(fval); + parseerror(parser, "failed to create accessor function node"); + return false; + } + + *out = fval; + + return true; +} + +static bool parser_create_array_setter(parser_t *parser, ast_value *array, const char *funcname) +{ + ast_expression *root = NULL; + ast_block *body = NULL; + ast_value *index = NULL; + ast_value *value = NULL; + ast_function *func; + ast_value *fval; + + if (!ast_istype(array->expression.next, ast_value)) { + parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type"); + return false; + } + + if (!parser_create_array_accessor(parser, array, funcname, &fval)) + return false; + func = fval->constval.vfunc; + fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "", TYPE_VOID); + + body = ast_block_new(ast_ctx(array)); + if (!body) { + parseerror(parser, "failed to create block for array accessor"); + goto cleanup; + } + + index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT); + value = ast_value_copy((ast_value*)array->expression.next); + + if (!index || !value) { + parseerror(parser, "failed to create locals for array accessor"); + goto cleanup; + } + (void)!ast_value_set_name(value, "value"); /* not important */ + (void)!ast_expression_common_params_add(&fval->expression, index); + (void)!ast_expression_common_params_add(&fval->expression, value); + + root = array_setter_node(parser, array, index, value, 0, array->expression.count); + if (!root) { + parseerror(parser, "failed to build accessor search tree"); + goto cleanup; + } + + (void)!ast_block_exprs_add(body, root); + (void)!ast_function_blocks_add(func, body); + array->setter = fval; + return true; +cleanup: + if (body) ast_delete(body); + if (index) ast_delete(index); + if (value) ast_delete(value); + if (root) ast_delete(root); + ast_delete(func); + ast_delete(fval); + return false; +} + +static bool parser_create_array_field_setter(parser_t *parser, ast_value *array, const char *funcname) +{ + ast_expression *root = NULL; + ast_block *body = NULL; + ast_value *entity = NULL; + ast_value *index = NULL; + ast_value *value = NULL; + ast_function *func; + ast_value *fval; + + if (!ast_istype(array->expression.next, ast_value)) { + parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type"); + return false; + } + + if (!parser_create_array_accessor(parser, array, funcname, &fval)) + return false; + func = fval->constval.vfunc; + fval->expression.next = (ast_expression*)ast_value_new(ast_ctx(array), "", TYPE_VOID); + + body = ast_block_new(ast_ctx(array)); + if (!body) { + parseerror(parser, "failed to create block for array accessor"); + goto cleanup; + } + + entity = ast_value_new(ast_ctx(array), "entity", TYPE_ENTITY); + index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT); + value = ast_value_copy((ast_value*)array->expression.next); + if (!entity || !index || !value) { + parseerror(parser, "failed to create locals for array accessor"); + goto cleanup; + } + (void)!ast_value_set_name(value, "value"); /* not important */ + (void)!ast_expression_common_params_add(&fval->expression, entity); + (void)!ast_expression_common_params_add(&fval->expression, index); + (void)!ast_expression_common_params_add(&fval->expression, value); + + root = array_field_setter_node(parser, array, entity, index, value, 0, array->expression.count); + if (!root) { + parseerror(parser, "failed to build accessor search tree"); + goto cleanup; + } + + (void)!ast_block_exprs_add(body, root); + (void)!ast_function_blocks_add(func, body); + array->setter = fval; + return true; +cleanup: + if (body) ast_delete(body); + if (entity) ast_delete(entity); + if (index) ast_delete(index); + if (value) ast_delete(value); + if (root) ast_delete(root); + ast_delete(func); + ast_delete(fval); + return false; +} + +static bool parser_create_array_getter(parser_t *parser, ast_value *array, const ast_expression *elemtype, const char *funcname) +{ + ast_expression *root = NULL; + ast_block *body = NULL; + ast_value *index = NULL; + ast_value *fval; + ast_function *func; + + /* NOTE: checking array->expression.next rather than elemtype since + * for fields elemtype is a temporary fieldtype. + */ + if (!ast_istype(array->expression.next, ast_value)) { + parseerror(parser, "internal error: array accessor needs to build an ast_value with a copy of the element type"); + return false; + } + + if (!parser_create_array_accessor(parser, array, funcname, &fval)) + return false; + func = fval->constval.vfunc; + fval->expression.next = ast_type_copy(ast_ctx(array), elemtype); + + body = ast_block_new(ast_ctx(array)); + if (!body) { + parseerror(parser, "failed to create block for array accessor"); + goto cleanup; + } + + index = ast_value_new(ast_ctx(array), "index", TYPE_FLOAT); + + if (!index) { + parseerror(parser, "failed to create locals for array accessor"); + goto cleanup; + } + (void)!ast_expression_common_params_add(&fval->expression, index); + + root = array_getter_node(parser, array, index, 0, array->expression.count); + if (!root) { + parseerror(parser, "failed to build accessor search tree"); + goto cleanup; + } + + (void)!ast_block_exprs_add(body, root); + (void)!ast_function_blocks_add(func, body); + array->getter = fval; + return true; +cleanup: + if (body) ast_delete(body); + if (index) ast_delete(index); + if (root) ast_delete(root); + ast_delete(func); + ast_delete(fval); + return false; +} + +typedef struct { + MEM_VECTOR_MAKE(ast_value*, p); +} paramlist_t; +MEM_VEC_FUNCTIONS(paramlist_t, ast_value*, p) + +static ast_value *parse_typename(parser_t *parser, ast_value **storebase); +static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) +{ + lex_ctx ctx; + size_t i; + paramlist_t params; + ast_value *param; + ast_value *fval; + bool first = true; + bool variadic = false; + + ctx = parser_ctx(parser); + + /* for the sake of less code we parse-in in this function */ + if (!parser_next(parser)) { + parseerror(parser, "expected parameter list"); + return NULL; + } + + MEM_VECTOR_INIT(¶ms, p); + + /* parse variables until we hit a closing paren */ + while (parser->tok != ')') { + if (!first) { + /* there must be commas between them */ + if (parser->tok != ',') { + parseerror(parser, "expected comma or end of parameter list"); + goto on_error; + } + if (!parser_next(parser)) { + parseerror(parser, "expected parameter"); + goto on_error; + } + } + first = false; + + if (parser->tok == TOKEN_DOTS) { + /* '...' indicates a varargs function */ + variadic = true; + if (!parser_next(parser)) { + parseerror(parser, "expected parameter"); + return NULL; + } + if (parser->tok != ')') { + parseerror(parser, "`...` must be the last parameter of a variadic function declaration"); + goto on_error; + } + } + else + { + /* for anything else just parse a typename */ + param = parse_typename(parser, NULL); + if (!param) + goto on_error; + if (!paramlist_t_p_add(¶ms, param)) { + ast_delete(param); + goto on_error; + } + if (param->expression.vtype >= TYPE_VARIANT) { + char typename[1024]; + ast_type_to_string((ast_expression*)param, typename, sizeof(typename)); + parseerror(parser, "type not supported as part of a parameter list: %s", typename); + goto on_error; + } } } - basetype = parser_token(parser)->constval.t; + /* sanity check */ + if (params.p_count > 8) + parseerror(parser, "more than 8 parameters are currently not supported"); + + /* parse-out */ + if (!parser_next(parser)) { + parseerror(parser, "parse error after typename"); + goto on_error; + } + + /* now turn 'var' into a function type */ + fval = ast_value_new(ctx, "", TYPE_FUNCTION); + fval->expression.next = (ast_expression*)var; + fval->expression.variadic = variadic; + var = fval; + + MEM_VECTOR_MOVE(¶ms, p, &var->expression, params); + + return var; + +on_error: + ast_delete(var); + for (i = 0; i < params.p_count; ++i) + ast_delete(params.p[i]); + MEM_VECTOR_CLEAR(¶ms, p); + return NULL; +} + +static ast_value *parse_arraysize(parser_t *parser, ast_value *var) +{ + ast_expression *cexp; + ast_value *cval, *tmp; + lex_ctx ctx; + + ctx = parser_ctx(parser); if (!parser_next(parser)) { - parseerror(parser, "expected variable definition"); + ast_delete(var); + parseerror(parser, "expected array-size"); + return NULL; + } + + cexp = parse_expression_leave(parser, true); + + if (!cexp || !ast_istype(cexp, ast_value)) { + if (cexp) + ast_unref(cexp); + ast_delete(var); + parseerror(parser, "expected array-size as constant positive integer"); + return NULL; + } + cval = (ast_value*)cexp; + + tmp = ast_value_new(ctx, "", TYPE_ARRAY); + tmp->expression.next = (ast_expression*)var; + var = tmp; + + if (cval->expression.vtype == TYPE_INTEGER) + tmp->expression.count = cval->constval.vint; + else if (cval->expression.vtype == TYPE_FLOAT) + tmp->expression.count = cval->constval.vfloat; + else { + ast_unref(cexp); + ast_delete(var); + parseerror(parser, "array-size must be a positive integer constant"); + return NULL; + } + ast_unref(cexp); + + if (parser->tok != ']') { + ast_delete(var); + parseerror(parser, "expected ']' after array-size"); + return NULL; + } + if (!parser_next(parser)) { + ast_delete(var); + parseerror(parser, "error after parsing array size"); + return NULL; + } + return var; +} + +/* Parse a complete typename. + * for single-variables (ie. function parameters or typedefs) storebase should be NULL + * but when parsing variables separated by comma + * 'storebase' should point to where the base-type should be kept. + * The base type makes up every bit of type information which comes *before* the + * variable name. + * + * The following will be parsed in its entirety: + * void() foo() + * The 'basetype' in this case is 'void()' + * and if there's a comma after it, say: + * void() foo(), bar + * then the type-information 'void()' can be stored in 'storebase' + */ +static ast_value *parse_typename(parser_t *parser, ast_value **storebase) +{ + ast_value *var, *tmp; + lex_ctx ctx; + + const char *name = NULL; + bool isfield = false; + bool wasarray = false; + + ctx = parser_ctx(parser); + + /* types may start with a dot */ + if (parser->tok == '.') { + isfield = true; + /* if we parsed a dot we need a typename now */ + if (!parser_next(parser)) { + parseerror(parser, "expected typename for field definition"); + return NULL; + } + if (parser->tok != TOKEN_TYPENAME) { + parseerror(parser, "expected typename"); + return NULL; + } + } + + /* generate the basic type value */ + var = ast_value_new(ctx, "", parser_token(parser)->constval.t); + /* do not yet turn into a field - remember: + * .void() foo; is a field too + * .void()() foo; is a function + */ + + /* parse on */ + if (!parser_next(parser)) { + ast_delete(var); + parseerror(parser, "parse error after typename"); + return NULL; + } + + /* an opening paren now starts the parameter-list of a function + * this is where original-QC has parameter lists. + * We allow a single parameter list here. + * Much like fteqcc we don't allow `float()() x` + */ + if (parser->tok == '(') { + var = parse_parameter_list(parser, var); + if (!var) + return NULL; + } + + /* store the base if requested */ + if (storebase) { + *storebase = ast_value_copy(var); + if (isfield) { + tmp = ast_value_new(ctx, "", TYPE_FIELD); + tmp->expression.next = (ast_expression*)*storebase; + *storebase = tmp; + } + } + + /* there may be a name now */ + if (parser->tok == TOKEN_IDENT) { + name = util_strdup(parser_tokval(parser)); + /* parse on */ + if (!parser_next(parser)) { + ast_delete(var); + parseerror(parser, "error after variable or field declaration"); + return NULL; + } + } + + /* now this may be an array */ + if (parser->tok == '[') { + wasarray = true; + var = parse_arraysize(parser, var); + if (!var) + return NULL; + } + + /* This is the point where we can turn it into a field */ + if (isfield) { + /* turn it into a field if desired */ + tmp = ast_value_new(ctx, "", TYPE_FIELD); + tmp->expression.next = (ast_expression*)var; + var = tmp; + } + + /* now there may be function parens again */ + if (parser->tok == '(' && opts_standard == COMPILER_QCC) + parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); + if (parser->tok == '(' && wasarray) + parseerror(parser, "arrays as part of a return type is not supported"); + while (parser->tok == '(') { + var = parse_parameter_list(parser, var); + if (!var) { + if (name) + mem_d((void*)name); + ast_delete(var); + return NULL; + } + } + + /* finally name it */ + if (name) { + if (!ast_value_set_name(var, name)) { + ast_delete(var); + parseerror(parser, "internal error: failed to set name"); + return NULL; + } + /* free the name, ast_value_set_name duplicates */ + mem_d((void*)name); + } + + return var; +} + +static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields) +{ + ast_value *var; + ast_value *proto; + ast_expression *old; + bool was_end; + size_t i; + + ast_value *basetype = NULL; + bool retval = true; + bool isparam = false; + bool isvector = false; + bool cleanvar = true; + bool wasarray = false; + + varentry_t varent, ve[3]; + + /* get the first complete variable */ + var = parse_typename(parser, &basetype); + if (!var) { + if (basetype) + ast_delete(basetype); return false; } - typevar = parse_type(parser, basetype, &isfunc); - if (!typevar) - return false; + memset(&varent, 0, sizeof(varent)); + memset(&ve, 0, sizeof(ve)); - while (true) - { - hadproto = false; - olddecl = NULL; - isparam = false; - varent.name = NULL; + while (true) { + proto = NULL; + wasarray = false; - ve[0].name = ve[1].name = ve[2].name = NULL; - ve[0].var = ve[1].var = ve[2].var = NULL; - - ctx = parser_ctx(parser); - var = ast_value_copy(typevar); - cleanvar = true; - - if (!var) { - parseerror(parser, "failed to create variable"); - retval = false; - goto cleanup; - } - - if (parser->tok != TOKEN_IDENT) { - parseerror(parser, "expected variable name"); - retval = false; - goto cleanup; + /* Part 0: finish the type */ + if (parser->tok == '(') { + if (opts_standard == COMPILER_QCC) + parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); + var = parse_parameter_list(parser, var); + if (!var) { + retval = false; + goto cleanup; + } + } + /* we only allow 1-dimensional arrays */ + if (parser->tok == '[') { + wasarray = true; + var = parse_arraysize(parser, var); + if (!var) { + retval = false; + goto cleanup; + } + } + if (parser->tok == '(' && wasarray) { + parseerror(parser, "arrays as part of a return type is not supported"); + /* we'll still parse the type completely for now */ + } + /* for functions returning functions */ + while (parser->tok == '(') { + if (opts_standard == COMPILER_QCC) + parseerror(parser, "C-style function syntax is not allowed in -std=qcc"); + var = parse_parameter_list(parser, var); + if (!var) { + retval = false; + goto cleanup; + } } + /* Part 1: + * check for validity: (end_sys_..., multiple-definitions, prototypes, ...) + * Also: if there was a prototype, `var` will be deleted and set to `proto` which + * is then filled with the previous definition and the parameter-names replaced. + */ if (!localblock) { - bool was_end = false; - if (!strcmp(parser_tokval(parser), "end_sys_globals")) { + /* Deal with end_sys_ vars */ + was_end = false; + if (!strcmp(var->name, "end_sys_globals")) { parser->crc_globals = parser->globals_count; was_end = true; } - else if (!strcmp(parser_tokval(parser), "end_sys_fields")) { + else if (!strcmp(var->name, "end_sys_fields")) { parser->crc_fields = parser->fields_count; was_end = true; } - if (isfield && was_end) { + if (was_end && var->expression.vtype == TYPE_FIELD) { if (parsewarning(parser, WARN_END_SYS_FIELDS, "global '%s' hint should not be a field", parser_tokval(parser))) @@ -2382,221 +3061,162 @@ static bool parse_variable(parser_t *parser, ast_block *localblock) retval = false; goto cleanup; } - - } - } - - if (!ast_value_set_name(var, parser_tokval(parser))) { - parseerror(parser, "failed to set variable name\n"); - retval = false; - goto cleanup; - } - - if (isfunc) { - /* a function was defined */ - ast_value *fval; - ast_value *proto = NULL; - bool dummy; - - if (!localblock) - olddecl = parser_find_global(parser, parser_tokval(parser)); - else - olddecl = parser_find_local(parser, parser_tokval(parser), parser->blocklocal, &dummy); - - if (olddecl) { - /* we had a prototype */ - if (!ast_istype(olddecl, ast_value)) { - /* vector v; - * void() v_x = {} - */ - parseerror(parser, "cannot declare a function with the same name as a vector's member: %s", - parser_tokval(parser)); - retval = false; - goto cleanup; - } - - proto = (ast_value*)olddecl; } - /* turn var into a value of TYPE_FUNCTION, with the old var - * as return type - */ - fval = ast_value_new(ctx, var->name, TYPE_FUNCTION); - if (!fval) { - retval = false; - goto cleanup; - } - - fval->expression.next = (ast_expression*)var; - MEM_VECTOR_MOVE(&var->expression, params, &fval->expression, params); - fval->expression.variadic = var->expression.variadic; - var = NULL; - - /* we compare the type late here, but it's easier than - * messing with the parameter-vector etc. earlier - */ - if (proto) { - size_t param; - if (!ast_compare_type((ast_expression*)proto, (ast_expression*)fval)) { - parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i", - proto->name, - ast_ctx(proto).file, ast_ctx(proto).line); - ast_value_delete(fval); - retval = false; - goto cleanup; - } - /* copy over the parameter names */ - for (param = 0; param < fval->expression.params_count; ++param) - ast_value_set_name(proto->expression.params[param], fval->expression.params[param]->name); - /* copy the new context */ - ast_ctx(proto) = ast_ctx(fval); - - /* now ditch the rest of the new data */ - ast_value_delete(fval); - fval = proto; - hadproto = true; - } - - var = fval; - } - - if (isfield) { - ast_value *tmp; - fld = ast_value_new(ctx, var->name, TYPE_FIELD); - fld->expression.next = (ast_expression*)var; - tmp = var; - var = fld; - fld = tmp; - } - else - fld = var; - - if (!isfunc) { - if (!localblock) + if (!nofields && var->expression.vtype == TYPE_FIELD) { - olddecl = parser_find_global(parser, var->name); - if (olddecl) { - if (!isfield) { - parseerror(parser, "global `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - else if (opts_standard == COMPILER_QCC) { - parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); - parseerror(parser, "global `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - } - olddecl = parser_find_field(parser, var->name); - if (olddecl && opts_standard == COMPILER_QCC) { - if (!isfield) { - parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); - parseerror(parser, "field `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - else + /* deal with field declarations */ + old = parser_find_field(parser, var->name); + if (old) { + if (parsewarning(parser, WARN_FIELD_REDECLARED, "field `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, (int)ast_ctx(old).line)) { - if (parsewarning(parser, WARN_FIELD_REDECLARED, "field `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line)) - { - retval = false; - goto cleanup; - } - if (!ast_compare_type(olddecl, (ast_expression*)var)) { - parseerror(parser, "field %s has previously been declared with a different type here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } - ast_delete(var); - var = NULL; - goto nextvar; + retval = false; + goto cleanup; } - } - else if (olddecl) { + ast_delete(var); + var = NULL; + goto skipvar; + /* parseerror(parser, "field `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); + var->name, ast_ctx(old).file, ast_ctx(old).line); + retval = false; + goto cleanup; + */ + } + if (opts_standard == COMPILER_QCC && + (old = parser_find_global(parser, var->name))) + { + parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); + parseerror(parser, "field `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, ast_ctx(old).line); retval = false; goto cleanup; } } - else /* if it's a local: */ + else { - olddecl = parser_find_local(parser, var->name, parser->blocklocal, &isparam); - if (opts_standard == COMPILER_GMQCC) + /* deal with other globals */ + old = parser_find_global(parser, var->name); + if (old && var->expression.vtype == TYPE_FUNCTION && old->expression.vtype == TYPE_FUNCTION) { - if (olddecl) - { - if (!isparam) { - parseerror(parser, "local `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } + /* This is a function which had a prototype */ + if (!ast_istype(old, ast_value)) { + parseerror(parser, "internal error: prototype is not an ast_value"); + retval = false; + goto cleanup; } - - if( (!isparam && olddecl) || - (olddecl = parser_find_local(parser, var->name, 0, &isparam)) - ) - { - if (parsewarning(parser, WARN_LOCAL_SHADOWS, - "local `%s` is shadowing a parameter", var->name)) - { - parseerror(parser, "local `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - retval = false; - goto cleanup; - } + proto = (ast_value*)old; + if (!ast_compare_type((ast_expression*)proto, (ast_expression*)var)) { + parseerror(parser, "conflicting types for `%s`, previous declaration was here: %s:%i", + proto->name, + ast_ctx(proto).file, ast_ctx(proto).line); + retval = false; + goto cleanup; } + /* we need the new parameter-names */ + for (i = 0; i < proto->expression.params_count; ++i) + ast_value_set_name(proto->expression.params[i], var->expression.params[i]->name); + ast_delete(var); + var = proto; } else { - if (olddecl) + /* other globals */ + if (old) { + parseerror(parser, "global `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, ast_ctx(old).line); + retval = false; + goto cleanup; + } + if (opts_standard == COMPILER_QCC && + (old = parser_find_field(parser, var->name))) { - if (isparam && - parsewarning(parser, WARN_LOCAL_SHADOWS, - "a parameter is shadowing local `%s`", var->name)) - { - ast_value_delete(var); - var = NULL; - retval = false; - goto cleanup; - } - else if (!isparam) - { - parseerror(parser, "local `%s` already declared here: %s:%i", - var->name, ast_ctx(olddecl).file, (int)ast_ctx(olddecl).line); - ast_value_delete(var); - var = NULL; - retval = false; - goto cleanup; - } - ast_value_delete(var); - var = NULL; - goto nextvar; + parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc"); + parseerror(parser, "global `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, ast_ctx(old).line); + retval = false; + goto cleanup; } } } } + else /* it's not a global */ + { + old = parser_find_local(parser, var->name, parser->blocklocal, &isparam); + if (old && !isparam) { + parseerror(parser, "local `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, (int)ast_ctx(old).line); + retval = false; + goto cleanup; + } + old = parser_find_local(parser, var->name, 0, &isparam); + if (old && isparam) { + if (parsewarning(parser, WARN_LOCAL_SHADOWS, + "local `%s` is shadowing a parameter", var->name)) + { + parseerror(parser, "local `%s` already declared here: %s:%i", + var->name, ast_ctx(old).file, (int)ast_ctx(old).line); + retval = false; + goto cleanup; + } + if (opts_standard != COMPILER_GMQCC) { + ast_delete(var); + var = NULL; + goto skipvar; + } + } + } + /* Part 2: + * Create the global/local, and deal with vector types. + */ + if (!proto) { + if (var->expression.vtype == TYPE_VECTOR) + isvector = true; + else if (var->expression.vtype == TYPE_FIELD && + var->expression.next->expression.vtype == TYPE_VECTOR) + isvector = true; + + if (isvector) { + if (!create_vector_members(parser, var, ve)) { + retval = false; + goto cleanup; + } + } - if (!hadproto) { varent.name = util_strdup(var->name); - varent.var = (ast_expression*)var; + varent.var = (ast_expression*)var; if (!localblock) { - if (!isfield) { - if (!(retval = parser_t_globals_add(parser, varent))) - goto cleanup; - } - else { + /* deal with global variables, fields, functions */ + if (!nofields && var->expression.vtype == TYPE_FIELD) { if (!(retval = parser_t_fields_add(parser, varent))) goto cleanup; + if (isvector) { + for (i = 0; i < 3; ++i) { + if (!(retval = parser_t_fields_add(parser, ve[i]))) + break; + } + if (!retval) { + parser->fields_count -= i+1; + goto cleanup; + } + } + } + else { + if (!(retval = parser_t_globals_add(parser, varent))) + goto cleanup; + if (isvector) { + for (i = 0; i < 3; ++i) { + if (!(retval = parser_t_globals_add(parser, ve[i]))) + break; + } + if (!retval) { + parser->globals_count -= i+1; + goto cleanup; + } + } } } else { if (!(retval = parser_t_locals_add(parser, varent))) @@ -2605,99 +3225,108 @@ static bool parse_variable(parser_t *parser, ast_block *localblock) parser->locals_count--; goto cleanup; } - } - - if (fld->expression.vtype == TYPE_VECTOR) - { - size_t e; - if (!create_vector_members(parser, var, ve)) { - retval = false; - goto cleanup; - } - - if (!localblock) { - for (e = 0; e < 3; ++e) { - if (!isfield) { - if (!(retval = parser_t_globals_add(parser, ve[e]))) - break; - } - else { - if (!(retval = parser_t_fields_add(parser, ve[e]))) - break; - } + if (isvector) { + for (i = 0; i < 3; ++i) { + if (!(retval = parser_t_locals_add(parser, ve[i]))) + break; + if (!(retval = ast_block_collect(localblock, ve[i].var))) + break; + ve[i].var = NULL; /* from here it's being collected in the block */ } if (!retval) { - parser->globals_count -= e+1; - goto cleanup; - } - } else { - for (e = 0; e < 3; ++e) { - if (!(retval = parser_t_locals_add(parser, ve[e]))) - break; - if (!(retval = ast_block_collect(localblock, ve[e].var))) - break; - ve[e].var = NULL; /* from here it's being collected in the block */ - } - if (!retval) { - parser->locals_count -= e+1; + parser->locals_count -= i+1; localblock->locals_count--; goto cleanup; } } - ve[0].name = ve[1].name = ve[2].name = NULL; - ve[0].var = ve[1].var = ve[2].var = NULL; } - cleanvar = false; + varent.name = NULL; + ve[0].name = ve[1].name = ve[2].name = NULL; + ve[0].var = ve[1].var = ve[2].var = NULL; + cleanvar = false; } - -nextvar: - if (!(retval = parser_next(parser))) - goto cleanup; - - if (parser->tok == ';') { - ast_value_delete(typevar); - return parser_next(parser); - } - - if (parser->tok == ',') { - /* another var */ - if (!(retval = parser_next(parser))) - goto cleanup; - continue; - } - - if (!localblock && isfield) { - parseerror(parser, "missing semicolon"); - ast_value_delete(typevar); - return false; - } - - /* NOTE: only 'typevar' needs to be deleted from here on, so 'cleanup' won't be used - * to avoid having too many gotos + /* Part 2.2 + * deal with arrays */ + if (var->expression.vtype == TYPE_ARRAY) { + char name[1024]; + snprintf(name, sizeof(name), "%s##SET", var->name); + if (!parser_create_array_setter(parser, var, name)) + goto cleanup; + snprintf(name, sizeof(name), "%s##GET", var->name); + if (!parser_create_array_getter(parser, var, var->expression.next, name)) + goto cleanup; + } + else if (!localblock && !nofields && + var->expression.vtype == TYPE_FIELD && + var->expression.next->expression.vtype == TYPE_ARRAY) + { + char name[1024]; + ast_expression *telem; + ast_value *tfield; + ast_value *array = (ast_value*)var->expression.next; + + if (!ast_istype(var->expression.next, ast_value)) { + parseerror(parser, "internal error: field element type must be an ast_value"); + goto cleanup; + } + + snprintf(name, sizeof(name), "%s##SETF", var->name); + if (!parser_create_array_field_setter(parser, array, name)) + goto cleanup; + + telem = ast_type_copy(ast_ctx(var), array->expression.next); + tfield = ast_value_new(ast_ctx(var), "<.type>", TYPE_FIELD); + tfield->expression.next = telem; + snprintf(name, sizeof(name), "%s##GETFP", var->name); + if (!parser_create_array_getter(parser, array, (ast_expression*)tfield, name)) { + ast_delete(tfield); + goto cleanup; + } + ast_delete(tfield); + } + +skipvar: + if (parser->tok == ';') { + ast_delete(basetype); + if (!parser_next(parser)) { + parseerror(parser, "error after variable declaration"); + return false; + } + return true; + } + + if (parser->tok == ',') + goto another; + + if (!var || (!localblock && !nofields && basetype->expression.vtype == TYPE_FIELD)) { + parseerror(parser, "missing comma or semicolon while parsing variables"); + break; + } + if (localblock && opts_standard == COMPILER_QCC) { if (parsewarning(parser, WARN_LOCAL_CONSTANTS, "initializing expression turns variable `%s` into a constant in this standard", var->name) ) { - ast_value_delete(typevar); - return false; + break; } } - if (parser->tok != '=') { - if (opts_standard == COMPILER_QCC) - parseerror(parser, "missing semicolon"); - else + if (parser->tok != '{') { + if (parser->tok != '=') { parseerror(parser, "missing semicolon or initializer"); - ast_value_delete(typevar); - return false; - } + break; + } - if (!parser_next(parser)) { - ast_value_delete(typevar); - return false; + if (!parser_next(parser)) { + parseerror(parser, "error parsing initializer"); + break; + } + } + else if (opts_standard == COMPILER_QCC) { + parseerror(parser, "expected '=' before function body in this standard"); } if (parser->tok == '#') { @@ -2705,107 +3334,149 @@ nextvar: if (localblock) { parseerror(parser, "cannot declare builtins within functions"); - ast_value_delete(typevar); - return false; + break; } - if (!isfunc) { + if (var->expression.vtype != TYPE_FUNCTION) { parseerror(parser, "unexpected builtin number, '%s' is not a function", var->name); - ast_value_delete(typevar); - return false; + break; } if (!parser_next(parser)) { parseerror(parser, "expected builtin number"); - ast_value_delete(typevar); - return false; + break; } if (parser->tok != TOKEN_INTCONST) { parseerror(parser, "builtin number must be an integer constant"); - ast_value_delete(typevar); - return false; + break; } if (parser_token(parser)->constval.i <= 0) { - parseerror(parser, "builtin number must be positive integer greater than zero"); - ast_value_delete(typevar); - return false; + parseerror(parser, "builtin number must be an integer greater than zero"); + break; } func = ast_function_new(ast_ctx(var), var->name, var); if (!func) { parseerror(parser, "failed to allocate function for `%s`", var->name); - ast_value_delete(typevar); - return false; + break; } if (!parser_t_functions_add(parser, func)) { parseerror(parser, "failed to allocate slot for function `%s`", var->name); ast_function_delete(func); var->constval.vfunc = NULL; - ast_value_delete(typevar); - return false; + break; } func->builtin = -parser_token(parser)->constval.i; if (!parser_next(parser)) { - ast_value_delete(typevar); - return false; + parseerror(parser, "expected comma or semicolon"); + ast_function_delete(func); + var->constval.vfunc = NULL; + break; } } else if (parser->tok == '{' || parser->tok == '[') { - ast_value_delete(typevar); if (localblock) { parseerror(parser, "cannot declare functions within functions"); - return false; + break; } - if (!parse_function_body(parser, var)) { - return false; - } + if (!parse_function_body(parser, var)) + break; + ast_delete(basetype); return true; } else { ast_expression *cexp; ast_value *cval; cexp = parse_expression_leave(parser, true); - if (!cexp) { - ast_value_delete(typevar); - return false; - } + if (!cexp) + break; - cval = (ast_value*)cexp; - if (!ast_istype(cval, ast_value) || !cval->isconst) - parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); - else - { - var->isconst = true; - if (cval->expression.vtype == TYPE_STRING) - var->constval.vstring = parser_strdup(cval->constval.vstring); + if (!localblock) { + cval = (ast_value*)cexp; + if (!ast_istype(cval, ast_value) || !cval->isconst) + parseerror(parser, "cannot initialize a global constant variable with a non-constant expression"); else - memcpy(&var->constval, &cval->constval, sizeof(var->constval)); - ast_unref(cval); + { + var->isconst = true; + if (cval->expression.vtype == TYPE_STRING) + var->constval.vstring = parser_strdup(cval->constval.vstring); + else + memcpy(&var->constval, &cval->constval, sizeof(var->constval)); + ast_unref(cval); + } + } else { + shunt sy; + MEM_VECTOR_INIT(&sy, out); + MEM_VECTOR_INIT(&sy, ops); + if (!shunt_out_add(&sy, syexp(ast_ctx(var), (ast_expression*)var)) || + !shunt_out_add(&sy, syexp(ast_ctx(cexp), (ast_expression*)cexp)) || + !shunt_ops_add(&sy, syop(ast_ctx(var), parser->assign_op))) + { + parseerror(parser, "internal error: failed to prepare initializer"); + ast_unref(cexp); + } + else if (!parser_sy_pop(parser, &sy)) + ast_unref(cexp); + else { + if (sy.out_count != 1 && sy.ops_count != 0) + parseerror(parser, "internal error: leaked operands"); + else if (!ast_block_exprs_add(localblock, (ast_expression*)sy.out[0].out)) { + parseerror(parser, "failed to create intializing expression"); + ast_unref(sy.out[0].out); + ast_unref(cexp); + } + } + MEM_VECTOR_CLEAR(&sy, out); + MEM_VECTOR_CLEAR(&sy, ops); } } +another: if (parser->tok == ',') { - /* another */ + if (!parser_next(parser)) { + parseerror(parser, "expected another variable"); + break; + } + + if (parser->tok != TOKEN_IDENT) { + parseerror(parser, "expected another variable"); + break; + } + var = ast_value_copy(basetype); + cleanvar = true; + ast_value_set_name(var, parser_tokval(parser)); + if (!parser_next(parser)) { + parseerror(parser, "error parsing variable declaration"); + break; + } continue; } if (parser->tok != ';') { - parseerror(parser, "missing semicolon"); - ast_value_delete(typevar); - return false; + parseerror(parser, "missing semicolon after variables"); + break; } - (void)parser_next(parser); + if (!parser_next(parser)) { + parseerror(parser, "parse error after variable declaration"); + break; + } - ast_value_delete(typevar); + ast_delete(basetype); return true; } + if (cleanvar && var) + ast_delete(var); + ast_delete(basetype); + return false; + cleanup: - ast_delete(typevar); - if (var && cleanvar) ast_delete(var); + ast_delete(basetype); + if (cleanvar && var) + ast_delete(var); if (varent.name) mem_d(varent.name); if (ve[0].name) mem_d(ve[0].name); if (ve[1].name) mem_d(ve[1].name); @@ -2813,7 +3484,6 @@ cleanup: if (ve[0].var) mem_d(ve[0].var); if (ve[1].var) mem_d(ve[1].var); if (ve[2].var) mem_d(ve[2].var); - return retval; } @@ -2821,11 +3491,18 @@ static bool parser_global_statement(parser_t *parser) { if (parser->tok == TOKEN_TYPENAME || parser->tok == '.') { - return parse_variable(parser, NULL); + return parse_variable(parser, NULL, false); } else if (parser->tok == TOKEN_KEYWORD) { /* handle 'var' and 'const' */ + if (!strcmp(parser_tokval(parser), "var")) { + if (!parser_next(parser)) { + parseerror(parser, "expected variable declaration after 'var'"); + return false; + } + return parse_variable(parser, NULL, true); + } return false; } else if (parser->tok == '$') @@ -2847,11 +3524,24 @@ static parser_t *parser; bool parser_init() { + size_t i; parser = (parser_t*)mem_a(sizeof(parser_t)); if (!parser) return false; memset(parser, 0, sizeof(*parser)); + + for (i = 0; i < operator_count; ++i) { + if (operators[i].id == opid1('=')) { + parser->assign_op = operators+i; + break; + } + } + if (!parser->assign_op) { + printf("internal error: initializing parser: failed to find assign operator\n"); + mem_d(parser); + return false; + } return true; } @@ -3035,7 +3725,7 @@ bool parser_finish(const char *output) field = (ast_value*)parser->fields[i].var; isconst = field->isconst; field->isconst = false; - if (!ast_global_codegen((ast_value*)field, ir)) { + if (!ast_global_codegen((ast_value*)field, ir, true)) { con_out("failed to generate field %s\n", field->name); ir_builder_delete(ir); return false; @@ -3066,33 +3756,88 @@ bool parser_finish(const char *output) "unused global: `%s`", asvalue->name); } } - if (!ast_global_codegen(asvalue, ir)) { + if (!ast_global_codegen(asvalue, ir, false)) { con_out("failed to generate global %s\n", parser->globals[i].name); ir_builder_delete(ir); return false; } } for (i = 0; i < parser->imm_float_count; ++i) { - if (!ast_global_codegen(parser->imm_float[i], ir)) { + if (!ast_global_codegen(parser->imm_float[i], ir, false)) { con_out("failed to generate global %s\n", parser->imm_float[i]->name); ir_builder_delete(ir); return false; } } for (i = 0; i < parser->imm_string_count; ++i) { - if (!ast_global_codegen(parser->imm_string[i], ir)) { + if (!ast_global_codegen(parser->imm_string[i], ir, false)) { con_out("failed to generate global %s\n", parser->imm_string[i]->name); ir_builder_delete(ir); return false; } } for (i = 0; i < parser->imm_vector_count; ++i) { - if (!ast_global_codegen(parser->imm_vector[i], ir)) { + if (!ast_global_codegen(parser->imm_vector[i], ir, false)) { con_out("failed to generate global %s\n", parser->imm_vector[i]->name); ir_builder_delete(ir); return false; } } + for (i = 0; i < parser->globals_count; ++i) { + ast_value *asvalue; + if (!ast_istype(parser->globals[i].var, ast_value)) + continue; + asvalue = (ast_value*)(parser->globals[i].var); + if (asvalue->setter) { + if (!ast_global_codegen(asvalue->setter, ir, false) || + !ast_function_codegen(asvalue->setter->constval.vfunc, ir) || + !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func)) + { + printf("failed to generate setter for %s\n", parser->globals[i].name); + ir_builder_delete(ir); + return false; + } + } + if (asvalue->getter) { + if (!ast_global_codegen(asvalue->getter, ir, false) || + !ast_function_codegen(asvalue->getter->constval.vfunc, ir) || + !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func)) + { + printf("failed to generate getter for %s\n", parser->globals[i].name); + ir_builder_delete(ir); + return false; + } + } + } + for (i = 0; i < parser->fields_count; ++i) { + ast_value *asvalue; + asvalue = (ast_value*)(parser->fields[i].var->expression.next); + + if (!ast_istype((ast_expression*)asvalue, ast_value)) + continue; + if (asvalue->expression.vtype != TYPE_ARRAY) + continue; + if (asvalue->setter) { + if (!ast_global_codegen(asvalue->setter, ir, false) || + !ast_function_codegen(asvalue->setter->constval.vfunc, ir) || + !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func)) + { + printf("failed to generate setter for %s\n", parser->fields[i].name); + ir_builder_delete(ir); + return false; + } + } + if (asvalue->getter) { + if (!ast_global_codegen(asvalue->getter, ir, false) || + !ast_function_codegen(asvalue->getter->constval.vfunc, ir) || + !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func)) + { + printf("failed to generate getter for %s\n", parser->fields[i].name); + ir_builder_delete(ir); + return false; + } + } + } for (i = 0; i < parser->functions_count; ++i) { if (!ast_function_codegen(parser->functions[i], ir)) { con_out("failed to generate function %s\n", parser->functions[i]->name); diff --git a/testsuite/Makefile b/testsuite/Makefile index e902e55..6eafd4c 100644 --- a/testsuite/Makefile +++ b/testsuite/Makefile @@ -17,7 +17,8 @@ TESTLIST = \ ngraphs \ invalid-assign \ field-parameters \ - functions-as-parameters + functions-as-parameters \ + shadow-qcc shadow-gmqcc .PHONY: clean test @@ -168,6 +169,16 @@ functions-as-parameters: @$(VM) $< > $@/output @diff $@/output $@/expected +$(eval $(call maketest,shadow-qcc,qcc)) +shadow-qcc: + @$(VM) -vector '33 44 55' $< > $@/output + @diff $@/output $@/expected + +$(eval $(call maketest,shadow-gmqcc,gm)) +shadow-gmqcc: + @$(VM) -vector '33 44 55' $< > $@/output + @diff $@/output $@/expected + ####################################################################### obj: mkdir obj diff --git a/testsuite/shadow-gmqcc/expected b/testsuite/shadow-gmqcc/expected new file mode 100644 index 0000000..89f4331 --- /dev/null +++ b/testsuite/shadow-gmqcc/expected @@ -0,0 +1 @@ +'0 0 0' diff --git a/testsuite/shadow-gmqcc/main.qc b/testsuite/shadow-gmqcc/main.qc new file mode 100644 index 0000000..08bc917 --- /dev/null +++ b/testsuite/shadow-gmqcc/main.qc @@ -0,0 +1,7 @@ +void(string, string) print = #1; +string(vector) vtos = #5; + +void(vector org) main = { + local vector org; + print(vtos(org), "\n"); +}; diff --git a/testsuite/shadow-qcc/expected b/testsuite/shadow-qcc/expected new file mode 100644 index 0000000..9ec2a0c --- /dev/null +++ b/testsuite/shadow-qcc/expected @@ -0,0 +1 @@ +'33 44 55' diff --git a/testsuite/shadow-qcc/main.qc b/testsuite/shadow-qcc/main.qc new file mode 100644 index 0000000..08bc917 --- /dev/null +++ b/testsuite/shadow-qcc/main.qc @@ -0,0 +1,7 @@ +void(string, string) print = #1; +string(vector) vtos = #5; + +void(vector org) main = { + local vector org; + print(vtos(org), "\n"); +};