From d6ca5673dc7f2760faca1200477808d919a290ca Mon Sep 17 00:00:00 2001 From: Dale Weiler Date: Tue, 30 Jul 2013 16:00:51 +0000 Subject: [PATCH] Use the _t consistency naming scheme. Also various cleanups. --- ast.c | 48 ++++++------ ast.h | 48 ++++++------ code.c | 90 +++++++++++------------ conout.c | 25 +++---- exec.c | 218 +++++++++++++++++++++++++++---------------------------- ftepp.c | 22 +++--- gmqcc.h | 197 ++++++++++++++++++++++++------------------------- ir.c | 94 ++++++++++++------------ ir.h | 46 ++++++------ lexer.c | 6 +- lexer.h | 4 +- opts.c | 8 +- parser.c | 106 +++++++++++++-------------- 13 files changed, 453 insertions(+), 459 deletions(-) diff --git a/ast.c b/ast.c index 5f07e83..7a8f6cc 100644 --- a/ast.c +++ b/ast.c @@ -84,7 +84,7 @@ static GMQCC_NORETURN void _ast_node_destroy(ast_node *self) } /* Initialize main ast node aprts */ -static void ast_node_init(ast_node *self, lex_ctx ctx, int nodetype) +static void ast_node_init(ast_node *self, lex_ctx_t ctx, int nodetype) { self->context = ctx; self->destroy = &_ast_node_destroy; @@ -174,7 +174,7 @@ void ast_type_adopt_impl(ast_expression *self, const ast_expression *other) } } -static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) +static ast_expression* ast_shallow_type(lex_ctx_t ctx, int vtype) { ast_instantiate(ast_expression, ctx, ast_expression_delete_full); ast_expression_init(self, NULL); @@ -184,7 +184,7 @@ static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype) return self; } -ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex) +ast_expression* ast_type_copy(lex_ctx_t ctx, const ast_expression *ex) { size_t i; const ast_expression *fromex; @@ -342,7 +342,7 @@ void ast_type_to_string(ast_expression *e, char *buf, size_t bufsize) } static bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_value **out); -ast_value* ast_value_new(lex_ctx ctx, const char *name, int t) +ast_value* ast_value_new(lex_ctx_t ctx, const char *name, int t) { ast_instantiate(ast_value, ctx, ast_value_delete); ast_expression_init((ast_expression*)self, @@ -433,7 +433,7 @@ bool ast_value_set_name(ast_value *self, const char *name) return !!self->name; } -ast_binary* ast_binary_new(lex_ctx ctx, int op, +ast_binary* ast_binary_new(lex_ctx_t ctx, int op, ast_expression* left, ast_expression* right) { ast_instantiate(ast_binary, ctx, ast_binary_delete); @@ -478,7 +478,7 @@ void ast_binary_delete(ast_binary *self) mem_d(self); } -ast_binstore* ast_binstore_new(lex_ctx ctx, int storop, int op, +ast_binstore* ast_binstore_new(lex_ctx_t ctx, int storop, int op, ast_expression* left, ast_expression* right) { ast_instantiate(ast_binstore, ctx, ast_binstore_delete); @@ -506,7 +506,7 @@ void ast_binstore_delete(ast_binstore *self) mem_d(self); } -ast_unary* ast_unary_new(lex_ctx ctx, int op, +ast_unary* ast_unary_new(lex_ctx_t ctx, int op, ast_expression *expr) { ast_instantiate(ast_unary, ctx, ast_unary_delete); @@ -532,7 +532,7 @@ void ast_unary_delete(ast_unary *self) mem_d(self); } -ast_return* ast_return_new(lex_ctx ctx, ast_expression *expr) +ast_return* ast_return_new(lex_ctx_t ctx, ast_expression *expr) { ast_instantiate(ast_return, ctx, ast_return_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_return_codegen); @@ -553,7 +553,7 @@ void ast_return_delete(ast_return *self) mem_d(self); } -ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expression *field) +ast_entfield* ast_entfield_new(lex_ctx_t ctx, ast_expression *entity, ast_expression *field) { if (field->vtype != TYPE_FIELD) { compile_error(ctx, "ast_entfield_new with expression not of type field"); @@ -562,7 +562,7 @@ ast_entfield* ast_entfield_new(lex_ctx ctx, ast_expression *entity, ast_expressi return ast_entfield_new_force(ctx, entity, field, field->next); } -ast_entfield* ast_entfield_new_force(lex_ctx ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype) +ast_entfield* ast_entfield_new_force(lex_ctx_t ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype) { ast_instantiate(ast_entfield, ctx, ast_entfield_delete); @@ -591,7 +591,7 @@ void ast_entfield_delete(ast_entfield *self) mem_d(self); } -ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int field, const char *name) +ast_member* ast_member_new(lex_ctx_t ctx, ast_expression *owner, unsigned int field, const char *name) { ast_instantiate(ast_member, ctx, ast_member_delete); if (field >= 3) { @@ -653,7 +653,7 @@ bool ast_member_set_name(ast_member *self, const char *name) return !!self->name; } -ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index) +ast_array_index* ast_array_index_new(lex_ctx_t ctx, ast_expression *array, ast_expression *index) { ast_expression *outtype; ast_instantiate(ast_array_index, ctx, ast_array_index_delete); @@ -696,7 +696,7 @@ void ast_array_index_delete(ast_array_index *self) mem_d(self); } -ast_argpipe* ast_argpipe_new(lex_ctx ctx, ast_expression *index) +ast_argpipe* ast_argpipe_new(lex_ctx_t ctx, ast_expression *index) { ast_instantiate(ast_argpipe, ctx, ast_argpipe_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_argpipe_codegen); @@ -713,7 +713,7 @@ void ast_argpipe_delete(ast_argpipe *self) mem_d(self); } -ast_ifthen* ast_ifthen_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) +ast_ifthen* ast_ifthen_new(lex_ctx_t ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { ast_instantiate(ast_ifthen, ctx, ast_ifthen_delete); if (!ontrue && !onfalse) { @@ -746,7 +746,7 @@ void ast_ifthen_delete(ast_ifthen *self) mem_d(self); } -ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) +ast_ternary* ast_ternary_new(lex_ctx_t ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse) { ast_expression *exprtype = ontrue; ast_instantiate(ast_ternary, ctx, ast_ternary_delete); @@ -783,7 +783,7 @@ void ast_ternary_delete(ast_ternary *self) mem_d(self); } -ast_loop* ast_loop_new(lex_ctx ctx, +ast_loop* ast_loop_new(lex_ctx_t ctx, ast_expression *initexpr, ast_expression *precond, bool pre_not, ast_expression *postcond, bool post_not, @@ -832,7 +832,7 @@ void ast_loop_delete(ast_loop *self) mem_d(self); } -ast_breakcont* ast_breakcont_new(lex_ctx ctx, bool iscont, unsigned int levels) +ast_breakcont* ast_breakcont_new(lex_ctx_t ctx, bool iscont, unsigned int levels) { ast_instantiate(ast_breakcont, ctx, ast_breakcont_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_breakcont_codegen); @@ -849,7 +849,7 @@ void ast_breakcont_delete(ast_breakcont *self) mem_d(self); } -ast_switch* ast_switch_new(lex_ctx ctx, ast_expression *op) +ast_switch* ast_switch_new(lex_ctx_t ctx, ast_expression *op) { ast_instantiate(ast_switch, ctx, ast_switch_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_switch_codegen); @@ -878,7 +878,7 @@ void ast_switch_delete(ast_switch *self) mem_d(self); } -ast_label* ast_label_new(lex_ctx ctx, const char *name, bool undefined) +ast_label* ast_label_new(lex_ctx_t ctx, const char *name, bool undefined) { ast_instantiate(ast_label, ctx, ast_label_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_label_codegen); @@ -906,7 +906,7 @@ static void ast_label_register_goto(ast_label *self, ast_goto *g) vec_push(self->gotos, g); } -ast_goto* ast_goto_new(lex_ctx ctx, const char *name) +ast_goto* ast_goto_new(lex_ctx_t ctx, const char *name) { ast_instantiate(ast_goto, ctx, ast_goto_delete); ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_goto_codegen); @@ -930,7 +930,7 @@ void ast_goto_set_label(ast_goto *self, ast_label *label) self->target = label; } -ast_call* ast_call_new(lex_ctx ctx, +ast_call* ast_call_new(lex_ctx_t ctx, ast_expression *funcexpr) { ast_instantiate(ast_call, ctx, ast_call_delete); @@ -1069,7 +1069,7 @@ bool ast_call_check_types(ast_call *self, ast_expression *va_type) return retval; } -ast_store* ast_store_new(lex_ctx ctx, int op, +ast_store* ast_store_new(lex_ctx_t ctx, int op, ast_expression *dest, ast_expression *source) { ast_instantiate(ast_store, ctx, ast_store_delete); @@ -1094,7 +1094,7 @@ void ast_store_delete(ast_store *self) mem_d(self); } -ast_block* ast_block_new(lex_ctx ctx) +ast_block* ast_block_new(lex_ctx_t ctx) { ast_instantiate(ast_block, ctx, ast_block_delete); ast_expression_init((ast_expression*)self, @@ -1148,7 +1148,7 @@ void ast_block_set_type(ast_block *self, ast_expression *from) ast_type_adopt(self, from); } -ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype) +ast_function* ast_function_new(lex_ctx_t ctx, const char *name, ast_value *vtype) { ast_instantiate(ast_function, ctx, ast_function_delete); diff --git a/ast.h b/ast.h index 3df25e8..1f3029f 100644 --- a/ast.h +++ b/ast.h @@ -87,7 +87,7 @@ enum { typedef void ast_node_delete(ast_node*); struct ast_node_common { - lex_ctx context; + lex_ctx_t context; /* I don't feel comfortable using keywords like 'delete' as names... */ ast_node_delete *destroy; int nodetype; @@ -170,7 +170,7 @@ struct ast_expression_common typedef union { double vfloat; int vint; - vector vvec; + vec3_t vvec; const char *vstring; int ventity; ast_function *vfunc; @@ -208,7 +208,7 @@ struct ast_value_s ast_value *getter; }; -ast_value* ast_value_new(lex_ctx ctx, const char *name, int qctype); +ast_value* ast_value_new(lex_ctx_t ctx, const char *name, int qctype); ast_value* ast_value_copy(const ast_value *self); /* This will NOT delete an underlying ast_function */ void ast_value_delete(ast_value*); @@ -225,7 +225,7 @@ bool ast_global_codegen(ast_value *self, ir_builder *ir, bool isfield); void ast_value_params_add(ast_value*, ast_value*); bool ast_compare_type(ast_expression *a, ast_expression *b); -ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex); +ast_expression* ast_type_copy(lex_ctx_t ctx, const ast_expression *ex); #define ast_type_adopt(a, b) ast_type_adopt_impl((ast_expression*)(a), (ast_expression*)(b)) void ast_type_adopt_impl(ast_expression *self, const ast_expression *other); void ast_type_to_string(ast_expression *e, char *buf, size_t bufsize); @@ -252,7 +252,7 @@ struct ast_binary_s ast_binary_ref refs; }; -ast_binary* ast_binary_new(lex_ctx ctx, +ast_binary* ast_binary_new(lex_ctx_t ctx, int op, ast_expression *left, ast_expression *right); @@ -273,7 +273,7 @@ struct ast_binstore_s /* for &~= which uses the destination in a binary in source we can use this */ bool keep_dest; }; -ast_binstore* ast_binstore_new(lex_ctx ctx, +ast_binstore* ast_binstore_new(lex_ctx_t ctx, int storeop, int op, ast_expression *left, @@ -290,7 +290,7 @@ struct ast_unary_s int op; ast_expression *operand; }; -ast_unary* ast_unary_new(lex_ctx ctx, +ast_unary* ast_unary_new(lex_ctx_t ctx, int op, ast_expression *expr); @@ -305,7 +305,7 @@ struct ast_return_s ast_expression expression; ast_expression *operand; }; -ast_return* ast_return_new(lex_ctx ctx, +ast_return* ast_return_new(lex_ctx_t ctx, ast_expression *expr); /* Entity-field @@ -329,8 +329,8 @@ struct ast_entfield_s /* As can the field, it just must result in a value of TYPE_FIELD */ 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); +ast_entfield* ast_entfield_new(lex_ctx_t ctx, ast_expression *entity, ast_expression *field); +ast_entfield* ast_entfield_new_force(lex_ctx_t ctx, ast_expression *entity, ast_expression *field, const ast_expression *outtype); /* Member access: * @@ -345,7 +345,7 @@ struct ast_member_s const char *name; bool rvalue; }; -ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int field, const char *name); +ast_member* ast_member_new(lex_ctx_t ctx, ast_expression *owner, unsigned int field, const char *name); void ast_member_delete(ast_member*); bool ast_member_set_name(ast_member*, const char *name); @@ -366,7 +366,7 @@ struct ast_array_index_s ast_expression *array; ast_expression *index; }; -ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_expression *index); +ast_array_index* ast_array_index_new(lex_ctx_t ctx, ast_expression *array, ast_expression *index); /* Vararg pipe node: * @@ -377,7 +377,7 @@ struct ast_argpipe_s ast_expression expression; ast_expression *index; }; -ast_argpipe* ast_argpipe_new(lex_ctx ctx, ast_expression *index); +ast_argpipe* ast_argpipe_new(lex_ctx_t ctx, ast_expression *index); /* Store * @@ -391,7 +391,7 @@ struct ast_store_s ast_expression *dest; ast_expression *source; }; -ast_store* ast_store_new(lex_ctx ctx, int op, +ast_store* ast_store_new(lex_ctx_t ctx, int op, ast_expression *d, ast_expression *s); /* If @@ -413,7 +413,7 @@ struct ast_ifthen_s ast_expression *on_true; ast_expression *on_false; }; -ast_ifthen* ast_ifthen_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse); +ast_ifthen* ast_ifthen_new(lex_ctx_t ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse); /* Ternary expressions... * @@ -436,7 +436,7 @@ struct ast_ternary_s ast_expression *on_true; ast_expression *on_false; }; -ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse); +ast_ternary* ast_ternary_new(lex_ctx_t ctx, ast_expression *cond, ast_expression *ontrue, ast_expression *onfalse); /* A general loop node * @@ -478,7 +478,7 @@ struct ast_loop_s bool pre_not; bool post_not; }; -ast_loop* ast_loop_new(lex_ctx ctx, +ast_loop* ast_loop_new(lex_ctx_t ctx, ast_expression *initexpr, ast_expression *precond, bool pre_not, ast_expression *postcond, bool post_not, @@ -493,7 +493,7 @@ struct ast_breakcont_s bool is_continue; unsigned int levels; }; -ast_breakcont* ast_breakcont_new(lex_ctx ctx, bool iscont, unsigned int levels); +ast_breakcont* ast_breakcont_new(lex_ctx_t ctx, bool iscont, unsigned int levels); /* Switch Statements * @@ -517,7 +517,7 @@ struct ast_switch_s ast_switch_case *cases; }; -ast_switch* ast_switch_new(lex_ctx ctx, ast_expression *op); +ast_switch* ast_switch_new(lex_ctx_t ctx, ast_expression *op); /* Label nodes * @@ -533,7 +533,7 @@ struct ast_label_s bool undefined; }; -ast_label* ast_label_new(lex_ctx ctx, const char *name, bool undefined); +ast_label* ast_label_new(lex_ctx_t ctx, const char *name, bool undefined); /* GOTO nodes * @@ -547,7 +547,7 @@ struct ast_goto_s ir_block *irblock_from; }; -ast_goto* ast_goto_new(lex_ctx ctx, const char *name); +ast_goto* ast_goto_new(lex_ctx_t ctx, const char *name); void ast_goto_set_label(ast_goto*, ast_label*); /* CALL node @@ -567,7 +567,7 @@ struct ast_call_s ast_expression* *params; ast_expression *va_count; }; -ast_call* ast_call_new(lex_ctx ctx, +ast_call* ast_call_new(lex_ctx_t ctx, ast_expression *funcexpr); bool ast_call_check_types(ast_call*, ast_expression *this_func_va_type); @@ -582,7 +582,7 @@ struct ast_block_s ast_expression* *exprs; ast_expression* *collect; }; -ast_block* ast_block_new(lex_ctx ctx); +ast_block* ast_block_new(lex_ctx_t ctx); void ast_block_delete(ast_block*); void ast_block_set_type(ast_block*, ast_expression *from); void ast_block_collect(ast_block*, ast_expression*); @@ -636,7 +636,7 @@ struct ast_function_s ast_value *fixedparams; ast_value *return_value; }; -ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype); +ast_function* ast_function_new(lex_ctx_t ctx, const char *name, ast_value *vtype); /* This will NOT delete the underlying ast_value */ void ast_function_delete(ast_function*); /* For "optimized" builds this can just keep returning "foo"... diff --git a/code.c b/code.c index 84f6648..a763ee6 100644 --- a/code.c +++ b/code.c @@ -26,7 +26,7 @@ /* * We could use the old method of casting to uintptr_t then to void* - * or qcint; however, it's incredibly unsafe for two reasons. + * or qcint_t; however, it's incredibly unsafe for two reasons. * 1) The compilers aliasing optimization can legally make it unstable * (it's undefined behaviour). * @@ -37,14 +37,14 @@ */ typedef union { void *enter; - qcint leave; + qcint_t leave; } code_hash_entry_t; /* Some sanity macros */ #define CODE_HASH_ENTER(ENTRY) ((ENTRY).enter) #define CODE_HASH_LEAVE(ENTRY) ((ENTRY).leave) -void code_push_statement(code_t *code, prog_section_statement *stmt, int linenum) +void code_push_statement(code_t *code, prog_section_statement_t *stmt, int linenum) { vec_push(code->statements, *stmt); vec_push(code->linenums, linenum); @@ -57,9 +57,9 @@ void code_pop_statement(code_t *code) } code_t *code_init() { - static prog_section_function empty_function = {0,0,0,0,0,0,0,{0,0,0,0,0,0,0,0}}; - static prog_section_statement empty_statement = {0,{0},{0},{0}}; - static prog_section_def empty_def = {0, 0, 0}; + static prog_section_function_t empty_function = {0,0,0,0,0,0,0,{0,0,0,0,0,0,0,0}}; + static prog_section_statement_t empty_statement = {0,{0},{0},{0}}; + static prog_section_def_t empty_def = {0, 0, 0}; code_t *code = (code_t*)mem_a(sizeof(code_t)); int i = 0; @@ -121,25 +121,25 @@ uint32_t code_genstring(code_t *code, const char *str) { return CODE_HASH_LEAVE(existing); } -qcint code_alloc_field (code_t *code, size_t qcsize) +qcint_t code_alloc_field (code_t *code, size_t qcsize) { - qcint pos = (qcint)code->entfields; + qcint_t pos = (qcint_t)code->entfields; code->entfields += qcsize; return pos; } -static void code_create_header(code_t *code, prog_header *code_header) { - code_header->statements.offset = sizeof(prog_header); +static void code_create_header(code_t *code, prog_header_t *code_header) { + code_header->statements.offset = sizeof(prog_header_t); code_header->statements.length = vec_size(code->statements); - code_header->defs.offset = code_header->statements.offset + (sizeof(prog_section_statement) * vec_size(code->statements)); + code_header->defs.offset = code_header->statements.offset + (sizeof(prog_section_statement_t) * vec_size(code->statements)); code_header->defs.length = vec_size(code->defs); - code_header->fields.offset = code_header->defs.offset + (sizeof(prog_section_def) * vec_size(code->defs)); + code_header->fields.offset = code_header->defs.offset + (sizeof(prog_section_def_t) * vec_size(code->defs)); code_header->fields.length = vec_size(code->fields); - code_header->functions.offset = code_header->fields.offset + (sizeof(prog_section_field) * vec_size(code->fields)); + code_header->functions.offset = code_header->fields.offset + (sizeof(prog_section_field_t) * vec_size(code->fields)); code_header->functions.length = vec_size(code->functions); - code_header->globals.offset = code_header->functions.offset + (sizeof(prog_section_function) * vec_size(code->functions)); + code_header->globals.offset = code_header->functions.offset + (sizeof(prog_section_function_t) * vec_size(code->functions)); code_header->globals.length = vec_size(code->globals); - code_header->strings.offset = code_header->globals.offset + (sizeof(int32_t) * vec_size(code->globals)); + code_header->strings.offset = code_header->globals.offset + (sizeof(int32_t) * vec_size(code->globals)); code_header->strings.length = vec_size(code->chars); code_header->version = 6; code_header->skip = 0; @@ -174,10 +174,10 @@ static void code_create_header(code_t *code, prog_header *code_header) { * These are not part of the header but we ensure LE format here to save on duplicated * code. */ - util_endianswap(code->statements, vec_size(code->statements), sizeof(prog_section_statement)); - util_endianswap(code->defs, vec_size(code->defs), sizeof(prog_section_def)); - util_endianswap(code->fields, vec_size(code->fields), sizeof(prog_section_field)); - util_endianswap(code->functions, vec_size(code->functions), sizeof(prog_section_function)); + util_endianswap(code->statements, vec_size(code->statements), sizeof(prog_section_statement_t)); + util_endianswap(code->defs, vec_size(code->defs), sizeof(prog_section_def_t)); + util_endianswap(code->fields, vec_size(code->fields), sizeof(prog_section_field_t)); + util_endianswap(code->functions, vec_size(code->functions), sizeof(prog_section_function_t)); util_endianswap(code->globals, vec_size(code->globals), sizeof(int32_t)); } @@ -187,8 +187,8 @@ static void code_create_header(code_t *code, prog_header *code_header) { * we're going to add. */ bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t **lnomem, size_t *sizelno) { - prog_header code_header; - uint32_t offset = 0; + prog_header_t code_header; + uint32_t offset = 0; if (!datmem) return false; @@ -232,23 +232,23 @@ bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t } /* Write out the dat */ - *sizedat += sizeof(prog_header); - *sizedat += sizeof(prog_section_statement) * vec_size(code->statements); - *sizedat += sizeof(prog_section_def) * vec_size(code->defs); - *sizedat += sizeof(prog_section_field) * vec_size(code->fields); - *sizedat += sizeof(prog_section_function) * vec_size(code->functions); - *sizedat += sizeof(int32_t) * vec_size(code->globals); - *sizedat += 1 * vec_size(code->chars); + *sizedat += sizeof(prog_header_t); + *sizedat += sizeof(prog_section_statement_t) * vec_size(code->statements); + *sizedat += sizeof(prog_section_def_t) * vec_size(code->defs); + *sizedat += sizeof(prog_section_field_t) * vec_size(code->fields); + *sizedat += sizeof(prog_section_function_t) * vec_size(code->functions); + *sizedat += sizeof(int32_t) * vec_size(code->globals); + *sizedat += 1 * vec_size(code->chars); *datmem = (uint8_t*)mem_a(*sizedat); - WRITE_CHUNK(datmem, &code_header, sizeof(prog_header)); - WRITE_CHUNK(datmem, code->statements, sizeof(prog_section_statement) * vec_size(code->statements)); - WRITE_CHUNK(datmem, code->defs, sizeof(prog_section_def) * vec_size(code->defs)); - WRITE_CHUNK(datmem, code->fields, sizeof(prog_section_field) * vec_size(code->fields)); - WRITE_CHUNK(datmem, code->functions, sizeof(prog_section_function) * vec_size(code->functions)); - WRITE_CHUNK(datmem, code->globals, sizeof(int32_t) * vec_size(code->globals)); - WRITE_CHUNK(datmem, code->chars, 1 * vec_size(code->chars)); + WRITE_CHUNK(datmem, &code_header, sizeof(prog_header_t)); + WRITE_CHUNK(datmem, code->statements, sizeof(prog_section_statement_t) * vec_size(code->statements)); + WRITE_CHUNK(datmem, code->defs, sizeof(prog_section_def_t) * vec_size(code->defs)); + WRITE_CHUNK(datmem, code->fields, sizeof(prog_section_field_t) * vec_size(code->fields)); + WRITE_CHUNK(datmem, code->functions, sizeof(prog_section_function_t) * vec_size(code->functions)); + WRITE_CHUNK(datmem, code->globals, sizeof(int32_t) * vec_size(code->globals)); + WRITE_CHUNK(datmem, code->chars, 1 * vec_size(code->chars)); #undef WRITE_CHUNK @@ -267,9 +267,9 @@ bool code_write_memory(code_t *code, uint8_t **datmem, size_t *sizedat, uint8_t } bool code_write(code_t *code, const char *filename, const char *lnofile) { - prog_header code_header; - FILE *fp = NULL; - size_t it = 2; + prog_header_t code_header; + FILE *fp = NULL; + size_t it = 2; code_create_header(code, &code_header); @@ -303,13 +303,13 @@ bool code_write(code_t *code, const char *filename, const char *lnofile) { if (!fp) return false; - if (1 != fs_file_write(&code_header, sizeof(prog_header) , 1 , fp) || - vec_size(code->statements) != fs_file_write(code->statements, sizeof(prog_section_statement), vec_size(code->statements), fp) || - vec_size(code->defs) != fs_file_write(code->defs, sizeof(prog_section_def) , vec_size(code->defs) , fp) || - vec_size(code->fields) != fs_file_write(code->fields, sizeof(prog_section_field) , vec_size(code->fields) , fp) || - vec_size(code->functions) != fs_file_write(code->functions, sizeof(prog_section_function) , vec_size(code->functions) , fp) || - vec_size(code->globals) != fs_file_write(code->globals, sizeof(int32_t) , vec_size(code->globals) , fp) || - vec_size(code->chars) != fs_file_write(code->chars, 1 , vec_size(code->chars) , fp)) + if (1 != fs_file_write(&code_header, sizeof(prog_header_t) , 1 , fp) || + vec_size(code->statements) != fs_file_write(code->statements, sizeof(prog_section_statement_t), vec_size(code->statements), fp) || + vec_size(code->defs) != fs_file_write(code->defs, sizeof(prog_section_def_t) , vec_size(code->defs) , fp) || + vec_size(code->fields) != fs_file_write(code->fields, sizeof(prog_section_field_t) , vec_size(code->fields) , fp) || + vec_size(code->functions) != fs_file_write(code->functions, sizeof(prog_section_function_t) , vec_size(code->functions) , fp) || + vec_size(code->globals) != fs_file_write(code->globals, sizeof(int32_t) , vec_size(code->globals) , fp) || + vec_size(code->chars) != fs_file_write(code->chars, 1 , vec_size(code->chars) , fp)) { fs_file_close(fp); return false; diff --git a/conout.c b/conout.c index 2f1eb9e..93c1ff8 100644 --- a/conout.c +++ b/conout.c @@ -369,11 +369,11 @@ void con_printmsg(int level, const char *name, size_t line, size_t column, const va_end (va); } -void con_cvprintmsg(void *ctx, int lvl, const char *msgtype, const char *msg, va_list ap) { - con_vprintmsg(lvl, ((lex_ctx*)ctx)->file, ((lex_ctx*)ctx)->line, ((lex_ctx*)ctx)->column, msgtype, msg, ap); +void con_cvprintmsg(lex_ctx_t ctx, int lvl, const char *msgtype, const char *msg, va_list ap) { + con_vprintmsg(lvl, ctx.file, ctx.line, ctx.column, msgtype, msg, ap); } -void con_cprintmsg (void *ctx, int lvl, const char *msgtype, const char *msg, ...) { +void con_cprintmsg(lex_ctx_t ctx, int lvl, const char *msgtype, const char *msg, ...) { va_list va; va_start(va, msg); con_cvprintmsg(ctx, lvl, msgtype, msg, va); @@ -381,24 +381,23 @@ void con_cprintmsg (void *ctx, int lvl, const char *msgtype, const char *msg, .. } /* General error interface */ -size_t compile_errors = 0; +size_t compile_errors = 0; size_t compile_warnings = 0; - -size_t compile_Werrors = 0; -static lex_ctx first_werror; +size_t compile_Werrors = 0; +static lex_ctx_t first_werror; void compile_show_werrors() { - con_cprintmsg((void*)&first_werror, LVL_ERROR, "first warning", "was here"); + con_cprintmsg(first_werror, LVL_ERROR, "first warning", "was here"); } -void vcompile_error(lex_ctx ctx, const char *msg, va_list ap) +void vcompile_error(lex_ctx_t ctx, const char *msg, va_list ap) { ++compile_errors; - con_cvprintmsg((void*)&ctx, LVL_ERROR, "error", msg, ap); + con_cvprintmsg(ctx, LVL_ERROR, "error", msg, ap); } -void compile_error(lex_ctx ctx, const char *msg, ...) +void compile_error(lex_ctx_t ctx, const char *msg, ...) { va_list ap; va_start(ap, msg); @@ -406,7 +405,7 @@ void compile_error(lex_ctx ctx, const char *msg, ...) va_end(ap); } -bool GMQCC_WARN vcompile_warning(lex_ctx ctx, int warntype, const char *fmt, va_list ap) +bool GMQCC_WARN vcompile_warning(lex_ctx_t ctx, int warntype, const char *fmt, va_list ap) { const char *msgtype = "warning"; int lvl = LVL_WARNING; @@ -437,7 +436,7 @@ bool GMQCC_WARN vcompile_warning(lex_ctx ctx, int warntype, const char *fmt, va_ return OPTS_WERROR(warntype) && OPTS_FLAG(BAIL_ON_WERROR); } -bool GMQCC_WARN compile_warning(lex_ctx ctx, int warntype, const char *fmt, ...) +bool GMQCC_WARN compile_warning(lex_ctx_t ctx, int warntype, const char *fmt, ...) { bool r; va_list ap; diff --git a/exec.c b/exec.c index fad760a..16e5ded 100644 --- a/exec.c +++ b/exec.c @@ -40,7 +40,7 @@ static void loaderror(const char *fmt, ...) printf(": %s\n", util_strerror(err)); } -static void qcvmerror(qc_program *prog, const char *fmt, ...) +static void qcvmerror(qc_program_t *prog, const char *fmt, ...) { va_list ap; @@ -52,10 +52,10 @@ static void qcvmerror(qc_program *prog, const char *fmt, ...) putchar('\n'); } -qc_program* prog_load(const char *filename, bool skipversion) +qc_program_t* prog_load(const char *filename, bool skipversion) { - qc_program *prog; - prog_header header; + qc_program_t *prog; + prog_header_t header; FILE *file = fs_file_open(filename, "rb"); if (!file) @@ -73,7 +73,7 @@ qc_program* prog_load(const char *filename, bool skipversion) return NULL; } - prog = (qc_program*)mem_a(sizeof(qc_program)); + prog = (qc_program_t*)mem_a(sizeof(qc_program_t)); if (!prog) { fs_file_close(file); fprintf(stderr, "failed to allocate program data\n"); @@ -149,7 +149,7 @@ error: return NULL; } -void prog_delete(qc_program *prog) +void prog_delete(qc_program_t *prog) { if (prog->filename) mem_d(prog->filename); vec_free(prog->code); @@ -170,15 +170,15 @@ void prog_delete(qc_program *prog) * VM code */ -const char* prog_getstring(qc_program *prog, qcint str) { +const char* prog_getstring(qc_program_t *prog, qcint_t str) { /* cast for return required for C++ */ - if (str < 0 || str >= (qcint)vec_size(prog->strings)) + if (str < 0 || str >= (qcint_t)vec_size(prog->strings)) return "<<>>"; return prog->strings + str; } -prog_section_def* prog_entfield(qc_program *prog, qcint off) { +prog_section_def_t* prog_entfield(qc_program_t *prog, qcint_t off) { size_t i; for (i = 0; i < vec_size(prog->fields); ++i) { if (prog->fields[i].offset == off) @@ -187,7 +187,7 @@ prog_section_def* prog_entfield(qc_program *prog, qcint off) { return NULL; } -prog_section_def* prog_getdef(qc_program *prog, qcint off) +prog_section_def_t* prog_getdef(qc_program_t *prog, qcint_t off) { size_t i; for (i = 0; i < vec_size(prog->defs); ++i) { @@ -197,39 +197,39 @@ prog_section_def* prog_getdef(qc_program *prog, qcint off) return NULL; } -qcany* prog_getedict(qc_program *prog, qcint e) { - if (e >= (qcint)vec_size(prog->entitypool)) { +qcany_t* prog_getedict(qc_program_t *prog, qcint_t e) { + if (e >= (qcint_t)vec_size(prog->entitypool)) { prog->vmerror++; fprintf(stderr, "Accessing out of bounds edict %i\n", (int)e); e = 0; } - return (qcany*)(prog->entitydata + (prog->entityfields * e)); + return (qcany_t*)(prog->entitydata + (prog->entityfields * e)); } -qcint prog_spawn_entity(qc_program *prog) { +qcint_t prog_spawn_entity(qc_program_t *prog) { char *data; - qcint e; - for (e = 0; e < (qcint)vec_size(prog->entitypool); ++e) { + qcint_t e; + for (e = 0; e < (qcint_t)vec_size(prog->entitypool); ++e) { if (!prog->entitypool[e]) { data = (char*)(prog->entitydata + (prog->entityfields * e)); - memset(data, 0, prog->entityfields * sizeof(qcint)); + memset(data, 0, prog->entityfields * sizeof(qcint_t)); return e; } } vec_push(prog->entitypool, true); prog->entities++; data = (char*)vec_add(prog->entitydata, prog->entityfields); - memset(data, 0, prog->entityfields * sizeof(qcint)); + memset(data, 0, prog->entityfields * sizeof(qcint_t)); return e; } -void prog_free_entity(qc_program *prog, qcint e) { +void prog_free_entity(qc_program_t *prog, qcint_t e) { if (!e) { prog->vmerror++; fprintf(stderr, "Trying to free world entity\n"); return; } - if (e >= (qcint)vec_size(prog->entitypool)) { + if (e >= (qcint_t)vec_size(prog->entitypool)) { prog->vmerror++; fprintf(stderr, "Trying to free out of bounds entity\n"); return; @@ -242,7 +242,7 @@ void prog_free_entity(qc_program *prog, qcint e) { prog->entitypool[e] = false; } -qcint prog_tempstring(qc_program *prog, const char *str) { +qcint_t prog_tempstring(qc_program_t *prog, const char *str) { size_t len = strlen(str); size_t at = prog->tempstring_at; @@ -297,10 +297,10 @@ static size_t print_escaped_string(const char *str, size_t maxlen) { return len; } -static void trace_print_global(qc_program *prog, unsigned int glob, int vtype) { +static void trace_print_global(qc_program_t *prog, unsigned int glob, int vtype) { static char spaces[28+1] = " "; - prog_section_def *def; - qcany *value; + prog_section_def_t *def; + qcany_t *value; int len; if (!glob) { @@ -311,7 +311,7 @@ static void trace_print_global(qc_program *prog, unsigned int glob, int vtype) { } def = prog_getdef(prog, glob); - value = (qcany*)(&prog->globals[glob]); + value = (qcany_t*)(&prog->globals[glob]); len = printf("[@%u] ", glob); if (def) { @@ -357,7 +357,7 @@ done: } } -static void prog_print_statement(qc_program *prog, prog_section_statement *st) { +static void prog_print_statement(qc_program_t *prog, prog_section_statement_t *st) { if (st->opcode >= VINSTR_END) { printf("\n", st->opcode); return; @@ -454,8 +454,8 @@ static void prog_print_statement(qc_program *prog, prog_section_statement *st) { } } -static qcint prog_enterfunction(qc_program *prog, prog_section_function *func) { - qc_exec_stack st; +static qcint_t prog_enterfunction(qc_program_t *prog, prog_section_function_t *func) { + qc_exec_stack_t st; size_t parampos; int32_t p; @@ -472,17 +472,17 @@ static qcint prog_enterfunction(qc_program *prog, prog_section_function *func) { #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS if (vec_size(prog->stack)) { - prog_section_function *cur; + prog_section_function_t *cur; cur = prog->stack[vec_size(prog->stack)-1].function; if (cur) { - qcint *globals = prog->globals + cur->firstlocal; + qcint_t *globals = prog->globals + cur->firstlocal; vec_append(prog->localstack, cur->locals, globals); } } #else { - qcint *globals = prog->globals + func->firstlocal; + qcint_t *globals = prog->globals + func->firstlocal; vec_append(prog->localstack, func->locals, globals); } #endif @@ -503,11 +503,11 @@ static qcint prog_enterfunction(qc_program *prog, prog_section_function *func) { return func->entry; } -static qcint prog_leavefunction(qc_program *prog) { - prog_section_function *prev = NULL; +static qcint_t prog_leavefunction(qc_program_t *prog) { + prog_section_function_t *prev = NULL; size_t oldsp; - qc_exec_stack st = vec_last(prog->stack); + qc_exec_stack_t st = vec_last(prog->stack); if (prog->xflags & VMXF_TRACE) { if (vec_size(prog->function_stack)) @@ -524,7 +524,7 @@ static qcint prog_leavefunction(qc_program *prog) { oldsp = prog->stack[vec_size(prog->stack)-1].localsp; #endif if (prev) { - qcint *globals = prog->globals + prev->firstlocal; + qcint_t *globals = prog->globals + prev->firstlocal; memcpy(globals, prog->localstack + oldsp, prev->locals * sizeof(prog->localstack[0])); /* vec_remove(prog->localstack, oldsp, vec_size(prog->localstack)-oldsp); */ vec_shrinkto(prog->localstack, oldsp); @@ -535,10 +535,10 @@ static qcint prog_leavefunction(qc_program *prog) { return st.stmt - 1; /* offset the ++st */ } -bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps) { +bool prog_exec(qc_program_t *prog, prog_section_function_t *func, size_t flags, long maxjumps) { long jumpcount = 0; size_t oldxflags = prog->xflags; - prog_section_statement *st; + prog_section_statement_t *st; prog->vmerror = 0; prog->xflags = flags; @@ -630,15 +630,15 @@ static qcvm_parameter *main_params = NULL; } \ } while (0) -#define GetGlobal(idx) ((qcany*)(prog->globals + (idx))) +#define GetGlobal(idx) ((qcany_t*)(prog->globals + (idx))) #define GetArg(num) GetGlobal(OFS_PARM0 + 3*(num)) #define Return(any) *(GetGlobal(OFS_RETURN)) = (any) -static int qc_print(qc_program *prog) { +static int qc_print(qc_program_t *prog) { size_t i; const char *laststr = NULL; for (i = 0; i < (size_t)prog->argc; ++i) { - qcany *str = (qcany*)(prog->globals + OFS_PARM0 + 3*i); + qcany_t *str = (qcany_t*)(prog->globals + OFS_PARM0 + 3*i); laststr = prog_getstring(prog, str->string); printf("%s", laststr); } @@ -650,17 +650,17 @@ static int qc_print(qc_program *prog) { return 0; } -static int qc_error(qc_program *prog) { +static int qc_error(qc_program_t *prog) { fprintf(stderr, "*** VM raised an error:\n"); qc_print(prog); prog->vmerror++; return -1; } -static int qc_ftos(qc_program *prog) { +static int qc_ftos(qc_program_t *prog) { char buffer[512]; - qcany *num; - qcany str; + qcany_t *num; + qcany_t str; CheckArgs(1); num = GetArg(0); util_snprintf(buffer, sizeof(buffer), "%g", num->_float); @@ -669,9 +669,9 @@ static int qc_ftos(qc_program *prog) { return 0; } -static int qc_stof(qc_program *prog) { - qcany *str; - qcany num; +static int qc_stof(qc_program_t *prog) { + qcany_t *str; + qcany_t num; CheckArgs(1); str = GetArg(0); num._float = (float)strtod(prog_getstring(prog, str->string), NULL); @@ -679,10 +679,10 @@ static int qc_stof(qc_program *prog) { return 0; } -static int qc_vtos(qc_program *prog) { +static int qc_vtos(qc_program_t *prog) { char buffer[512]; - qcany *num; - qcany str; + qcany_t *num; + qcany_t str; CheckArgs(1); num = GetArg(0); util_snprintf(buffer, sizeof(buffer), "'%g %g %g'", num->vector[0], num->vector[1], num->vector[2]); @@ -691,10 +691,10 @@ static int qc_vtos(qc_program *prog) { return 0; } -static int qc_etos(qc_program *prog) { +static int qc_etos(qc_program_t *prog) { char buffer[512]; - qcany *num; - qcany str; + qcany_t *num; + qcany_t str; CheckArgs(1); num = GetArg(0); util_snprintf(buffer, sizeof(buffer), "%i", num->_int); @@ -703,24 +703,24 @@ static int qc_etos(qc_program *prog) { return 0; } -static int qc_spawn(qc_program *prog) { - qcany ent; +static int qc_spawn(qc_program_t *prog) { + qcany_t ent; CheckArgs(0); ent.edict = prog_spawn_entity(prog); Return(ent); return (ent.edict ? 0 : -1); } -static int qc_kill(qc_program *prog) { - qcany *ent; +static int qc_kill(qc_program_t *prog) { + qcany_t *ent; CheckArgs(1); ent = GetArg(0); prog_free_entity(prog, ent->edict); return 0; } -static int qc_sqrt(qc_program *prog) { - qcany *num, out; +static int qc_sqrt(qc_program_t *prog) { + qcany_t *num, out; CheckArgs(1); num = GetArg(0); out._float = sqrt(num->_float); @@ -728,8 +728,8 @@ static int qc_sqrt(qc_program *prog) { return 0; } -static int qc_vlen(qc_program *prog) { - qcany *vec, len; +static int qc_vlen(qc_program_t *prog) { + qcany_t *vec, len; CheckArgs(1); vec = GetArg(0); len._float = sqrt(vec->vector[0] * vec->vector[0] + @@ -739,10 +739,10 @@ static int qc_vlen(qc_program *prog) { return 0; } -static int qc_normalize(qc_program *prog) { +static int qc_normalize(qc_program_t *prog) { double len; - qcany *vec; - qcany out; + qcany_t *vec; + qcany_t out; CheckArgs(1); vec = GetArg(0); len = sqrt(vec->vector[0] * vec->vector[0] + @@ -759,11 +759,11 @@ static int qc_normalize(qc_program *prog) { return 0; } -static int qc_strcat(qc_program *prog) { +static int qc_strcat(qc_program_t *prog) { char *buffer; size_t len1, len2; - qcany *str1, *str2; - qcany out; + qcany_t *str1, *str2; + qcany_t out; const char *cstr1; const char *cstr2; @@ -784,9 +784,9 @@ static int qc_strcat(qc_program *prog) { return 0; } -static int qc_strcmp(qc_program *prog) { - qcany *str1, *str2; - qcany out; +static int qc_strcmp(qc_program_t *prog) { + qcany_t *str1, *str2; + qcany_t out; const char *cstr1; const char *cstr2; @@ -809,8 +809,8 @@ static int qc_strcmp(qc_program *prog) { return 0; } -static int qc_floor(qc_program *prog) { - qcany *num, out; +static int qc_floor(qc_program_t *prog) { + qcany_t *num, out; CheckArgs(1); num = GetArg(0); out._float = floor(num->_float); @@ -818,7 +818,7 @@ static int qc_floor(qc_program *prog) { return 0; } -static prog_builtin qc_builtins[] = { +static prog_builtin_t qc_builtins[] = { NULL, &qc_print, /* 1 */ &qc_ftos, /* 2 */ @@ -869,9 +869,9 @@ static void usage(void) { " -string pass a string parameter to main() \n"); } -static void prog_main_setparams(qc_program *prog) { +static void prog_main_setparams(qc_program_t *prog) { size_t i; - qcany *arg; + qcany_t *arg; for (i = 0; i < vec_size(main_params); ++i) { arg = GetGlobal(OFS_PARM0 + 3*i); @@ -931,12 +931,12 @@ void escapestring(char* dest, const char* src) { *dest = '\0'; } -void prog_disasm_function(qc_program *prog, size_t id); +void prog_disasm_function(qc_program_t *prog, size_t id); int main(int argc, char **argv) { size_t i; - qcint fnmain = -1; - qc_program *prog; + qcint_t fnmain = -1; + qc_program_t *prog; size_t xflags = VMXF_DEFAULT; bool opts_printfields = false; bool opts_printdefs = false; @@ -1159,19 +1159,19 @@ int main(int argc, char **argv) { if (opts_v) { switch (prog->defs[i].type & DEF_TYPEMASK) { case TYPE_FLOAT: - printf(" [init: %g]", ((qcany*)(prog->globals + prog->defs[i].offset))->_float); + printf(" [init: %g]", ((qcany_t*)(prog->globals + prog->defs[i].offset))->_float); break; case TYPE_INTEGER: - printf(" [init: %i]", (int)( ((qcany*)(prog->globals + prog->defs[i].offset))->_int )); + printf(" [init: %i]", (int)( ((qcany_t*)(prog->globals + prog->defs[i].offset))->_int )); break; case TYPE_ENTITY: case TYPE_FUNCTION: case TYPE_FIELD: case TYPE_POINTER: - printf(" [init: %u]", (unsigned)( ((qcany*)(prog->globals + prog->defs[i].offset))->_int )); + printf(" [init: %u]", (unsigned)( ((qcany_t*)(prog->globals + prog->defs[i].offset))->_int )); break; case TYPE_STRING: - getstring = prog_getstring(prog, ((qcany*)(prog->globals + prog->defs[i].offset))->string); + getstring = prog_getstring(prog, ((qcany_t*)(prog->globals + prog->defs[i].offset))->string); escape = (char*)mem_a(strlen(getstring) * 2 + 1); /* will be enough */ escapestring(escape, getstring); printf(" [init: `%s`]", escape); @@ -1209,7 +1209,7 @@ int main(int argc, char **argv) { printf(") builtin %i\n", (int)-start); else { size_t funsize = 0; - prog_section_statement *st = prog->code + start; + prog_section_statement_t *st = prog->code + start; for (;st->opcode != INSTR_DONE; ++st) ++funsize; printf(") - %lu instructions", (unsigned long)funsize); @@ -1235,7 +1235,7 @@ int main(int argc, char **argv) { for (i = 1; i < vec_size(prog->functions); ++i) { const char *name = prog_getstring(prog, prog->functions[i].name); if (!strcmp(name, "main")) - fnmain = (qcint)i; + fnmain = (qcint_t)i; } if (fnmain > 0) { @@ -1250,9 +1250,9 @@ int main(int argc, char **argv) { return 0; } -void prog_disasm_function(qc_program *prog, size_t id) { - prog_section_function *fdef = prog->functions + id; - prog_section_statement *st; +void prog_disasm_function(qc_program_t *prog, size_t id) { + prog_section_function_t *fdef = prog->functions + id; + prog_section_statement_t *st; if (fdef->entry < 0) { printf("FUNCTION \"%s\" = builtin #%i\n", prog_getstring(prog, fdef->name), (int)-fdef->entry); @@ -1277,11 +1277,11 @@ void prog_disasm_function(qc_program *prog, size_t id) { * sort of isn't, which makes it nicer looking. */ -#define OPA ( (qcany*) (prog->globals + st->o1.u1) ) -#define OPB ( (qcany*) (prog->globals + st->o2.u1) ) -#define OPC ( (qcany*) (prog->globals + st->o3.u1) ) +#define OPA ( (qcany_t*) (prog->globals + st->o1.u1) ) +#define OPB ( (qcany_t*) (prog->globals + st->o2.u1) ) +#define OPC ( (qcany_t*) (prog->globals + st->o3.u1) ) -#define GLOBAL(x) ( (qcany*) (prog->globals + (x)) ) +#define GLOBAL(x) ( (qcany_t*) (prog->globals + (x)) ) /* to be consistent with current darkplaces behaviour */ #if !defined(FLOAT_IS_TRUE_FOR_INT) @@ -1289,9 +1289,9 @@ void prog_disasm_function(qc_program *prog, size_t id) { #endif while (1) { - prog_section_function *newf; - qcany *ed; - qcany *ptr; + prog_section_function_t *newf; + qcany_t *ed; + qcany_t *ptr; ++st; @@ -1332,7 +1332,7 @@ while (1) { break; case INSTR_MUL_FV: { - qcfloat f = OPA->_float; + qcfloat_t f = OPA->_float; OPC->vector[0] = f * OPB->vector[0]; OPC->vector[1] = f * OPB->vector[1]; OPC->vector[2] = f * OPB->vector[2]; @@ -1340,7 +1340,7 @@ while (1) { } case INSTR_MUL_VF: { - qcfloat f = OPB->_float; + qcfloat_t f = OPB->_float; OPC->vector[0] = f * OPA->vector[0]; OPC->vector[1] = f * OPA->vector[1]; OPC->vector[2] = f * OPA->vector[2]; @@ -1436,14 +1436,14 @@ while (1) { goto cleanup; } ed = prog_getedict(prog, OPA->edict); - OPC->_int = ((qcany*)( ((qcint*)ed) + OPB->_int ))->_int; + OPC->_int = ((qcany_t*)( ((qcint_t*)ed) + OPB->_int ))->_int; break; case INSTR_LOAD_V: if (OPA->edict < 0 || OPA->edict >= prog->entities) { qcvmerror(prog, "progs `%s` attempted to read an out of bounds entity", prog->filename); goto cleanup; } - if (OPB->_int < 0 || OPB->_int + 3 > (qcint)prog->entityfields) + if (OPB->_int < 0 || OPB->_int + 3 > (qcint_t)prog->entityfields) { qcvmerror(prog, "prog `%s` attempted to read an invalid field from entity (%i)", prog->filename, @@ -1451,7 +1451,7 @@ while (1) { goto cleanup; } ed = prog_getedict(prog, OPA->edict); - ptr = (qcany*)( ((qcint*)ed) + OPB->_int ); + ptr = (qcany_t*)( ((qcint_t*)ed) + OPB->_int ); OPC->ivector[0] = ptr->ivector[0]; OPC->ivector[1] = ptr->ivector[1]; OPC->ivector[2] = ptr->ivector[2]; @@ -1471,7 +1471,7 @@ while (1) { } ed = prog_getedict(prog, OPA->edict); - OPC->_int = ((qcint*)ed) - prog->entitydata + OPB->_int; + OPC->_int = ((qcint_t*)ed) - prog->entitydata + OPB->_int; break; case INSTR_STORE_F: @@ -1492,29 +1492,29 @@ while (1) { case INSTR_STOREP_ENT: case INSTR_STOREP_FLD: case INSTR_STOREP_FNC: - if (OPB->_int < 0 || OPB->_int >= (qcint)vec_size(prog->entitydata)) { + if (OPB->_int < 0 || OPB->_int >= (qcint_t)vec_size(prog->entitydata)) { qcvmerror(prog, "`%s` attempted to write to an out of bounds edict (%i)", prog->filename, OPB->_int); goto cleanup; } - if (OPB->_int < (qcint)prog->entityfields && !prog->allowworldwrites) + if (OPB->_int < (qcint_t)prog->entityfields && !prog->allowworldwrites) qcvmerror(prog, "`%s` tried to assign to world.%s (field %i)\n", prog->filename, prog_getstring(prog, prog_entfield(prog, OPB->_int)->name), OPB->_int); - ptr = (qcany*)(prog->entitydata + OPB->_int); + ptr = (qcany_t*)(prog->entitydata + OPB->_int); ptr->_int = OPA->_int; break; case INSTR_STOREP_V: - if (OPB->_int < 0 || OPB->_int + 2 >= (qcint)vec_size(prog->entitydata)) { + if (OPB->_int < 0 || OPB->_int + 2 >= (qcint_t)vec_size(prog->entitydata)) { qcvmerror(prog, "`%s` attempted to write to an out of bounds edict (%i)", prog->filename, OPB->_int); goto cleanup; } - if (OPB->_int < (qcint)prog->entityfields && !prog->allowworldwrites) + if (OPB->_int < (qcint_t)prog->entityfields && !prog->allowworldwrites) qcvmerror(prog, "`%s` tried to assign to world.%s (field %i)\n", prog->filename, prog_getstring(prog, prog_entfield(prog, OPB->_int)->name), OPB->_int); - ptr = (qcany*)(prog->entitydata + OPB->_int); + ptr = (qcany_t*)(prog->entitydata + OPB->_int); ptr->ivector[0] = OPA->ivector[0]; ptr->ivector[1] = OPA->ivector[1]; ptr->ivector[2] = OPA->ivector[2]; @@ -1570,7 +1570,7 @@ while (1) { if (!OPA->function) qcvmerror(prog, "NULL function in `%s`", prog->filename); - if(!OPA->function || OPA->function >= (qcint)vec_size(prog->functions)) + if(!OPA->function || OPA->function >= (qcint_t)vec_size(prog->functions)) { qcvmerror(prog, "CALL outside the program in `%s`", prog->filename); goto cleanup; @@ -1584,8 +1584,8 @@ while (1) { if (newf->entry < 0) { /* negative statements are built in functions */ - qcint builtinnumber = -newf->entry; - if (builtinnumber < (qcint)prog->builtins_count && prog->builtins[builtinnumber]) + qcint_t builtinnumber = -newf->entry; + if (builtinnumber < (qcint_t)prog->builtins_count && prog->builtins[builtinnumber]) prog->builtins[builtinnumber](prog); else qcvmerror(prog, "No such builtin #%i in %s! Try updating your gmqcc sources", diff --git a/ftepp.c b/ftepp.c index d68eed4..3f45bc2 100644 --- a/ftepp.c +++ b/ftepp.c @@ -41,7 +41,7 @@ typedef struct { char *value; /* a copy from the lexer */ union { - vector v; + vec3_t v; int i; double f; int t; /* type */ @@ -49,7 +49,7 @@ typedef struct { } pptoken; typedef struct { - lex_ctx ctx; + lex_ctx_t ctx; char *name; char **params; @@ -239,14 +239,14 @@ static GMQCC_INLINE char *(*ftepp_predef(const char *name))(lex_file *context) { #define ftepp_tokval(f) ((f)->lex->tok.value) #define ftepp_ctx(f) ((f)->lex->tok.ctx) -static void ftepp_errorat(ftepp_t *ftepp, lex_ctx ctx, const char *fmt, ...) +static void ftepp_errorat(ftepp_t *ftepp, lex_ctx_t ctx, const char *fmt, ...) { va_list ap; ftepp->errors++; va_start(ap, fmt); - con_cvprintmsg((void*)&ctx, LVL_ERROR, "error", fmt, ap); + con_cvprintmsg(ctx, LVL_ERROR, "error", fmt, ap); va_end(ap); } @@ -257,7 +257,7 @@ static void ftepp_error(ftepp_t *ftepp, const char *fmt, ...) ftepp->errors++; va_start(ap, fmt); - con_cvprintmsg((void*)&ftepp->lex->tok.ctx, LVL_ERROR, "error", fmt, ap); + con_cvprintmsg(ftepp->lex->tok.ctx, LVL_ERROR, "error", fmt, ap); va_end(ap); } @@ -293,7 +293,7 @@ static GMQCC_INLINE void pptoken_delete(pptoken *self) mem_d(self); } -static ppmacro *ppmacro_new(lex_ctx ctx, const char *name) +static ppmacro *ppmacro_new(lex_ctx_t ctx, const char *name) { ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro)); @@ -1406,7 +1406,7 @@ static void ftepp_directive_message(ftepp_t *ftepp) { } vec_push(message, '\0'); if (ftepp->output_on) - con_cprintmsg(&ftepp->lex->tok.ctx, LVL_MSG, "message", message); + con_cprintmsg(ftepp->lex->tok.ctx, LVL_MSG, "message", message); vec_free(message); return; } @@ -1415,7 +1415,7 @@ static void ftepp_directive_message(ftepp_t *ftepp) { return; unescape (ftepp_tokval(ftepp), ftepp_tokval(ftepp)); - con_cprintmsg(&ftepp->lex->tok.ctx, LVL_MSG, "message", ftepp_tokval(ftepp)); + con_cprintmsg(ftepp->lex->tok.ctx, LVL_MSG, "message", ftepp_tokval(ftepp)); } /** @@ -1427,7 +1427,7 @@ static bool ftepp_include(ftepp_t *ftepp) { lex_file *old_lexer = ftepp->lex; lex_file *inlex; - lex_ctx ctx; + lex_ctx_t ctx; char lineno[128]; char *filename; char *old_includename; @@ -1517,7 +1517,7 @@ static bool ftepp_hash(ftepp_t *ftepp) ppcondition cond; ppcondition *pc; - lex_ctx ctx = ftepp_ctx(ftepp); + lex_ctx_t ctx = ftepp_ctx(ftepp); if (!ftepp_skipspace(ftepp)) return false; @@ -1878,7 +1878,7 @@ ftepp_t *ftepp_create() void ftepp_add_define(ftepp_t *ftepp, const char *source, const char *name) { ppmacro *macro; - lex_ctx ctx = { "__builtin__", 0, 0 }; + lex_ctx_t ctx = { "__builtin__", 0, 0 }; ctx.file = source; macro = ppmacro_new(ctx, name); /*vec_push(ftepp->macros, macro);*/ diff --git a/gmqcc.h b/gmqcc.h index 4595be9..2ab3a00 100644 --- a/gmqcc.h +++ b/gmqcc.h @@ -382,14 +382,14 @@ void _util_vec_grow(void **a, size_t i, size_t s); #define vec_upload(X,Y,S) ((void)(memcpy(vec_add((X), (S) * sizeof(*(Y))), (Y), (S) * sizeof(*(Y))))) #define vec_remove(A,I,N) ((void)(memmove((A)+(I),(A)+((I)+(N)),sizeof(*(A))*(vec_meta(A)->used-(I)-(N))),vec_meta(A)->used-=(N))) -typedef struct trie_s { - void *value; - struct trie_s *entries; +typedef struct correct_trie_s { + void *value; + struct correct_trie_s *entries; } correct_trie_t; correct_trie_t* correct_trie_new(void); -typedef struct hash_table_t { +typedef struct hash_table_s { size_t size; struct hash_node_t **table; } hash_table_t, *ht; @@ -525,21 +525,21 @@ extern const uint16_t type_not_instr [TYPE_COUNT]; typedef struct { uint32_t offset; /* Offset in file of where data begins */ uint32_t length; /* Length of section (how many of) */ -} prog_section; +} prog_section_t; typedef struct { - uint32_t version; /* Program version (6) */ - uint16_t crc16; - uint16_t skip; + uint32_t version; /* Program version (6) */ + uint16_t crc16; + uint16_t skip; - prog_section statements; /* prog_section_statement */ - prog_section defs; /* prog_section_def */ - prog_section fields; /* prog_section_field */ - prog_section functions; /* prog_section_function */ - prog_section strings; - prog_section globals; - uint32_t entfield; /* Number of entity fields */ -} prog_header; + prog_section_t statements; /* prog_section_statement */ + prog_section_t defs; /* prog_section_def */ + prog_section_t fields; /* prog_section_field */ + prog_section_t functions; /* prog_section_function */ + prog_section_t strings; + prog_section_t globals; + uint32_t entfield; /* Number of entity fields */ +} prog_header_t; /* * Each paramater incerements by 3 since vector types hold @@ -584,7 +584,7 @@ typedef struct { * But this one is more sane to work with, and the * type sizes are guranteed. */ -} prog_section_statement; +} prog_section_statement_t; typedef struct { /* @@ -602,10 +602,10 @@ typedef struct { uint16_t type; uint16_t offset; uint32_t name; -} prog_section_both; +} prog_section_both_t; -typedef prog_section_both prog_section_def; -typedef prog_section_both prog_section_field; +typedef prog_section_both_t prog_section_def_t; +typedef prog_section_both_t prog_section_field_t; /* this is ORed to the type */ #define DEF_SAVEGLOBAL (1<<15) @@ -620,7 +620,7 @@ typedef struct { uint32_t file; /* file of the source file */ int32_t nargs; /* number of arguments */ uint8_t argsize[8]; /* size of arguments (keep 8 always?) */ -} prog_section_function; +} prog_section_function_t; /* * Instructions @@ -713,22 +713,22 @@ enum { /* TODO: elide */ extern const char *util_instr_str[VINSTR_END]; -/* uhh? */ -typedef float qcfloat; -typedef int32_t qcint; +/* TOO: _t */ +typedef float qcfloat_t; +typedef int32_t qcint_t; typedef struct { - prog_section_statement *statements; - int *linenums; - prog_section_def *defs; - prog_section_field *fields; - prog_section_function *functions; - int *globals; - char *chars; - uint16_t crc; - uint32_t entfields; - ht string_cache; - qcint string_cached_empty; + prog_section_statement_t *statements; + int *linenums; + prog_section_def_t *defs; + prog_section_field_t *fields; + prog_section_function_t *functions; + int *globals; + char *chars; + uint16_t crc; + uint32_t entfields; + ht string_cache; + qcint_t string_cached_empty; } code_t; /* @@ -744,8 +744,8 @@ GMQCC_WARN code_t *code_init (void); void code_cleanup (code_t *); uint32_t code_genstring (code_t *, const char *string); -qcint code_alloc_field (code_t *, size_t qcsize); -void code_push_statement(code_t *, prog_section_statement *stmt, int linenum); +qcint_t code_alloc_field (code_t *, size_t qcsize); +void code_push_statement(code_t *, prog_section_statement_t *stmt, int linenum); void code_pop_statement (code_t *); /* @@ -756,7 +756,7 @@ typedef struct { const char *file; size_t line; size_t column; -} lex_ctx; +} lex_ctx_t; /*===================================================================*/ /*============================ con.c ================================*/ @@ -784,8 +784,8 @@ FILE *con_default_err(void); void con_vprintmsg (int level, const char *name, size_t line, size_t column, const char *msgtype, const char *msg, va_list ap); void con_printmsg (int level, const char *name, size_t line, size_t column, const char *msgtype, const char *msg, ...); -void con_cvprintmsg(void *ctx, int lvl, const char *msgtype, const char *msg, va_list ap); -void con_cprintmsg (void *ctx, int lvl, const char *msgtype, const char *msg, ...); +void con_cvprintmsg(lex_ctx_t ctx, int lvl, const char *msgtype, const char *msg, va_list ap); +void con_cprintmsg (lex_ctx_t ctx, int lvl, const char *msgtype, const char *msg, ...); void con_close (void); void con_init (void); @@ -802,10 +802,10 @@ extern size_t compile_errors; extern size_t compile_Werrors; extern size_t compile_warnings; -void /********/ compile_error (lex_ctx ctx, /*LVL_ERROR*/ const char *msg, ...); -void /********/ vcompile_error (lex_ctx ctx, /*LVL_ERROR*/ const char *msg, va_list ap); -bool GMQCC_WARN compile_warning (lex_ctx ctx, int warntype, const char *fmt, ...); -bool GMQCC_WARN vcompile_warning(lex_ctx ctx, int warntype, const char *fmt, va_list ap); +void /********/ compile_error (lex_ctx_t ctx, /*LVL_ERROR*/ const char *msg, ...); +void /********/ vcompile_error (lex_ctx_t ctx, /*LVL_ERROR*/ const char *msg, va_list ap); +bool GMQCC_WARN compile_warning (lex_ctx_t ctx, int warntype, const char *fmt, ...); +bool GMQCC_WARN vcompile_warning(lex_ctx_t ctx, int warntype, const char *fmt, va_list ap); void compile_show_werrors(void); /*===================================================================*/ @@ -821,13 +821,13 @@ enum store_types { }; typedef struct { - qcfloat x, y, z; -} vector; + qcfloat_t x, y, z; +} vec3_t; -vector vec3_add (vector, vector); -vector vec3_sub (vector, vector); -qcfloat vec3_mulvv(vector, vector); -vector vec3_mulvf(vector, float); +vec3_t vec3_add (vec3_t, vec3_t); +vec3_t vec3_sub (vec3_t, vec3_t); +qcfloat_t vec3_mulvv(vec3_t, vec3_t); +vec3_t vec3_mulvf(vec3_t, float); /*===================================================================*/ /*============================= exec.c ==============================*/ @@ -841,22 +841,21 @@ vector vec3_mulvf(vector, float); * float and int here. */ typedef union { - qcint _int; - qcint string; - qcint function; - qcint edict; - qcfloat _float; - qcfloat vector[3]; - qcint ivector[3]; -} qcany; + qcint_t _int; + qcint_t string; + qcint_t function; + qcint_t edict; + qcfloat_t _float; + qcfloat_t vector[3]; + qcint_t ivector[3]; +} qcany_t; -typedef char qcfloat_size_is_correct [sizeof(qcfloat) == 4 ?1:-1]; -typedef char qcint_size_is_correct [sizeof(qcint) == 4 ?1:-1]; +typedef char qcfloat_t_size_is_correct [sizeof(qcfloat_t) == 4 ?1:-1]; +typedef char qcint_t_size_is_correct [sizeof(qcint_t) == 4 ?1:-1]; enum { VMERR_OK, VMERR_TEMPSTRING_ALLOC, - VMERR_END }; @@ -868,65 +867,61 @@ enum { #define VMXF_PROFILE 0x0002 /* profile: increment the profile counters */ struct qc_program_s; - -typedef int (*prog_builtin)(struct qc_program_s *prog); +typedef int (*prog_builtin_t)(struct qc_program_s *prog); typedef struct { - qcint stmt; - size_t localsp; - prog_section_function *function; -} qc_exec_stack; + qcint_t stmt; + size_t localsp; + prog_section_function_t *function; +} qc_exec_stack_t; typedef struct qc_program_s { - char *filename; + char *filename; + prog_section_statement_t *code; + prog_section_def_t *defs; + prog_section_def_t *fields; + prog_section_function_t *functions; + char *strings; + qcint_t *globals; + qcint_t *entitydata; + bool *entitypool; - prog_section_statement *code; - prog_section_def *defs; - prog_section_def *fields; - prog_section_function *functions; - char *strings; - qcint *globals; - qcint *entitydata; - bool *entitypool; - - const char* *function_stack; + const char* *function_stack; uint16_t crc16; size_t tempstring_start; size_t tempstring_at; - qcint vmerror; + qcint_t vmerror; size_t *profile; - prog_builtin *builtins; - size_t builtins_count; + prog_builtin_t *builtins; + size_t builtins_count; /* size_t ip; */ - qcint entities; + qcint_t entities; size_t entityfields; bool allowworldwrites; - qcint *localstack; - qc_exec_stack *stack; + qcint_t *localstack; + qc_exec_stack_t *stack; size_t statement; size_t xflags; int argc; /* current arg count for debugging */ -} qc_program; +} qc_program_t; -qc_program* prog_load(const char *filename, bool ignoreversion); -void prog_delete(qc_program *prog); - -bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps); - -const char* prog_getstring (qc_program *prog, qcint str); -prog_section_def* prog_entfield (qc_program *prog, qcint off); -prog_section_def* prog_getdef (qc_program *prog, qcint off); -qcany* prog_getedict (qc_program *prog, qcint e); -qcint prog_tempstring(qc_program *prog, const char *_str); +qc_program_t* prog_load (const char *filename, bool ignoreversion); +void prog_delete (qc_program_t *prog); +bool prog_exec (qc_program_t *prog, prog_section_function_t *func, size_t flags, long maxjumps); +const char* prog_getstring (qc_program_t *prog, qcint_t str); +prog_section_def_t* prog_entfield (qc_program_t *prog, qcint_t off); +prog_section_def_t* prog_getdef (qc_program_t *prog, qcint_t off); +qcany_t* prog_getedict (qc_program_t *prog, qcint_t e); +qcint_t prog_tempstring(qc_program_t *prog, const char *_str); /*===================================================================*/ @@ -990,7 +985,7 @@ int u8_fromchar(uchar_t w, char *to, size_t maxlen); typedef struct { const char *name; longbit bit; -} opts_flag_def; +} opts_flag_def_t; bool opts_setflag (const char *, bool); bool opts_setwarn (const char *, bool); @@ -1037,11 +1032,11 @@ enum { OPTION_COUNT }; -extern const opts_flag_def opts_flag_list[COUNT_FLAGS+1]; -extern const opts_flag_def opts_warn_list[COUNT_WARNINGS+1]; -extern const opts_flag_def opts_opt_list[COUNT_OPTIMIZATIONS+1]; -extern const unsigned int opts_opt_oflag[COUNT_OPTIMIZATIONS+1]; -extern unsigned int opts_optimizationcount[COUNT_OPTIMIZATIONS]; +extern const opts_flag_def_t opts_flag_list[COUNT_FLAGS+1]; +extern const opts_flag_def_t opts_warn_list[COUNT_WARNINGS+1]; +extern const opts_flag_def_t opts_opt_list[COUNT_OPTIMIZATIONS+1]; +extern const unsigned int opts_opt_oflag[COUNT_OPTIMIZATIONS+1]; +extern unsigned int opts_optimizationcount[COUNT_OPTIMIZATIONS]; /* other options: */ typedef enum { diff --git a/ir.c b/ir.c index 52e2ee4..4f53533 100644 --- a/ir.c +++ b/ir.c @@ -227,11 +227,11 @@ static bool ir_function_set_name(ir_function*, const char *name); static void ir_function_delete(ir_function*); static void ir_function_dump(ir_function*, char *ind, int (*oprintf)(const char*,...)); -static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx, const char *label, +static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx_t, const char *label, int op, ir_value *a, ir_value *b, int outype); static void ir_block_delete(ir_block*); static ir_block* ir_block_new(struct ir_function_s *owner, const char *label); -static bool GMQCC_WARN ir_block_create_store(ir_block*, lex_ctx, ir_value *target, ir_value *what); +static bool GMQCC_WARN ir_block_create_store(ir_block*, lex_ctx_t, ir_value *target, ir_value *what); static bool ir_block_set_label(ir_block*, const char *label); static void ir_block_dump(ir_block*, char *ind, int (*oprintf)(const char*,...)); @@ -240,15 +240,15 @@ static void ir_instr_delete(ir_instr*); static void ir_instr_dump(ir_instr* in, char *ind, int (*oprintf)(const char*,...)); /* error functions */ -static void irerror(lex_ctx ctx, const char *msg, ...) +static void irerror(lex_ctx_t ctx, const char *msg, ...) { va_list ap; va_start(ap, msg); - con_cvprintmsg((void*)&ctx, LVL_ERROR, "internal error", msg, ap); + con_cvprintmsg(ctx, LVL_ERROR, "internal error", msg, ap); va_end(ap); } -static bool irwarning(lex_ctx ctx, int warntype, const char *fmt, ...) +static bool irwarning(lex_ctx_t ctx, int warntype, const char *fmt, ...) { bool r; va_list ap; @@ -584,7 +584,7 @@ static void ir_function_collect_value(ir_function *self, ir_value *v) vec_push(self->values, v); } -ir_block* ir_function_create_block(lex_ctx ctx, ir_function *self, const char *label) +ir_block* ir_function_create_block(lex_ctx_t ctx, ir_function *self, const char *label) { ir_block* bn = ir_block_new(self, label); bn->context = ctx; @@ -954,7 +954,7 @@ bool ir_block_set_label(ir_block *self, const char *name) *IR Instructions */ -static ir_instr* ir_instr_new(lex_ctx ctx, ir_block* owner, int op) +static ir_instr* ir_instr_new(lex_ctx_t ctx, ir_block* owner, int op) { ir_instr *self; self = (ir_instr*)mem_a(sizeof(*self)); @@ -1216,7 +1216,7 @@ bool ir_value_set_func(ir_value *self, int f) return true; } -bool ir_value_set_vector(ir_value *self, vector v) +bool ir_value_set_vector(ir_value *self, vec3_t v) { if (self->vtype != TYPE_VECTOR) return false; @@ -1482,7 +1482,7 @@ static bool ir_check_unreachable(ir_block *self) return false; } -bool ir_block_create_store_op(ir_block *self, lex_ctx ctx, int op, ir_value *target, ir_value *what) +bool ir_block_create_store_op(ir_block *self, lex_ctx_t ctx, int op, ir_value *target, ir_value *what) { ir_instr *in; if (!ir_check_unreachable(self)) @@ -1511,7 +1511,7 @@ bool ir_block_create_store_op(ir_block *self, lex_ctx ctx, int op, ir_value *tar return true; } -static bool ir_block_create_store(ir_block *self, lex_ctx ctx, ir_value *target, ir_value *what) +static bool ir_block_create_store(ir_block *self, lex_ctx_t ctx, ir_value *target, ir_value *what) { int op = 0; int vtype; @@ -1536,7 +1536,7 @@ static bool ir_block_create_store(ir_block *self, lex_ctx ctx, ir_value *target, return ir_block_create_store_op(self, ctx, op, target, what); } -bool ir_block_create_storep(ir_block *self, lex_ctx ctx, ir_value *target, ir_value *what) +bool ir_block_create_storep(ir_block *self, lex_ctx_t ctx, ir_value *target, ir_value *what) { int op = 0; int vtype; @@ -1558,7 +1558,7 @@ bool ir_block_create_storep(ir_block *self, lex_ctx ctx, ir_value *target, ir_va return ir_block_create_store_op(self, ctx, op, target, what); } -bool ir_block_create_return(ir_block *self, lex_ctx ctx, ir_value *v) +bool ir_block_create_return(ir_block *self, lex_ctx_t ctx, ir_value *v) { ir_instr *in; if (!ir_check_unreachable(self)) @@ -1578,7 +1578,7 @@ bool ir_block_create_return(ir_block *self, lex_ctx ctx, ir_value *v) return true; } -bool ir_block_create_if(ir_block *self, lex_ctx ctx, ir_value *v, +bool ir_block_create_if(ir_block *self, lex_ctx_t ctx, ir_value *v, ir_block *ontrue, ir_block *onfalse) { ir_instr *in; @@ -1607,7 +1607,7 @@ bool ir_block_create_if(ir_block *self, lex_ctx ctx, ir_value *v, return true; } -bool ir_block_create_jump(ir_block *self, lex_ctx ctx, ir_block *to) +bool ir_block_create_jump(ir_block *self, lex_ctx_t ctx, ir_block *to) { ir_instr *in; if (!ir_check_unreachable(self)) @@ -1625,13 +1625,13 @@ bool ir_block_create_jump(ir_block *self, lex_ctx ctx, ir_block *to) return true; } -bool ir_block_create_goto(ir_block *self, lex_ctx ctx, ir_block *to) +bool ir_block_create_goto(ir_block *self, lex_ctx_t ctx, ir_block *to) { self->owner->flags |= IR_FLAG_HAS_GOTO; return ir_block_create_jump(self, ctx, to); } -ir_instr* ir_block_create_phi(ir_block *self, lex_ctx ctx, const char *label, int ot) +ir_instr* ir_block_create_phi(ir_block *self, lex_ctx_t ctx, const char *label, int ot) { ir_value *out; ir_instr *in; @@ -1678,7 +1678,7 @@ void ir_phi_add(ir_instr* self, ir_block *b, ir_value *v) } /* call related code */ -ir_instr* ir_block_create_call(ir_block *self, lex_ctx ctx, const char *label, ir_value *func, bool noreturn) +ir_instr* ir_block_create_call(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *func, bool noreturn) { ir_value *out; ir_instr *in; @@ -1729,7 +1729,7 @@ void ir_call_param(ir_instr* self, ir_value *v) /* binary op related code */ -ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx, +ir_value* ir_block_create_binop(ir_block *self, lex_ctx_t ctx, const char *label, int opcode, ir_value *left, ir_value *right) { @@ -1840,7 +1840,7 @@ ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx, return ir_block_create_general_instr(self, ctx, label, opcode, left, right, ot); } -ir_value* ir_block_create_unary(ir_block *self, lex_ctx ctx, +ir_value* ir_block_create_unary(ir_block *self, lex_ctx_t ctx, const char *label, int opcode, ir_value *operand) { @@ -1873,7 +1873,7 @@ ir_value* ir_block_create_unary(ir_block *self, lex_ctx ctx, return ir_block_create_general_instr(self, ctx, label, opcode, operand, NULL, ot); } -static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx ctx, const char *label, +static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx_t ctx, const char *label, int op, ir_value *a, ir_value *b, int outype) { ir_instr *instr; @@ -1905,7 +1905,7 @@ on_error: return NULL; } -ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx ctx, const char *label, ir_value *ent, ir_value *field) +ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *ent, ir_value *field) { ir_value *v; @@ -1921,7 +1921,7 @@ ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx ctx, const char * return v; } -ir_value* ir_block_create_load_from_ent(ir_block *self, lex_ctx ctx, const char *label, ir_value *ent, ir_value *field, int outype) +ir_value* ir_block_create_load_from_ent(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *ent, ir_value *field, int outype) { int op; if (ent->vtype != TYPE_ENTITY) @@ -2741,7 +2741,7 @@ static bool gen_global_pointer(code_t *code, ir_value *global) static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *block) { - prog_section_statement stmt; + prog_section_statement_t stmt; ir_instr *instr; ir_block *target; ir_block *ontrue; @@ -3002,7 +3002,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc static bool gen_function_code(code_t *code, ir_function *self) { ir_block *block; - prog_section_statement stmt, *retst; + prog_section_statement_t stmt, *retst; /* Starting from entry point, we generate blocks "as they come" * for now. Dead blocks will not be translated obviously. @@ -3040,13 +3040,13 @@ static bool gen_function_code(code_t *code, ir_function *self) return true; } -static qcint ir_builder_filestring(ir_builder *ir, const char *filename) +static qcint_t ir_builder_filestring(ir_builder *ir, const char *filename) { /* NOTE: filename pointers are copied, we never strdup them, * thus we can use pointer-comparison to find the string. */ size_t i; - qcint str; + qcint_t str; for (i = 0; i < vec_size(ir->filenames); ++i) { if (ir->filenames[i] == filename) @@ -3061,8 +3061,8 @@ static qcint ir_builder_filestring(ir_builder *ir, const char *filename) static bool gen_global_function(ir_builder *ir, ir_value *global) { - prog_section_function fun; - ir_function *irfun; + prog_section_function_t fun; + ir_function *irfun; size_t i; @@ -3116,8 +3116,8 @@ static ir_value* ir_gen_extparam_proto(ir_builder *ir) static void ir_gen_extparam(ir_builder *ir) { - prog_section_def def; - ir_value *global; + prog_section_def_t def; + ir_value *global; if (vec_size(ir->extparam_protos) < vec_size(ir->extparams)+1) global = ir_gen_extparam_proto(ir); @@ -3145,7 +3145,7 @@ static bool gen_function_extparam_copy(code_t *code, ir_function *self) ir_builder *ir = self->owner; ir_value *ep; - prog_section_statement stmt; + prog_section_statement_t stmt; numparams = vec_size(self->params); if (!numparams) @@ -3180,7 +3180,7 @@ static bool gen_function_varargs_copy(code_t *code, ir_function *self) ir_builder *ir = self->owner; ir_value *ep; - prog_section_statement stmt; + prog_section_statement_t stmt; numparams = vec_size(self->params); if (!numparams) @@ -3212,10 +3212,10 @@ static bool gen_function_varargs_copy(code_t *code, ir_function *self) static bool gen_function_locals(ir_builder *ir, ir_value *global) { - prog_section_function *def; - ir_function *irfun; - size_t i; - uint32_t firstlocal, firstglobal; + prog_section_function_t *def; + ir_function *irfun; + size_t i; + uint32_t firstlocal, firstglobal; irfun = global->constval.vfunc; def = ir->code->functions + irfun->code_function_def; @@ -3261,8 +3261,8 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global) static bool gen_global_function_code(ir_builder *ir, ir_value *global) { - prog_section_function *fundef; - ir_function *irfun; + prog_section_function_t *fundef; + ir_function *irfun; (void)ir; @@ -3305,7 +3305,7 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global) return true; } -static void gen_vector_defs(code_t *code, prog_section_def def, const char *name) +static void gen_vector_defs(code_t *code, prog_section_def_t def, const char *name) { char *component; size_t len, i; @@ -3335,7 +3335,7 @@ static void gen_vector_defs(code_t *code, prog_section_def def, const char *name mem_d(component); } -static void gen_vector_fields(code_t *code, prog_section_field fld, const char *name) +static void gen_vector_fields(code_t *code, prog_section_field_t fld, const char *name) { char *component; size_t len, i; @@ -3367,10 +3367,10 @@ static void gen_vector_fields(code_t *code, prog_section_field fld, const char * static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal) { - size_t i; - int32_t *iptr; - prog_section_def def; - bool pushdef = opts.optimizeoff; + size_t i; + int32_t *iptr; + prog_section_def_t def; + bool pushdef = opts.optimizeoff; def.type = global->vtype; def.offset = vec_size(self->code->globals); @@ -3543,8 +3543,8 @@ static GMQCC_INLINE void ir_builder_prepare_field(code_t *code, ir_value *field) static bool ir_builder_gen_field(ir_builder *self, ir_value *field) { - prog_section_def def; - prog_section_field fld; + prog_section_def_t def; + prog_section_field_t fld; (void)self; @@ -3613,7 +3613,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field) bool ir_builder_generate(ir_builder *self, const char *filename) { - prog_section_statement stmt; + prog_section_statement_t stmt; size_t i; char *lnofile = NULL; diff --git a/ir.h b/ir.h index 34dea1a..b62b09d 100644 --- a/ir.h +++ b/ir.h @@ -36,7 +36,7 @@ typedef struct ir_value_s { char *name; int vtype; int store; - lex_ctx context; + lex_ctx_t context; /* even the IR knows the subtype of a field */ int fieldtype; /* and the output type of a function */ @@ -53,7 +53,7 @@ typedef struct ir_value_s { union { float vfloat; int vint; - vector vvec; + vec3_t vvec; int32_t ivec[3]; char *vstring; struct ir_value_s *vpointer; @@ -94,7 +94,7 @@ ir_value* ir_value_vector_member(ir_value*, unsigned int member); bool GMQCC_WARN ir_value_set_float(ir_value*, float f); bool GMQCC_WARN ir_value_set_func(ir_value*, int f); bool GMQCC_WARN ir_value_set_string(ir_value*, const char *s); -bool GMQCC_WARN ir_value_set_vector(ir_value*, vector v); +bool GMQCC_WARN ir_value_set_vector(ir_value*, vec3_t v); bool GMQCC_WARN ir_value_set_field(ir_value*, ir_value *fld); bool ir_value_lives(ir_value*, size_t); void ir_value_dump_life(const ir_value *self, int (*oprintf)(const char*,...)); @@ -110,7 +110,7 @@ typedef struct ir_phi_entry_s typedef struct ir_instr_s { int opcode; - lex_ctx context; + lex_ctx_t context; ir_value* (_ops[3]); struct ir_block_s* (bops[2]); @@ -130,7 +130,7 @@ typedef struct ir_instr_s typedef struct ir_block_s { char *label; - lex_ctx context; + lex_ctx_t context; bool final; /* once a jump is added we're done */ ir_instr **instr; @@ -149,26 +149,26 @@ typedef struct ir_block_s size_t code_start; } ir_block; -ir_value* ir_block_create_binop(ir_block*, lex_ctx, const char *label, int op, ir_value *left, ir_value *right); -ir_value* ir_block_create_unary(ir_block*, lex_ctx, const char *label, int op, ir_value *operand); -bool GMQCC_WARN ir_block_create_store_op(ir_block*, lex_ctx, int op, ir_value *target, ir_value *what); -bool GMQCC_WARN ir_block_create_storep(ir_block*, lex_ctx, ir_value *target, ir_value *what); -ir_value* ir_block_create_load_from_ent(ir_block*, lex_ctx, const char *label, ir_value *ent, ir_value *field, int outype); -ir_value* ir_block_create_fieldaddress(ir_block*, lex_ctx, const char *label, ir_value *entity, ir_value *field); +ir_value* ir_block_create_binop(ir_block*, lex_ctx_t, const char *label, int op, ir_value *left, ir_value *right); +ir_value* ir_block_create_unary(ir_block*, lex_ctx_t, const char *label, int op, ir_value *operand); +bool GMQCC_WARN ir_block_create_store_op(ir_block*, lex_ctx_t, int op, ir_value *target, ir_value *what); +bool GMQCC_WARN ir_block_create_storep(ir_block*, lex_ctx_t, ir_value *target, ir_value *what); +ir_value* ir_block_create_load_from_ent(ir_block*, lex_ctx_t, const char *label, ir_value *ent, ir_value *field, int outype); +ir_value* ir_block_create_fieldaddress(ir_block*, lex_ctx_t, const char *label, ir_value *entity, ir_value *field); /* This is to create an instruction of the form * %label := opcode a, b */ -ir_instr* ir_block_create_phi(ir_block*, lex_ctx, const char *label, int vtype); +ir_instr* ir_block_create_phi(ir_block*, lex_ctx_t, const char *label, int vtype); ir_value* ir_phi_value(ir_instr*); void ir_phi_add(ir_instr*, ir_block *b, ir_value *v); -ir_instr* ir_block_create_call(ir_block*, lex_ctx, const char *label, ir_value *func, bool noreturn); +ir_instr* ir_block_create_call(ir_block*, lex_ctx_t, const char *label, ir_value *func, bool noreturn); ir_value* ir_call_value(ir_instr*); void ir_call_param(ir_instr*, ir_value*); -bool GMQCC_WARN ir_block_create_return(ir_block*, lex_ctx, ir_value *opt_value); +bool GMQCC_WARN ir_block_create_return(ir_block*, lex_ctx_t, ir_value *opt_value); -bool GMQCC_WARN ir_block_create_if(ir_block*, lex_ctx, ir_value *cond, +bool GMQCC_WARN ir_block_create_if(ir_block*, lex_ctx_t, ir_value *cond, ir_block *ontrue, ir_block *onfalse); /* A 'goto' is an actual 'goto' coded in QC, whereas * a 'jump' is a virtual construct which simply names the @@ -176,8 +176,8 @@ bool GMQCC_WARN ir_block_create_if(ir_block*, lex_ctx, ir_value *cond, * A goto usually becomes an OP_GOTO in the resulting code, * whereas a 'jump' usually doesn't add any actual instruction. */ -bool GMQCC_WARN ir_block_create_jump(ir_block*, lex_ctx, ir_block *to); -bool GMQCC_WARN ir_block_create_goto(ir_block*, lex_ctx, ir_block *to); +bool GMQCC_WARN ir_block_create_jump(ir_block*, lex_ctx_t, ir_block *to); +bool GMQCC_WARN ir_block_create_goto(ir_block*, lex_ctx_t, ir_block *to); /* function */ typedef struct ir_function_s @@ -208,7 +208,7 @@ typedef struct ir_function_s ir_block* first; ir_block* last; - lex_ctx context; + lex_ctx_t context; /* for prototypes - first we generate all the * globals, and we remember teh function-defs @@ -216,7 +216,7 @@ typedef struct ir_function_s * * remember the ID: */ - qcint code_function_def; + qcint_t code_function_def; /* for temp allocation */ size_t run_id; @@ -236,7 +236,7 @@ typedef struct ir_function_s ir_value* ir_function_create_local(ir_function *self, const char *name, int vtype, bool param); bool GMQCC_WARN ir_function_finalize(ir_function*); -ir_block* ir_function_create_block(lex_ctx ctx, ir_function*, const char *label); +ir_block* ir_function_create_block(lex_ctx_t ctx, ir_function*, const char *label); /* builder */ #define IR_HT_SIZE 1024 @@ -261,9 +261,9 @@ typedef struct ir_builder_s uint32_t first_common_globaltemp; const char **filenames; - qcint *filestrings; + qcint_t *filestrings; /* we cache the #IMMEDIATE string here */ - qcint str_immediate; + qcint_t str_immediate; /* there should just be this one nil */ ir_value *nil; ir_value *reserved_va_count; @@ -287,6 +287,6 @@ void ir_builder_dump(ir_builder*, int (*oprintf)(const char*, ...)); * for some reason :P */ typedef int static_assert_is_32bit_float [(sizeof(int32_t) == 4)?1:-1]; -typedef int static_assert_is_32bit_integer[(sizeof(qcfloat) == 4)?1:-1]; +typedef int static_assert_is_32bit_integer[(sizeof(qcfloat_t) == 4)?1:-1]; #endif diff --git a/lexer.c b/lexer.c index e0dafc3..5411041 100644 --- a/lexer.c +++ b/lexer.c @@ -71,9 +71,9 @@ static void lexerror(lex_file *lex, const char *fmt, ...) static bool lexwarn(lex_file *lex, int warntype, const char *fmt, ...) { - bool r; - lex_ctx ctx; - va_list ap; + bool r; + lex_ctx_t ctx; + va_list ap; ctx.file = lex->name; ctx.line = lex->sline; diff --git a/lexer.h b/lexer.h index 0de0c8f..efbdd64 100644 --- a/lexer.h +++ b/lexer.h @@ -30,7 +30,7 @@ struct token_s { char *value; union { - vector v; + vec3_t v; int i; double f; int t; /* type */ @@ -41,7 +41,7 @@ struct token_s { struct token_s *prev; #endif - lex_ctx ctx; + lex_ctx_t ctx; }; #if 0 diff --git a/opts.c b/opts.c index e009d4e..46496ca 100644 --- a/opts.c +++ b/opts.c @@ -33,21 +33,21 @@ const unsigned int opts_opt_oflag[COUNT_OPTIMIZATIONS+1] = { 0 }; -const opts_flag_def opts_opt_list[COUNT_OPTIMIZATIONS+1] = { +const opts_flag_def_t opts_opt_list[COUNT_OPTIMIZATIONS+1] = { # define GMQCC_TYPE_OPTIMIZATIONS # define GMQCC_DEFINE_FLAG(NAME, MIN_O) { #NAME, LONGBIT(OPTIM_##NAME) }, # include "opts.def" { NULL, LONGBIT(0) } }; -const opts_flag_def opts_warn_list[COUNT_WARNINGS+1] = { +const opts_flag_def_t opts_warn_list[COUNT_WARNINGS+1] = { # define GMQCC_TYPE_WARNS # define GMQCC_DEFINE_FLAG(X) { #X, LONGBIT(WARN_##X) }, # include "opts.def" { NULL, LONGBIT(0) } }; -const opts_flag_def opts_flag_list[COUNT_FLAGS+1] = { +const opts_flag_def_t opts_flag_list[COUNT_FLAGS+1] = { # define GMQCC_TYPE_FLAGS # define GMQCC_DEFINE_FLAG(X) { #X, LONGBIT(X) }, # include "opts.def" @@ -132,7 +132,7 @@ void opts_init(const char *output, int standard, size_t arraysize) { OPTS_OPTION_U16(OPTION_MEMDUMPCOLS) = 16; } -static bool opts_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def *list, size_t listsize) { +static bool opts_setflag_all(const char *name, bool on, uint32_t *flags, const opts_flag_def_t *list, size_t listsize) { size_t i; for (i = 0; i < listsize; ++i) { diff --git a/parser.c b/parser.c index ea4930f..00e7299 100644 --- a/parser.c +++ b/parser.c @@ -92,7 +92,7 @@ typedef struct parser_s { size_t *_blocklocals; ast_value **_typedefs; size_t *_blocktypedefs; - lex_ctx *_block_ctx; + lex_ctx_t *_block_ctx; /* we store the '=' operator info */ const oper_info *assign_op; @@ -148,32 +148,32 @@ static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char * * some maths used for constant folding */ -vector vec3_add(vector a, vector b) +vec3_t vec3_add(vec3_t a, vec3_t b) { - vector out; + vec3_t out; out.x = a.x + b.x; out.y = a.y + b.y; out.z = a.z + b.z; return out; } -vector vec3_sub(vector a, vector b) +vec3_t vec3_sub(vec3_t a, vec3_t b) { - vector out; + vec3_t out; out.x = a.x - b.x; out.y = a.y - b.y; out.z = a.z - b.z; return out; } -qcfloat vec3_mulvv(vector a, vector b) +qcfloat_t vec3_mulvv(vec3_t a, vec3_t b) { return (a.x * b.x + a.y * b.y + a.z * b.z); } -vector vec3_mulvf(vector a, float b) +vec3_t vec3_mulvf(vec3_t a, float b) { - vector out; + vec3_t out; out.x = a.x * b; out.y = a.y * b; out.z = a.z * b; @@ -205,7 +205,7 @@ static ast_value* parser_const_float(parser_t *parser, double d) { size_t i; ast_value *out; - lex_ctx ctx; + lex_ctx_t ctx; for (i = 0; i < vec_size(parser->imm_float); ++i) { const double compare = parser->imm_float[i]->constval.vfloat; if (memcmp((const void*)&compare, (const void *)&d, sizeof(double)) == 0) @@ -291,7 +291,7 @@ static ast_value* parser_const_string(parser_t *parser, const char *str, bool do return out; } -static ast_value* parser_const_vector(parser_t *parser, vector v) +static ast_value* parser_const_vector(parser_t *parser, vec3_t v) { size_t i; ast_value *out; @@ -310,7 +310,7 @@ static ast_value* parser_const_vector(parser_t *parser, vector v) static ast_value* parser_const_vector_f(parser_t *parser, float x, float y, float z) { - vector v; + vec3_t v; v.x = x; v.y = y; v.z = z; @@ -410,7 +410,7 @@ typedef struct size_t off; ast_expression *out; ast_block *block; /* for commas and function calls */ - lex_ctx ctx; + lex_ctx_t ctx; } sy_elem; enum { @@ -428,7 +428,7 @@ typedef struct unsigned int *paren; } shunt; -static sy_elem syexp(lex_ctx ctx, ast_expression *v) { +static sy_elem syexp(lex_ctx_t ctx, ast_expression *v) { sy_elem e; e.etype = 0; e.off = 0; @@ -439,7 +439,7 @@ static sy_elem syexp(lex_ctx ctx, ast_expression *v) { return e; } -static sy_elem syblock(lex_ctx ctx, ast_block *v) { +static sy_elem syblock(lex_ctx_t ctx, ast_block *v) { sy_elem e; e.etype = 0; e.off = 0; @@ -450,7 +450,7 @@ static sy_elem syblock(lex_ctx ctx, ast_block *v) { return e; } -static sy_elem syop(lex_ctx ctx, const oper_info *op) { +static sy_elem syop(lex_ctx_t ctx, const oper_info *op) { sy_elem e; e.etype = 1 + (op - operators); e.off = 0; @@ -461,7 +461,7 @@ static sy_elem syop(lex_ctx ctx, const oper_info *op) { return e; } -static sy_elem syparen(lex_ctx ctx, size_t off) { +static sy_elem syparen(lex_ctx_t ctx, size_t off) { sy_elem e; e.etype = 0; e.off = off; @@ -484,7 +484,7 @@ static bool rotate_entfield_array_index_nodes(ast_expression **out) ast_expression *sub; ast_expression *entity; - lex_ctx ctx = ast_ctx(*out); + lex_ctx_t ctx = ast_ctx(*out); if (!ast_istype(*out, ast_array_index)) return false; @@ -514,7 +514,7 @@ static bool rotate_entfield_array_index_nodes(ast_expression **out) return true; } -static bool immediate_is_true(lex_ctx ctx, ast_value *v) +static bool immediate_is_true(lex_ctx_t ctx, ast_value *v) { switch (v->expression.vtype) { case TYPE_FLOAT: @@ -543,14 +543,14 @@ static bool immediate_is_true(lex_ctx ctx, ast_value *v) static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) { const oper_info *op; - lex_ctx ctx; + lex_ctx_t ctx; ast_expression *out = NULL; ast_expression *exprs[3]; ast_block *blocks[3]; ast_value *asvalue[3]; ast_binstore *asbinstore; size_t i, assignop, addop, subop; - qcint generated_op = 0; + qcint_t generated_op = 0; char ty1[1024]; char ty2[1024]; @@ -878,7 +878,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (CanConstFold(exprs[0], exprs[1])) out = (ast_expression*)parser_const_float(parser, vec3_mulvv(ConstV(0), ConstV(1))); else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[0])) { - vector vec = ConstV(0); + vec3_t vec = ConstV(0); if (!vec.y && !vec.z) { /* 'n 0 0' * v */ ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS]; out = (ast_expression*)ast_member_new(ctx, exprs[1], 0, NULL); @@ -907,7 +907,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) out = (ast_expression*)ast_binary_new(ctx, INSTR_MUL_V, exprs[0], exprs[1]); } else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && CanConstFold1(exprs[1])) { - vector vec = ConstV(1); + vec3_t vec = ConstV(1); if (!vec.y && !vec.z) { /* v * 'n 0 0' */ ++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS]; out = (ast_expression*)ast_member_new(ctx, exprs[0], 0, NULL); @@ -995,7 +995,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } if (CanConstFold(exprs[0], exprs[1])) { out = (ast_expression*)parser_const_float(parser, - (float)(((qcint)ConstF(0)) % ((qcint)ConstF(1)))); + (float)(((qcint_t)ConstF(0)) % ((qcint_t)ConstF(1)))); } else { /* generate a call to __builtin_mod */ ast_expression *mod = intrin_func(parser, "mod"); @@ -1024,8 +1024,8 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } if (CanConstFold(exprs[0], exprs[1])) out = (ast_expression*)parser_const_float(parser, - (op->id == opid1('|') ? (float)( ((qcint)ConstF(0)) | ((qcint)ConstF(1)) ) : - (float)( ((qcint)ConstF(0)) & ((qcint)ConstF(1)) ) )); + (op->id == opid1('|') ? (float)( ((qcint_t)ConstF(0)) | ((qcint_t)ConstF(1)) ) : + (float)( ((qcint_t)ConstF(0)) & ((qcint_t)ConstF(1)) ) )); else out = (ast_expression*)ast_binary_new(ctx, (op->id == opid1('|') ? INSTR_BITOR : INSTR_BITAND), @@ -1085,7 +1085,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) */ if (exprs[0]->vtype == TYPE_FLOAT) { if(CanConstFold(exprs[0], exprs[1])) { - out = (ast_expression*)parser_const_float(parser, (float)((qcint)(ConstF(0)) ^ ((qcint)(ConstF(1))))); + out = (ast_expression*)parser_const_float(parser, (float)((qcint_t)(ConstF(0)) ^ ((qcint_t)(ConstF(1))))); } else { ast_binary *expr = ast_binary_new( ctx, @@ -1126,9 +1126,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (CanConstFold(exprs[0], exprs[1])) { out = (ast_expression*)parser_const_vector_f( parser, - (float)(((qcint)(ConstV(0).x)) ^ ((qcint)(ConstV(1).x))), - (float)(((qcint)(ConstV(0).y)) ^ ((qcint)(ConstV(1).y))), - (float)(((qcint)(ConstV(0).z)) ^ ((qcint)(ConstV(1).z))) + (float)(((qcint_t)(ConstV(0).x)) ^ ((qcint_t)(ConstV(1).x))), + (float)(((qcint_t)(ConstV(0).y)) ^ ((qcint_t)(ConstV(1).y))), + (float)(((qcint_t)(ConstV(0).z)) ^ ((qcint_t)(ConstV(1).z))) ); } else { compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against vector"); @@ -1142,9 +1142,9 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) if (CanConstFold(exprs[0], exprs[1])) { out = (ast_expression*)parser_const_vector_f( parser, - (float)(((qcint)(ConstV(0).x)) ^ ((qcint)(ConstF(1)))), - (float)(((qcint)(ConstV(0).y)) ^ ((qcint)(ConstF(1)))), - (float)(((qcint)(ConstV(0).z)) ^ ((qcint)(ConstF(1)))) + (float)(((qcint_t)(ConstV(0).x)) ^ ((qcint_t)(ConstF(1)))), + (float)(((qcint_t)(ConstV(0).y)) ^ ((qcint_t)(ConstF(1)))), + (float)(((qcint_t)(ConstV(0).z)) ^ ((qcint_t)(ConstF(1)))) ); } else { compile_error(ast_ctx(exprs[0]), "Not Yet Implemented: bit-xor for vector against float"); @@ -1603,7 +1603,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy) } if(CanConstFold1(exprs[0])) - out = (ast_expression*)parser_const_float(parser, ~(qcint)ConstF(0)); + out = (ast_expression*)parser_const_float(parser, ~(qcint_t)ConstF(0)); else out = (ast_expression*) ast_binary_new(ctx, INSTR_SUB_F, (ast_expression*)parser_const_float_neg1(parser), exprs[0]); @@ -1823,7 +1823,7 @@ static ast_expression* parse_vararg_do(parser_t *parser) ast_expression *idx, *out; ast_value *typevar; ast_value *funtype = parser->function->vtype; - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); if (!parser->function->varargs) { parseerror(parser, "function has no variable argument list"); @@ -2538,7 +2538,7 @@ static bool parse_if(parser_t *parser, ast_block *block, ast_expression **out) ast_expression *cond, *ontrue = NULL, *onfalse = NULL; bool ifnot = false; - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); (void)block; /* not touching */ @@ -2677,7 +2677,7 @@ static bool parse_while_go(parser_t *parser, ast_block *block, ast_expression ** bool ifnot = false; - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); (void)block; /* not touching */ @@ -2778,7 +2778,7 @@ static bool parse_dowhile_go(parser_t *parser, ast_block *block, ast_expression bool ifnot = false; - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); (void)block; /* not touching */ @@ -2903,7 +2903,7 @@ static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **ou bool ifnot = false; - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); parser_enterblock(parser); @@ -2969,7 +2969,7 @@ static bool parse_for_go(parser_t *parser, ast_block *block, ast_expression **ou /* parse the incrementor */ if (parser->tok != ')') { - lex_ctx condctx = parser_ctx(parser); + lex_ctx_t condctx = parser_ctx(parser); increment = parse_expression_leave(parser, false, false, false); if (!increment) goto onerr; @@ -3021,7 +3021,7 @@ static bool parse_return(parser_t *parser, ast_block *block, ast_expression **ou ast_value *retval = parser->function->return_value; ast_value *expected = parser->function->vtype; - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); (void)block; /* not touching */ @@ -3120,7 +3120,7 @@ static bool parse_break_continue(parser_t *parser, ast_block *block, ast_express { size_t i; unsigned int levels = 0; - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); const char **loops = (is_continue ? parser->continues : parser->breaks); (void)block; /* not touching */ @@ -3407,7 +3407,7 @@ static bool parse_switch_go(parser_t *parser, ast_block *block, ast_expression * bool noref, is_static; uint32_t qflags = 0; - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); (void)block; /* not touching */ (void)opval; @@ -3919,7 +3919,7 @@ static bool parse_statement(parser_t *parser, ast_block *block, ast_expression * } else { - lex_ctx ctx = parser_ctx(parser); + lex_ctx_t ctx = parser_ctx(parser); ast_expression *exp = parse_expression(parser, false, false); if (!exp) return false; @@ -3936,7 +3936,7 @@ static bool parse_enum(parser_t *parser) { bool flag = false; bool reverse = false; - qcfloat num = 0; + qcfloat_t num = 0; ast_value **values = NULL; ast_value *var = NULL; ast_value *asvalue; @@ -4318,7 +4318,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var) } if (has_frame_think) { - lex_ctx ctx; + lex_ctx_t ctx; ast_expression *self_frame; ast_expression *self_nextthink; ast_expression *self_think; @@ -4498,7 +4498,7 @@ static ast_expression *array_accessor_split( ast_ifthen *ifthen; ast_binary *cmp; - lex_ctx ctx = ast_ctx(array); + lex_ctx_t ctx = ast_ctx(array); if (!left || !right) { if (left) ast_delete(left); @@ -4528,7 +4528,7 @@ static ast_expression *array_accessor_split( 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); + lex_ctx_t ctx = ast_ctx(array); if (from+1 == afterend) { /* set this value */ @@ -4593,7 +4593,7 @@ static ast_expression *array_field_setter_node( size_t from, size_t afterend) { - lex_ctx ctx = ast_ctx(array); + lex_ctx_t ctx = ast_ctx(array); if (from+1 == afterend) { /* set this value */ @@ -4664,7 +4664,7 @@ static ast_expression *array_field_setter_node( 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); + lex_ctx_t ctx = ast_ctx(array); if (from+1 == afterend) { ast_return *ret; @@ -4900,7 +4900,7 @@ static bool parser_create_array_getter(parser_t *parser, ast_value *array, const static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef); static ast_value *parse_parameter_list(parser_t *parser, ast_value *var) { - lex_ctx ctx; + lex_ctx_t ctx; size_t i; ast_value **params; ast_value *param; @@ -5027,7 +5027,7 @@ static ast_value *parse_arraysize(parser_t *parser, ast_value *var) { ast_expression *cexp; ast_value *cval, *tmp; - lex_ctx ctx; + lex_ctx_t ctx; ctx = parser_ctx(parser); @@ -5106,7 +5106,7 @@ static ast_value *parse_arraysize(parser_t *parser, ast_value *var) static ast_value *parse_typename(parser_t *parser, ast_value **storebase, ast_value *cached_typedef) { ast_value *var, *tmp; - lex_ctx ctx; + lex_ctx_t ctx; const char *name = NULL; bool isfield = false; @@ -6277,7 +6277,7 @@ static void generate_checksum(parser_t *parser, ir_builder *ir) parser_t *parser_create() { parser_t *parser; - lex_ctx empty_ctx; + lex_ctx_t empty_ctx; size_t i; parser = (parser_t*)mem_a(sizeof(parser_t));