From 3c2c4aa9e636069ba37ed6455d12d954fbae43a6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 6 Dec 2001 19:49:40 +0000 Subject: [PATCH] indent whitespace cleanup. not perfect, but a bit more consistent now --- tools/qfcc/source/.indent.pro | 39 +++-- tools/qfcc/source/cmdlib.c | 37 ++--- tools/qfcc/source/debug.c | 4 +- tools/qfcc/source/emit.c | 66 ++++---- tools/qfcc/source/expr.c | 257 +++++++++++++++--------------- tools/qfcc/source/pr_comp.c | 12 +- tools/qfcc/source/pr_def.c | 85 +++++----- tools/qfcc/source/pr_imm.c | 91 ++++++----- tools/qfcc/source/pr_lex.c | 97 ++++++------ tools/qfcc/source/pr_opcode.c | 56 +++---- tools/qfcc/source/qfcc.c | 284 +++++++++++++++++----------------- tools/qfcc/source/switch.c | 32 ++-- 12 files changed, 557 insertions(+), 503 deletions(-) diff --git a/tools/qfcc/source/.indent.pro b/tools/qfcc/source/.indent.pro index f49e555d2..ff653d3c7 100644 --- a/tools/qfcc/source/.indent.pro +++ b/tools/qfcc/source/.indent.pro @@ -7,19 +7,36 @@ -ts4 --T byte --T def_s --T def_t --T etype_t --T eval_s --T eval_t +-T FILE -T func_t --T function_s +-T case_label_t +-T case_node_t +-T ddef_t +-T def_t +-T dfunction_t +-T dprograms_t +-T dstatement_t +-T elabel_t +-T entvars_t +-T etype_t +-T eval_t +-T expr_t -T function_t +-T globalvars_t -T gofs_t --T qboolean --T statement_s --T statement_t +-T hashtab_t +-T locref_t +-T opcode_t +-T options_t +-T pid_t +-T pr_auxfunction_t +-T pr_debug_header_t +-T pr_info_t +-T pr_lineno_t +-T size_t +-T statref_t -T string_t --T type_s +-T switch_block_t +-T token_type_t -T type_t +-T vec3_t diff --git a/tools/qfcc/source/cmdlib.c b/tools/qfcc/source/cmdlib.c index 30c1aa0fd..cc8efa444 100644 --- a/tools/qfcc/source/cmdlib.c +++ b/tools/qfcc/source/cmdlib.c @@ -49,27 +49,27 @@ #define PATHSEPERATOR '/' -char com_token[1024]; -qboolean com_eof; +char com_token[1024]; +qboolean com_eof; /* Error For abnormal program terminations -*/ +*/ void -Error (char *error, ...) +Error (char *error, ...) { - va_list argptr; - + va_list argptr; + printf ("************ ERROR ************\n"); - + va_start (argptr, error); vprintf (error, argptr); va_end (argptr); printf ("\n"); exit (1); -} +} /* @@ -80,8 +80,8 @@ Error (char *error, ...) char * Parse (char *data) { - int c; - int len = 0; + int c; + int len = 0; com_token[0] = 0; @@ -89,7 +89,7 @@ Parse (char *data) return NULL; // skip whitespace -skipwhite: + skipwhite: while ((c = *data) <= ' ') { if (c == 0) { com_eof = true; @@ -104,7 +104,6 @@ skipwhite: data++; goto skipwhite; } - // handle quoted strings specially if (c == '\"') { data++; @@ -118,7 +117,6 @@ skipwhite: len++; } while (1); } - // parse single characters if (c == '{' || c == '}' || c == ')' || c == '(' || c == '\'' || c == ':') { com_token[len] = c; @@ -126,7 +124,6 @@ skipwhite: com_token[len] = 0; return data + 1; } - // parse a regular word do { com_token[len] = c; @@ -158,8 +155,8 @@ skipwhite: int FileLength (FILE *f) { - int pos; - int end; + int pos; + int end; pos = ftell (f); fseek (f, 0, SEEK_END); @@ -173,7 +170,7 @@ FileLength (FILE *f) FILE * SafeOpenWrite (char *filename) { - FILE *f; + FILE *f; f = fopen (filename, "wb"); @@ -219,9 +216,9 @@ SafeWrite (FILE *f, void *buffer, int count) int LoadFile (char *filename, void **bufferptr) { - FILE *f; - int length; - void *buffer; + FILE *f; + int length; + void *buffer; f = SafeOpenRead (filename); length = FileLength (f); diff --git a/tools/qfcc/source/debug.c b/tools/qfcc/source/debug.c index c5fdd9cf5..ab9f109b2 100644 --- a/tools/qfcc/source/debug.c +++ b/tools/qfcc/source/debug.c @@ -27,7 +27,7 @@ Boston, MA 02111-1307, USA */ -static const char rcsid[] = +static const char rcsid[] = "$Id$"; #include "qfcc.h" @@ -42,7 +42,7 @@ pr_lineno_t *linenos; static int locals_size; int num_locals; -ddef_t *locals; +ddef_t *locals; pr_auxfunction_t * new_auxfunction (void) diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index 3fd1e551f..c6af3c8dd 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -27,7 +27,7 @@ Boston, MA 02111-1307, USA */ -static const char rcsid[] = +static const char rcsid[] = "$Id$"; #include @@ -39,26 +39,29 @@ static const char rcsid[] = #include "scope.h" #include "qc-parse.h" -def_t *emit_sub_expr (expr_t *e, def_t *dest); +def_t *emit_sub_expr (expr_t *e, def_t *dest); def_t * -emit_statement (int sline, opcode_t *op, def_t *var_a, def_t *var_b, def_t *var_c) +emit_statement (int sline, opcode_t *op, def_t *var_a, def_t *var_b, + def_t *var_c) { - dstatement_t *statement; - def_t *ret; + dstatement_t *statement; + def_t *ret; if (!op) { - expr_t e; + expr_t e; + e.line = sline; e.file = s_file; error (&e, "ice ice baby\n"); abort (); } if (options.code.debug) { - int line = sline - lineno_base; + int line = sline - lineno_base; if (line != linenos[num_linenos - 1].line) { - pr_lineno_t *lineno = new_lineno (); + pr_lineno_t *lineno = new_lineno (); + lineno->line = line; lineno->fa.addr = numstatements; } @@ -76,7 +79,7 @@ emit_statement (int sline, opcode_t *op, def_t *var_a, def_t *var_b, def_t *var_ statement->c = 0; } ret = var_a; - } else { // allocate result space + } else { // allocate result space if (!var_c) { var_c = PR_GetTempDef (types[op->type_c], pr_scope); var_c->users += 2; @@ -98,8 +101,8 @@ void emit_branch (int line, opcode_t *op, expr_t *e, expr_t *l) { dstatement_t *st; - statref_t *ref; - def_t *def = 0; + statref_t *ref; + def_t *def = 0; if (e) def = emit_sub_expr (e, 0); @@ -120,12 +123,12 @@ emit_branch (int line, opcode_t *op, expr_t *e, expr_t *l) def_t * emit_function_call (expr_t *e, def_t *dest) { - def_t *func = emit_sub_expr (e->e.expr.e1, 0); - def_t parm; - def_t *arg; - expr_t *earg; - opcode_t *op; - int count = 0, ind; + def_t *func = emit_sub_expr (e->e.expr.e1, 0); + def_t parm; + def_t *arg; + expr_t *earg; + opcode_t *op; + int count = 0, ind; for (earg = e->e.expr.e2; earg; earg = earg->next) count++; @@ -157,10 +160,10 @@ emit_function_call (expr_t *e, def_t *dest) def_t * emit_assign_expr (expr_t *e) { - def_t *def_a, *def_b, *def_c; - opcode_t *op; - expr_t *e1 = e->e.expr.e1; - expr_t *e2 = e->e.expr.e2; + def_t *def_a, *def_b, *def_c; + opcode_t *op; + expr_t *e1 = e->e.expr.e1; + expr_t *e2 = e->e.expr.e2; if (e1->type == ex_temp && e1->e.temp.users < 2) { e1->e.temp.users--; @@ -182,8 +185,8 @@ emit_assign_expr (expr_t *e) } else { if (def_a->constant) { if (options.code.cow) { - int size = pr_type_size [def_a->type->type]; - int ofs = PR_NewLocation (def_a->type); + int size = pr_type_size[def_a->type->type]; + int ofs = PR_NewLocation (def_a->type); memcpy (pr_globals + ofs, pr_globals + def_a->ofs, size); def_a->ofs = ofs; @@ -221,9 +224,10 @@ emit_bind_expr (expr_t *e1, expr_t *e2) def = emit_sub_expr (e1, e2->e.temp.def); if (t1 != t2) { def_t *tmp = PR_NewDef (t2, 0, def->scope); + tmp->ofs = def->ofs; tmp->users = e2->e.temp.users; - tmp->freed = 1; // don't free this offset when freeing def + tmp->freed = 1; // don't free this offset when freeing def def = tmp; } e2->e.temp.def = def; @@ -335,11 +339,11 @@ emit_sub_expr (expr_t *e, def_t *dest) void emit_expr (expr_t *e) { - def_t *def; - def_t *def_a; - def_t *def_b; - statref_t *ref; - elabel_t *label; + def_t *def; + def_t *def_a; + def_t *def_b; + statref_t *ref; + elabel_t *label; switch (e->type) { case ex_label: @@ -357,10 +361,10 @@ emit_expr (expr_t *e) ref->statement->c = label->statement - ref->statement; break; case 3: - *(int*)ref->statement = label->statement - statements; + *(int *) ref->statement = label->statement - statements; break; default: - abort(); + abort (); } } break; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 4feb91c4f..999b8325a 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -27,7 +27,7 @@ Boston, MA 02111-1307, USA */ -static const char rcsid[] = +static const char rcsid[] = "$Id$"; #include @@ -41,30 +41,30 @@ static const char rcsid[] = #include "qc-parse.h" -int lineno_base; +int lineno_base; -etype_t qc_types[] = { - ev_void, // ex_label - ev_void, // ex_block - ev_void, // ex_expr - ev_void, // ex_uexpr - ev_void, // ex_def - ev_void, // ex_temp - ev_void, // ex_nil +etype_t qc_types[] = { + ev_void, // ex_label + ev_void, // ex_block + ev_void, // ex_expr + ev_void, // ex_uexpr + ev_void, // ex_def + ev_void, // ex_temp + ev_void, // ex_nil - ev_string, // ex_string - ev_float, // ex_float - ev_vector, // ex_vector - ev_entity, // ex_entity - ev_field, // ex_field - ev_func, // ex_func - ev_pointer, // ex_pointer - ev_quaternion, // ex_quaternion - ev_integer, // ex_integer - ev_uinteger, // ex_uinteger + ev_string, // ex_string + ev_float, // ex_float + ev_vector, // ex_vector + ev_entity, // ex_entity + ev_field, // ex_field + ev_func, // ex_func + ev_pointer, // ex_pointer + ev_quaternion, // ex_quaternion + ev_integer, // ex_integer + ev_uinteger, // ex_uinteger }; -type_t *types[] = { +type_t *types[] = { &type_void, &type_string, &type_float, @@ -78,18 +78,18 @@ type_t *types[] = { &type_uinteger, }; -expr_type expr_types[] = { - ex_nil, // ev_void - ex_string, // ev_string - ex_float, // ev_float - ex_vector, // ev_vector - ex_entity, // ev_entity - ex_field, // ev_field - ex_func, // ev_func - ex_pointer, // ev_pointer - ex_quaternion, // ev_quaternion - ex_integer, // ev_integer - ex_uinteger, // ev_uinteger +expr_type expr_types[] = { + ex_nil, // ev_void + ex_string, // ev_string + ex_float, // ev_float + ex_vector, // ev_vector + ex_entity, // ev_entity + ex_field, // ev_field + ex_func, // ev_func + ex_pointer, // ev_pointer + ex_quaternion, // ev_quaternion + ex_integer, // ev_integer + ex_uinteger, // ev_uinteger }; type_t * @@ -97,7 +97,7 @@ get_type (expr_t *e) { switch (e->type) { case ex_label: - return 0; // something went very wrong + return 0; // something went very wrong case ex_nil: return &type_void; case ex_block: @@ -135,6 +135,7 @@ etype_t extract_type (expr_t *e) { type_t *type = get_type (e); + if (type) return type->type; return ev_type_count; @@ -144,9 +145,9 @@ expr_t * error (expr_t *e, const char *fmt, ...) { va_list args; - string_t file = s_file; - int line = pr_source_line; - + string_t file = s_file; + int line = pr_source_line; + va_start (args, fmt); if (e) { file = e->file; @@ -169,15 +170,15 @@ void warning (expr_t *e, const char *fmt, ...) { va_list args; - string_t file = s_file; - int line = pr_source_line; + string_t file = s_file; + int line = pr_source_line; if (options.warnings.promote) { - options.warnings.promote = 0; // only want to do this once + options.warnings.promote = 0; // only want to do this once fprintf (stderr, "%s: warnings treated as errors\n", "qfcc"); pr_error_count++; } - + va_start (args, fmt); if (e) { file = e->file; @@ -226,14 +227,15 @@ get_op_string (int op) case 'b': return ""; case 's': return ""; case 'c': return ""; - default: return "unknown"; + default: + return "unknown"; } } expr_t * type_mismatch (expr_t *e1, expr_t *e2, int op) { - etype_t t1, t2; + etype_t t1, t2; t1 = extract_type (e1); t2 = extract_type (e2); @@ -250,7 +252,7 @@ check_initialized (expr_t *e) && !(e->e.def->type->type == ev_func && !e->e.def->scope) && !e->e.def->initialized) { warning (e, "%s may be used uninitialized", e->e.def->name); - e->e.def->initialized = 1; // only warn once + e->e.def->initialized = 1; // only warn once } } } @@ -267,7 +269,8 @@ inc_users (expr_t *e) expr_t * new_expr (void) { - expr_t *e = calloc (1, sizeof (expr_t)); + expr_t *e = calloc (1, sizeof (expr_t)); + e->line = pr_source_line; e->file = s_file; return e; @@ -278,7 +281,7 @@ num_digits (int val) { int num = 1; -// printf ("%d ", val); +// printf ("%d ", val); if (val < 0) { num++; val = -val; @@ -287,7 +290,7 @@ num_digits (int val) val /= 10; num++; } -// printf ("%d\n", num); +// printf ("%d\n", num); return num; } @@ -299,6 +302,7 @@ new_label_name (void) const char *fname = current_func->def->name; int len = 1 + strlen (fname) + 1 + num_digits (lnum) + 1; char *lname = malloc (len); + if (!lname) Sys_Error ("new_label_expr: Memory Allocation Failure\n"); snprintf (lname, len, "$%s_%d", fname, lnum); @@ -309,7 +313,8 @@ expr_t * new_label_expr (void) { - expr_t *l = new_expr (); + expr_t *l = new_expr (); + l->type = ex_label; l->e.label.name = new_label_name (); return l; @@ -318,7 +323,7 @@ new_label_expr (void) expr_t * new_block_expr (void) { - expr_t *b = new_expr (); + expr_t *b = new_expr (); b->type = ex_block; b->e.block.head = 0; @@ -329,7 +334,7 @@ new_block_expr (void) expr_t * new_binary_expr (int op, expr_t *e1, expr_t *e2) { - expr_t *e = new_expr (); + expr_t *e = new_expr (); inc_users (e1); inc_users (e2); @@ -344,7 +349,7 @@ new_binary_expr (int op, expr_t *e1, expr_t *e2) expr_t * new_unary_expr (int op, expr_t *e1) { - expr_t *e = new_expr (); + expr_t *e = new_expr (); inc_users (e1); @@ -357,7 +362,7 @@ new_unary_expr (int op, expr_t *e1) expr_t * new_temp_def_expr (type_t *type) { - expr_t *e = new_expr (); + expr_t *e = new_expr (); e->type = ex_temp; e->e.temp.type = type; @@ -373,7 +378,7 @@ new_bind_expr (expr_t *e1, expr_t *e2) error (e1, "internal error"); abort (); } - //e = new_binary_expr ('b', e1, e2); + // e = new_binary_expr ('b', e1, e2); e = new_expr (); e->type = ex_expr; e->e.expr.op = 'b'; @@ -422,14 +427,15 @@ print_expr (expr_t *e) printf ("{\n"); for (e = e->e.block.head; e; e = e->next) { print_expr (e); - puts(""); + puts (""); } printf ("}"); break; case ex_expr: print_expr (e->e.expr.e1); if (e->e.expr.op == 'c') { - expr_t *p = e->e.expr.e2; + expr_t *p = e->e.expr.e2; + printf ("("); while (p) { print_expr (p); @@ -466,14 +472,14 @@ print_expr (expr_t *e) printf (":"); if (e->e.temp.def) { if (e->e.temp.def->name) { - printf("%s", e->e.temp.def->name); + printf ("%s", e->e.temp.def->name); } else { - printf("<%d>", e->e.temp.def->ofs); + printf ("<%d>", e->e.temp.def->ofs); } } else { - printf("<>"); + printf ("<>"); } - printf (":%s:%d)@", type_name [e->e.temp.type->type], + printf (":%s:%d)@", type_name[e->e.temp.type->type], e->e.temp.users); break; case ex_nil: @@ -512,13 +518,13 @@ print_expr (expr_t *e) static expr_t * do_op_string (int op, expr_t *e1, expr_t *e2) { - int len; - char *buf; + int len; + char *buf; const char *s1, *s2; s1 = e1->e.string_val ? e1->e.string_val : ""; s2 = e2->e.string_val ? e2->e.string_val : ""; - + switch (op) { case '+': len = strlen (s1) + strlen (s2) + 1; @@ -562,11 +568,11 @@ do_op_string (int op, expr_t *e1, expr_t *e2) static expr_t * do_op_float (int op, expr_t *e1, expr_t *e2) { - float f1, f2; + float f1, f2; f1 = e1->e.float_val; f2 = e2->e.float_val; - + switch (op) { case '+': e1->e.float_val += f2; @@ -581,22 +587,22 @@ do_op_float (int op, expr_t *e1, expr_t *e2) e1->e.float_val /= f2; break; case '&': - e1->e.float_val = (int)f1 & (int)f2; + e1->e.float_val = (int) f1 & (int) f2; break; case '|': - e1->e.float_val = (int)f1 | (int)f2; + e1->e.float_val = (int) f1 | (int) f2; break; case '^': - e1->e.float_val = (int)f1 ^ (int)f2; + e1->e.float_val = (int) f1 ^ (int) f2; break; case '%': - e1->e.float_val = (int)f1 % (int)f2; + e1->e.float_val = (int) f1 % (int) f2; break; case SHL: - e1->e.float_val = (int)f1 << (int)f2; + e1->e.float_val = (int) f1 << (int) f2; break; case SHR: - e1->e.float_val = (int)f1 >> (int)f2; + e1->e.float_val = (int) f1 >> (int) f2; break; case AND: e1->type = ex_integer; @@ -639,11 +645,11 @@ do_op_float (int op, expr_t *e1, expr_t *e2) static expr_t * do_op_vector (int op, expr_t *e1, expr_t *e2) { - float *v1, *v2; + float *v1, *v2; v1 = e1->e.vector_val; v2 = e2->e.vector_val; - + switch (op) { case '+': VectorAdd (v1, v2, v1); @@ -658,14 +664,14 @@ do_op_vector (int op, expr_t *e1, expr_t *e2) case EQ: e1->type = ex_integer; e1->e.integer_val = (v1[0] == v2[0]) - && (v1[1] == v2[1]) - && (v1[2] == v2[2]); + && (v1[1] == v2[1]) + && (v1[2] == v2[2]); break; case NE: e1->type = ex_integer; e1->e.integer_val = (v1[0] == v2[0]) - || (v1[1] != v2[1]) - || (v1[2] != v2[2]); + || (v1[1] != v2[1]) + || (v1[2] != v2[2]); break; default: return error (e1, "invalid operand for vector"); @@ -676,11 +682,11 @@ do_op_vector (int op, expr_t *e1, expr_t *e2) static expr_t * do_op_integer (int op, expr_t *e1, expr_t *e2) { - int i1, i2; + int i1, i2; i1 = e1->e.integer_val; i2 = e2->e.integer_val; - + switch (op) { case '+': e1->e.integer_val += i2; @@ -771,14 +777,13 @@ static expr_t *(*do_op[]) (int op, expr_t *e1, expr_t *e2) = { static expr_t * binary_const (int op, expr_t *e1, expr_t *e2) { - etype_t t1, t2; - //expr_t *e; + etype_t t1, t2; t1 = extract_type (e1); t2 = extract_type (e2); if (t1 == t2) { - return do_op[t1](op, e1, e2); + return do_op[t1] (op, e1, e2); } else { return type_mismatch (e1, e2, op); } @@ -787,8 +792,8 @@ binary_const (int op, expr_t *e1, expr_t *e2) static expr_t * field_expr (expr_t *e1, expr_t *e2) { - etype_t t1, t2; - expr_t *e; + etype_t t1, t2; + expr_t *e; t1 = extract_type (e1); t2 = extract_type (e2); @@ -809,7 +814,7 @@ field_expr (expr_t *e1, expr_t *e2) expr_t * test_expr (expr_t *e, int test) { - expr_t *new = 0; + expr_t *new = 0; check_initialized (e); @@ -891,10 +896,9 @@ binary_expr (int op, expr_t *e1, expr_t *e2) PR_DefInitialized (e1->e.def); if (e1->type == ex_block && e1->e.block.is_call - && e2->type == ex_block && e2->e.block.is_call - && e1->e.block.result) { + && e2->type == ex_block && e2->e.block.is_call && e1->e.block.result) { e = new_temp_def_expr (e1->e.block.result->e.def->type); - inc_users (e); // for the block itself + inc_users (e); // for the block itself e1 = binary_expr ('=', e, e1); } @@ -932,7 +936,8 @@ binary_expr (int op, expr_t *e1, expr_t *e2) if ((op == '&' || op == '|') && e1->type == ex_uexpr && e1->e.expr.op == '!' && !e1->paren) { - warning (e1, "ambiguous logic. Suggest explicit parentheses with expressions involving ! and %c", op); + warning (e1, "ambiguous logic. Suggest explicit parentheses with " + "expressions involving ! and %c", op); } if (op == '=' && t1->type != ev_void && e2->type == ex_nil) { @@ -973,7 +978,7 @@ binary_expr (int op, expr_t *e1, expr_t *e2) } break; default: -type_mismatch: + type_mismatch: return type_mismatch (e1, e2, op); } } else { @@ -988,7 +993,7 @@ type_mismatch: type = &type_float; } if (op == '=' && e1->type == ex_expr && e1->e.expr.op == '.') { - if (get_type(e1->e.expr.e1) == &type_entity) { + if (get_type (e1->e.expr.e1) == &type_entity) { type_t new; memset (&new, 0, sizeof (new)); @@ -1008,7 +1013,8 @@ type_mismatch: expr_t * asx_expr (int op, expr_t *e1, expr_t *e2) { - expr_t *e = new_expr (); + expr_t *e = new_expr (); + *e = *e1; return binary_expr ('=', e, binary_expr (op, e1, e2)); } @@ -1033,10 +1039,10 @@ unary_expr (int op, expr_t *e) case ex_def: case ex_temp: { - expr_t *n = new_unary_expr (op, e); + expr_t *n = new_unary_expr (op, e); + n->e.expr.type = (e->type == ex_def) - ? e->e.def->type - : e->e.expr.type; + ? e->e.def->type : e->e.expr.type; return n; } case ex_integer: @@ -1078,7 +1084,8 @@ unary_expr (int op, expr_t *e) case ex_def: case ex_temp: { - expr_t *n = new_unary_expr (op, e); + expr_t *n = new_unary_expr (op, e); + if (options.code.progsversion > PROG_ID_VERSION) n->e.expr.type = &type_integer; else @@ -1101,15 +1108,15 @@ unary_expr (int op, expr_t *e) return e; case ex_vector: e->e.integer_val = !e->e.vector_val[0] - && !e->e.vector_val[1] - && !e->e.vector_val[2]; + && !e->e.vector_val[1] + && !e->e.vector_val[2]; e->type = ex_integer; return e; case ex_quaternion: e->e.integer_val = !e->e.quaternion_val[0] - && !e->e.quaternion_val[1] - && !e->e.quaternion_val[2] - && !e->e.quaternion_val[3]; + && !e->e.quaternion_val[1] + && !e->e.quaternion_val[2] + && !e->e.quaternion_val[3]; e->type = ex_integer; return e; case ex_entity: @@ -1134,8 +1141,9 @@ unary_expr (int op, expr_t *e) case ex_def: case ex_temp: { - expr_t *n = new_unary_expr (op, e); - type_t *t = get_type (e); + expr_t *n = new_unary_expr (op, e); + type_t *t = get_type (e); + if (t != &type_integer && t != &type_float) return error (e, "invalid type for unary ~"); n->e.expr.type = t; @@ -1146,7 +1154,7 @@ unary_expr (int op, expr_t *e) e->e.integer_val = ~e->e.integer_val; return e; case ex_float: - e->e.float_val = ~(int)e->e.float_val; + e->e.float_val = ~(int) e->e.float_val; e->type = ex_integer; return e; case ex_nil: @@ -1217,10 +1225,10 @@ function_expr (expr_t *e1, expr_t *e2) } if (e1->type == ex_def && e2 && e2->type == ex_string) { - //FIXME eww, I hate this, but it's needed :( - //FIXME make a qc hook? :) - def_t *func = e1->e.def; - def_t *e = PR_ReuseConstant (e2, 0); + // FIXME eww, I hate this, but it's needed :( + // FIXME make a qc hook? :) + def_t *func = e1->e.def; + def_t *e = PR_ReuseConstant (e2, 0); if (strncmp (func->name, "precache_sound", 14) == 0) PrecacheSound (e, func->name[4]); @@ -1230,9 +1238,7 @@ function_expr (expr_t *e1, expr_t *e2) PrecacheFile (e, func->name[13]); } - ftype = e1->type == ex_def - ? e1->e.def->type - : e1->e.expr.type; + ftype = e1->type == ex_def ? e1->e.def->type : e1->e.expr.type; for (e = e2; e; e = e->next) parm_count++; @@ -1247,7 +1253,7 @@ function_expr (expr_t *e1, expr_t *e2) } } for (i = parm_count, e = e2; i > 0; i--, e = e->next) { - type_t *t = get_type (e); + type_t *t = get_type (e); if (ftype->parm_types[i - 1] == &type_float && e->type == ex_integer) { e->type = ex_float; @@ -1263,8 +1269,8 @@ function_expr (expr_t *e1, expr_t *e2) err = error (e, "type mismatch for parameter %d of %s", i, e1->e.def->name); } else { - //if (e->type == ex_integer) - // warning (e, "passing integer consant into ... function"); + if (e->type == ex_integer && options.warnings.vararg_integer) + warning (e, "passing integer consant into ... function"); } arg_types[parm_count - i] = t; } @@ -1285,8 +1291,7 @@ function_expr (expr_t *e1, expr_t *e2) a = &(*a)->next; } for (i = 0; i < arg_expr_count - 1; i++) { - append_expr (call, binary_expr ('=', arg_exprs[i][1], - arg_exprs[i][0])); + append_expr (call, binary_expr ('=', arg_exprs[i][1], arg_exprs[i][0])); } if (arg_expr_count) { e = new_bind_expr (arg_exprs[arg_expr_count - 1][0], @@ -1300,8 +1305,10 @@ function_expr (expr_t *e1, expr_t *e2) append_expr (call, e); if (ftype->aux_type != &type_void) { expr_t *ret = new_expr (); + ret->type = ex_def; ret->e.def = memcpy (malloc (sizeof (def_t)), &def_ret, sizeof (def_t)); + if (!ret->e.def) Sys_Error ("function_expr: Memory Allocation Failure\n"); ret->e.def->type = ftype->aux_type; @@ -1317,7 +1324,7 @@ return_expr (function_t *f, expr_t *e) if (f->def->type->aux_type != &type_void) return error (e, "return from non-void function without a value"); } else { - type_t *t = get_type (e); + type_t *t = get_type (e); if (f->def->type->aux_type == &type_void) return error (e, "returning a value for a void function"); @@ -1332,7 +1339,7 @@ return_expr (function_t *f, expr_t *e) } if (f->def->type->aux_type != t) return error (e, "type mismatch for return value of %s", - f->def->name); + f->def->name); } return new_unary_expr ('r', e); } @@ -1340,11 +1347,11 @@ return_expr (function_t *f, expr_t *e) expr_t * conditional_expr (expr_t *cond, expr_t *e1, expr_t *e2) { - expr_t *block = new_block_expr (); - type_t *type1 = get_type (e1); - type_t *type2 = get_type (e2); - expr_t *tlabel = new_label_expr (); - expr_t *elabel = new_label_expr (); + expr_t *block = new_block_expr (); + type_t *type1 = get_type (e1); + type_t *type2 = get_type (e2); + expr_t *tlabel = new_label_expr (); + expr_t *elabel = new_label_expr (); block->e.block.result = (type1 == type2) ? new_temp_def_expr (type1) : 0; append_expr (block, new_binary_expr ('i', test_expr (cond, 1), tlabel)); @@ -1368,7 +1375,7 @@ incop_expr (int op, expr_t *e, int postop) expr_t *one = new_expr (); expr_t *incop; - one->type = ex_integer; // integer constants get auto-cast to float + one->type = ex_integer; // integer constants get auto-cast to float one->e.integer_val = 1; incop = asx_expr (op, e, one); if (postop) { @@ -1399,11 +1406,11 @@ array_expr (expr_t *array, expr_t *index) return error (index, "invalid array index type"); if (index->type >= ex_integer && index->e.uinteger_val >= array_type->num_parms) - return error (index, "array index out of bounds"); + return error (index, "array index out of bounds"); size = pr_type_size[array_type->aux_type->type]; if (size > 1) { scale = new_expr (); - scale->type = expr_types [index_type->type]; + scale->type = expr_types[index_type->type]; scale->e.integer_val = size; index = binary_expr ('*', index, scale); } diff --git a/tools/qfcc/source/pr_comp.c b/tools/qfcc/source/pr_comp.c index 76c876e31..0cfe1c30f 100644 --- a/tools/qfcc/source/pr_comp.c +++ b/tools/qfcc/source/pr_comp.c @@ -30,8 +30,8 @@ static const char rcsid[] = void PrecacheSound (def_t *e, int ch) { - char *n; - int i; + char *n; + int i; if (!e->ofs) return; @@ -59,8 +59,8 @@ PrecacheSound (def_t *e, int ch) void PrecacheModel (def_t *e, int ch) { - char *n; - int i; + char *n; + int i; if (!e->ofs) return; @@ -88,8 +88,8 @@ PrecacheModel (def_t *e, int ch) void PrecacheFile (def_t *e, int ch) { - char *n; - int i; + char *n; + int i; if (!e->ofs) return; diff --git a/tools/qfcc/source/pr_def.c b/tools/qfcc/source/pr_def.c index 9ab679b65..4b3535737 100644 --- a/tools/qfcc/source/pr_def.c +++ b/tools/qfcc/source/pr_def.c @@ -29,22 +29,22 @@ static const char rcsid[] = typedef struct locref_s { struct locref_s *next; - int ofs; + int ofs; } locref_t; -def_t *pr_global_defs[MAX_REGS]; // to find def for a global variable -static def_t *free_temps[4]; // indexted by type size +def_t *pr_global_defs[MAX_REGS]; // to find def for a global variable +static def_t *free_temps[4]; // indexted by type size static def_t temp_scope; -static locref_t *free_locs[4]; // indexted by type size +static locref_t *free_locs[4]; // indexted by type size static locref_t *free_free_locs; -static hashtab_t *defs_by_name; +static hashtab_t *defs_by_name; static const char * defs_get_key (void *_def, void *_tab) { - def_t *def = (def_t*)_def; - hashtab_t **tab = (hashtab_t**) _tab; + def_t *def = (def_t *) _def; + hashtab_t **tab = (hashtab_t **) _tab; if (tab == &defs_by_name) { return def->name; @@ -55,14 +55,13 @@ defs_get_key (void *_def, void *_tab) static def_t * check_for_name (type_t *type, const char *name, def_t *scope, int *allocate) { - def_t *def; + def_t *def; if (!defs_by_name) { defs_by_name = Hash_NewTable (16381, defs_get_key, 0, &defs_by_name); } - // see if the name is already in use - def = (def_t*) Hash_Find (defs_by_name, name); + def = (def_t *) Hash_Find (defs_by_name, name); if (def) { if (allocate && scope == def->scope) if (type && def->type != type) @@ -77,6 +76,7 @@ static inline type_t * find_type (type_t *type, type_t *aux_type) { type_t new; + memset (&new, 0, sizeof (new)); new.type = type->type; new.aux_type = aux_type; @@ -88,14 +88,15 @@ def_t * PR_GetArray (type_t *etype, const char *name, int size, def_t *scope, int *allocate) { - type_t *type = find_type (&type_pointer, etype); - def_t *def = check_for_name (type, name, scope, allocate); + type_t *type = find_type (&type_pointer, etype); + def_t *def = check_for_name (type, name, scope, allocate); + if (def || !allocate) return def; def = PR_NewDef (type, name, scope); def->ofs = *allocate; def->initialized = def->constant = 1; - *allocate += pr_type_size [type->type] * size + 1; + *allocate += pr_type_size[type->type] * size + 1; pr_global_defs[def->ofs] = def; G_INT (def->ofs) = def->ofs + 1; return def; @@ -110,8 +111,8 @@ PR_GetArray (type_t *etype, const char *name, int size, def_t *scope, def_t * PR_GetDef (type_t *type, const char *name, def_t *scope, int *allocate) { - def_t *def = check_for_name (type, name, scope, allocate); - char element[MAX_NAME]; + def_t *def = check_for_name (type, name, scope, allocate); + char element[MAX_NAME]; if (def || !allocate) return def; @@ -120,13 +121,13 @@ PR_GetDef (type_t *type, const char *name, def_t *scope, int *allocate) def = PR_NewDef (type, name, scope); Hash_Add (defs_by_name, def); - //FIXME: need to sort out location re-use + // FIXME: need to sort out location re-use def->ofs = *allocate; pr_global_defs[*allocate] = def; - /* - make automatic defs for the vectors elements - .origin can be accessed as .origin_x, .origin_y, and .origin_z + /* + make automatic defs for the vectors elements .origin can be accessed + as .origin_x, .origin_y, and .origin_z */ if (type->type == ev_vector) { def_t *d; @@ -157,21 +158,21 @@ PR_GetDef (type_t *type, const char *name, def_t *scope, int *allocate) snprintf (element, sizeof (element), "%s_x", name); d = PR_GetDef (&type_floatfield, element, scope, allocate); - d->used = 1; // always `used' + d->used = 1; // always `used' d->parent = def; snprintf (element, sizeof (element), "%s_y", name); d = PR_GetDef (&type_floatfield, element, scope, allocate); - d->used = 1; // always `used' + d->used = 1; // always `used' d->parent = def; snprintf (element, sizeof (element), "%s_z", name); d = PR_GetDef (&type_floatfield, element, scope, allocate); - d->used = 1; // always `used' + d->used = 1; // always `used' d->parent = def; } else if (type->aux_type->type == ev_pointer) { pr.size_fields += type->aux_type->num_parms - * pr_type_size[type->aux_type->aux_type->type]; + * pr_type_size[type->aux_type->aux_type->type]; } else { pr.size_fields += pr_type_size[type->aux_type->type]; } @@ -186,7 +187,7 @@ PR_GetDef (type_t *type, const char *name, def_t *scope, int *allocate) def_t * PR_NewDef (type_t *type, const char *name, def_t *scope) { - def_t *def; + def_t *def; def = calloc (1, sizeof (def_t)); @@ -214,8 +215,8 @@ PR_NewDef (type_t *type, const char *name, def_t *scope) int PR_NewLocation (type_t *type) { - int size = pr_type_size[type->type]; - locref_t *loc; + int size = pr_type_size[type->type]; + locref_t *loc; if (free_locs[size]) { loc = free_locs[size]; @@ -233,11 +234,12 @@ PR_NewLocation (type_t *type) void PR_FreeLocation (def_t *def) { - int size = pr_type_size[def->type->type]; - locref_t *loc; + int size = pr_type_size[def->type->type]; + locref_t *loc; if (!free_free_locs) { free_free_locs = malloc (256 * sizeof (locref_t)); + if (!free_free_locs) Sys_Error ("PR_FreeLocation: Memory Allocation Failure\n"); for (loc = free_free_locs; loc - free_free_locs < 255; loc++) @@ -254,8 +256,9 @@ PR_FreeLocation (def_t *def) def_t * PR_GetTempDef (type_t *type, def_t *scope) { - int size = pr_type_size[type->type]; - def_t *def; + int size = pr_type_size[type->type]; + def_t *def; + if (free_temps[size]) { def = free_temps[size]; free_temps[size] = def->next; @@ -274,8 +277,8 @@ PR_GetTempDef (type_t *type, def_t *scope) void PR_FreeTempDefs (void) { - def_t **def, *d; - int size; + def_t **def, *d; + int size; def = &temp_scope.next; while (*def) { @@ -284,7 +287,8 @@ PR_FreeTempDefs (void) *def = d->next; if (d->users < 0) - printf ("%s:%d: warning: %s %3d %3d\n", strings + d->file, d->line, type_name[d->type->type], d->ofs, d->users); + printf ("%s:%d: warning: %s %3d %3d\n", strings + d->file, + d->line, type_name[d->type->type], d->ofs, d->users); size = pr_type_size[d->type->type]; if (d->expr) d->expr->e.temp.def = 0; @@ -303,27 +307,29 @@ PR_FreeTempDefs (void) void PR_ResetTempDefs (void) { - int i; - def_t *d; + int i; + def_t *d; for (i = 0; i < sizeof (free_temps) / sizeof (free_temps[0]); i++) { free_temps[i] = 0; } for (d = temp_scope.next; d; d = d->next) - printf ("%s:%d: warning: %s %3d %3d\n", strings + d->file, d->line, type_name[d->type->type], d->ofs, d->users); + printf ("%s:%d: warning: %s %3d %3d\n", strings + d->file, d->line, + type_name[d->type->type], d->ofs, d->users); temp_scope.next = 0; } void PR_FlushScope (def_t *scope, int force_used) { - def_t *def; + def_t *def; for (def = scope->scope_next; def; def = def->scope_next) { if (def->name) { if (!force_used && !def->used) { - expr_t e; + expr_t e; + e.line = def->line; e.file = def->file; warning (&e, "unused variable `%s'", def->name); @@ -341,8 +347,7 @@ PR_DefInitialized (def_t *d) { d->initialized = 1; if (d->type == &type_vector - || (d->type->type == ev_field - && d->type->aux_type == &type_vector)) { + || (d->type->type == ev_field && d->type->aux_type == &type_vector)) { d = d->def_next; d->initialized = 1; d = d->def_next; diff --git a/tools/qfcc/source/pr_imm.c b/tools/qfcc/source/pr_imm.c index 04b851c21..6943341aa 100644 --- a/tools/qfcc/source/pr_imm.c +++ b/tools/qfcc/source/pr_imm.c @@ -26,73 +26,78 @@ static const char rcsid[] = #include "qfcc.h" -static hashtab_t *string_imm_defs; -static hashtab_t *float_imm_defs; -static hashtab_t *vector_imm_defs; -static hashtab_t *entity_imm_defs; -static hashtab_t *field_imm_defs; -static hashtab_t *func_imm_defs; -static hashtab_t *pointer_imm_defs; -static hashtab_t *quaternion_imm_defs; -static hashtab_t *integer_imm_defs; +static hashtab_t *string_imm_defs; +static hashtab_t *float_imm_defs; +static hashtab_t *vector_imm_defs; +static hashtab_t *entity_imm_defs; +static hashtab_t *field_imm_defs; +static hashtab_t *func_imm_defs; +static hashtab_t *pointer_imm_defs; +static hashtab_t *quaternion_imm_defs; +static hashtab_t *integer_imm_defs; static const char * string_imm_get_key (void *_def, void *unused) { - def_t *def = (def_t*)_def; + def_t *def = (def_t *) _def; + return G_STRING (def->ofs); } static const char * float_imm_get_key (void *_def, void *unused) { - def_t *def = (def_t*)_def; + def_t *def = (def_t *) _def; static char rep[20]; - snprintf (rep, sizeof (rep), "\001float:%08X\001", G_INT(def->ofs)); + + snprintf (rep, sizeof (rep), "\001float:%08X\001", G_INT (def->ofs)); return rep; } static const char * vector_imm_get_key (void *_def, void *unused) { - def_t *def = (def_t*)_def; + def_t *def = (def_t *) _def; static char rep[60]; + snprintf (rep, sizeof (rep), "\001vector:%08X\001%08X\001%08X\001", - G_INT(def->ofs), G_INT(def->ofs+1), G_INT(def->ofs+2)); + G_INT (def->ofs), G_INT (def->ofs + 1), G_INT (def->ofs + 2)); return rep; } static const char * quaternion_imm_get_key (void *_def, void *unused) { - def_t *def = (def_t*)_def; + def_t *def = (def_t *) _def; static char rep[60]; + snprintf (rep, sizeof (rep), - "\001quaternion:%08X\001%08X\001%08X\001%08X\001", - G_INT(def->ofs), G_INT(def->ofs+1), - G_INT(def->ofs+2), G_INT(def->ofs+3)); + "\001quaternion:%08X\001%08X\001%08X\001%08X\001", + G_INT (def->ofs), G_INT (def->ofs + 1), + G_INT (def->ofs + 2), G_INT (def->ofs + 3)); return rep; } static const char * int_imm_get_key (void *_def, void *_str) { - def_t *def = (def_t*)_def; + def_t *def = (def_t *) _def; static char rep[60]; - char *str = (char*)_str; - snprintf (rep, sizeof (rep), "\001%s:%08X\001", str, G_INT(def->ofs)); + char *str = (char *) _str; + + snprintf (rep, sizeof (rep), "\001%s:%08X\001", str, G_INT (def->ofs)); return rep; } def_t * PR_ReuseConstant (expr_t *expr, def_t *def) { - def_t *cn = 0; - char rep[60]; + def_t *cn = 0; + char rep[60]; const char *r = rep; - hashtab_t *tab = 0; - type_t *type; - expr_t e = *expr; + hashtab_t *tab = 0; + type_t *type; + expr_t e = *expr; if (!string_imm_defs) { string_imm_defs = Hash_NewTable (16381, string_imm_get_key, 0, 0); @@ -102,7 +107,8 @@ PR_ReuseConstant (expr_t *expr, def_t *def) field_imm_defs = Hash_NewTable (16381, int_imm_get_key, 0, "field"); func_imm_defs = Hash_NewTable (16381, int_imm_get_key, 0, "func"); pointer_imm_defs = Hash_NewTable (16381, int_imm_get_key, 0, "pointer"); - quaternion_imm_defs = Hash_NewTable (16381, quaternion_imm_get_key, 0, 0); + quaternion_imm_defs = + Hash_NewTable (16381, quaternion_imm_get_key, 0, 0); integer_imm_defs = Hash_NewTable (16381, int_imm_get_key, 0, "integer"); Hash_Add (string_imm_defs, PR_NewDef (&type_string, ".imm", 0)); @@ -113,7 +119,8 @@ PR_ReuseConstant (expr_t *expr, def_t *def) } switch (e.type) { case ex_entity: - snprintf (rep, sizeof (rep), "\001entity:%08X\001", e.e.integer_val); + snprintf (rep, sizeof (rep), "\001entity:%08X\001", + e.e.integer_val); tab = entity_imm_defs; type = &type_entity; break; @@ -128,14 +135,16 @@ PR_ReuseConstant (expr_t *expr, def_t *def) type = &type_function; break; case ex_pointer: - snprintf (rep, sizeof (rep), "\001pointer:%08X\001", e.e.integer_val); + snprintf (rep, sizeof (rep), "\001pointer:%08X\001", + e.e.integer_val); tab = pointer_imm_defs; type = &type_pointer; break; case ex_integer: case ex_uinteger: if (!def || def->type != &type_float) { - snprintf (rep, sizeof (rep), "\001integer:%08X\001", e.e.integer_val); + snprintf (rep, sizeof (rep), "\001integer:%08X\001", + e.e.integer_val); tab = integer_imm_defs; if (e.type == ex_uinteger) type = &type_uinteger; @@ -159,25 +168,25 @@ PR_ReuseConstant (expr_t *expr, def_t *def) break; case ex_vector: snprintf (rep, sizeof (rep), "\001vector:%08X\001%08X\001%08X\001", - *(int*)&e.e.vector_val[0], - *(int*)&e.e.vector_val[1], - *(int*)&e.e.vector_val[2]); + *(int *) &e.e.vector_val[0], + *(int *) &e.e.vector_val[1], *(int *) &e.e.vector_val[2]); tab = vector_imm_defs; type = &type_vector; break; case ex_quaternion: - snprintf (rep, sizeof (rep), "\001quaternion:%08X\001%08X\001%08X\001%08X\001", - *(int*)&e.e.quaternion_val[0], - *(int*)&e.e.quaternion_val[1], - *(int*)&e.e.quaternion_val[2], - *(int*)&e.e.quaternion_val[3]); + snprintf (rep, sizeof (rep), + "\001quaternion:%08X\001%08X\001%08X\001%08X\001", + *(int *) &e.e.quaternion_val[0], + *(int *) &e.e.quaternion_val[1], + *(int *) &e.e.quaternion_val[2], + *(int *) &e.e.quaternion_val[3]); tab = vector_imm_defs; type = &type_quaternion; break; default: abort (); } - cn = (def_t*) Hash_Find (tab, r); + cn = (def_t *) Hash_Find (tab, r); if (cn) { if (def) { PR_FreeLocation (def); @@ -207,9 +216,9 @@ PR_ReuseConstant (expr_t *expr, def_t *def) cn->ofs = PR_NewLocation (type); pr_global_defs[cn->ofs] = cn; if (type == &type_vector || type == &type_quaternion) { - int i; + int i; - for (i = 0; i< 3 + (type == &type_quaternion); i++) + for (i = 0; i < 3 + (type == &type_quaternion); i++) PR_NewDef (&type_float, ".imm", 0); } } diff --git a/tools/qfcc/source/pr_lex.c b/tools/qfcc/source/pr_lex.c index bdc8827b1..8a658c381 100644 --- a/tools/qfcc/source/pr_lex.c +++ b/tools/qfcc/source/pr_lex.c @@ -34,56 +34,57 @@ #include "qfcc.h" -int pr_source_line; +int pr_source_line; -char pr_parm_names[MAX_PARMS][MAX_NAME]; +char pr_parm_names[MAX_PARMS][MAX_NAME]; -char *pr_file_p; -char *pr_line_start; // start of current source line +char *pr_file_p; +char *pr_line_start; // start of current source line -int pr_bracelevel; +int pr_bracelevel; -char pr_token[2048]; -int pr_token_len; -token_type_t pr_token_type; -type_t *pr_immediate_type; -eval_t pr_immediate; +char pr_token[2048]; +int pr_token_len; +token_type_t pr_token_type; +type_t *pr_immediate_type; +eval_t pr_immediate; -char pr_immediate_string[2048]; +char pr_immediate_string[2048]; -int pr_error_count; +int pr_error_count; // simple types. function types are dynamically allocated -type_t type_void = { ev_void, &def_void }; -type_t type_string = { ev_string, &def_string }; -type_t type_float = { ev_float, &def_float }; -type_t type_vector = { ev_vector, &def_vector }; -type_t type_entity = { ev_entity, &def_entity }; -type_t type_field = { ev_field, &def_field }; +type_t type_void = { ev_void, &def_void }; +type_t type_string = { ev_string, &def_string }; +type_t type_float = { ev_float, &def_float }; +type_t type_vector = { ev_vector, &def_vector }; +type_t type_entity = { ev_entity, &def_entity }; +type_t type_field = { ev_field, &def_field }; + // type_function is a void() function used for state defs -type_t type_function = { ev_func, &def_function, NULL, &type_void }; -type_t type_pointer = { ev_pointer, &def_pointer }; -type_t type_quaternion = { ev_quaternion, &def_quaternion }; -type_t type_integer = { ev_integer, &def_integer }; -type_t type_uinteger = { ev_uinteger, &def_uinteger }; +type_t type_function = { ev_func, &def_function, NULL, &type_void }; +type_t type_pointer = { ev_pointer, &def_pointer }; +type_t type_quaternion = { ev_quaternion, &def_quaternion }; +type_t type_integer = { ev_integer, &def_integer }; +type_t type_uinteger = { ev_uinteger, &def_uinteger }; -type_t type_floatfield = { ev_field, &def_field, NULL, &type_float }; +type_t type_floatfield = { ev_field, &def_field, NULL, &type_float }; -def_t def_void = { &type_void, "temp" }; -def_t def_string = { &type_string, "temp" }; -def_t def_float = { &type_float, "temp" }; -def_t def_vector = { &type_vector, "temp" }; -def_t def_entity = { &type_entity, "temp" }; -def_t def_field = { &type_field, "temp" }; -def_t def_function = { &type_function, "temp" }; -def_t def_pointer = { &type_pointer, "temp" }; -def_t def_quaternion = { &type_quaternion, "temp"}; -def_t def_integer = { &type_integer, "temp"}; -def_t def_uinteger = { &type_uinteger, "temp"}; +def_t def_void = { &type_void, "temp" }; +def_t def_string = { &type_string, "temp" }; +def_t def_float = { &type_float, "temp" }; +def_t def_vector = { &type_vector, "temp" }; +def_t def_entity = { &type_entity, "temp" }; +def_t def_field = { &type_field, "temp" }; +def_t def_function = { &type_function, "temp" }; +def_t def_pointer = { &type_pointer, "temp" }; +def_t def_quaternion = { &type_quaternion, "temp" }; +def_t def_integer = { &type_integer, "temp" }; +def_t def_uinteger = { &type_uinteger, "temp" }; -def_t def_ret, def_parms[MAX_PARMS]; +def_t def_ret, def_parms[MAX_PARMS]; -def_t *def_for_type[8] = { +def_t *def_for_type[8] = { &def_void, &def_string, &def_float, &def_vector, &def_entity, &def_field, &def_function, &def_pointer }; @@ -97,9 +98,9 @@ void PR_LexString (void) { int c; - int i; - int mask; - int boldnext; + int i; + int mask; + int boldnext; pr_token_len = 0; mask = 0x00; @@ -132,8 +133,8 @@ PR_LexString (void) case '6': case '7': for (i = c = 0; i < 3 - && *pr_file_p >= '0' - && *pr_file_p <='7'; i++, pr_file_p++) { + && *pr_file_p >= '0' + && *pr_file_p <= '7'; i++, pr_file_p++) { c *= 8; c += *pr_file_p - '0'; } @@ -210,9 +211,10 @@ PR_LexString (void) void PR_PrintType (type_t *type) { - int i; + int i; + if (!type) { - printf("(null)"); + printf ("(null)"); return; } switch (type->type) { @@ -266,9 +268,9 @@ PR_PrintType (type_t *type) type_t * PR_FindType (type_t *type) { - def_t *def; - type_t *check; - int i; + def_t *def; + type_t *check; + int i; for (check = pr.types; check; check = check->next) { if (check->type != type->type @@ -300,6 +302,7 @@ PR_FindType (type_t *type) // allocate a generic def for the type, so fields can reference it def = malloc (sizeof (def_t)); + if (!check) Sys_Error ("PR_FindType: Memory Allocation Failure\n"); def->name = "COMPLEX TYPE"; diff --git a/tools/qfcc/source/pr_opcode.c b/tools/qfcc/source/pr_opcode.c index 80c5b30a4..c86ee2d5a 100644 --- a/tools/qfcc/source/pr_opcode.c +++ b/tools/qfcc/source/pr_opcode.c @@ -27,26 +27,27 @@ static const char rcsid[] = #include "qfcc.h" -hashtab_t *opcode_type_table_ab; -hashtab_t *opcode_type_table_abc; +hashtab_t *opcode_type_table_ab; +hashtab_t *opcode_type_table_abc; -opcode_t *op_done; -opcode_t *op_return; -opcode_t *op_if; -opcode_t *op_ifnot; -opcode_t *op_ifbe; -opcode_t *op_ifb; -opcode_t *op_ifae; -opcode_t *op_ifa; -opcode_t *op_state; -opcode_t *op_goto; -opcode_t *op_jump; -opcode_t *op_jumpb; +opcode_t *op_done; +opcode_t *op_return; +opcode_t *op_if; +opcode_t *op_ifnot; +opcode_t *op_ifbe; +opcode_t *op_ifb; +opcode_t *op_ifae; +opcode_t *op_ifa; +opcode_t *op_state; +opcode_t *op_goto; +opcode_t *op_jump; +opcode_t *op_jumpb; statref_t * PR_NewStatref (dstatement_t *st, int field) { - statref_t *ref = calloc (1, sizeof (statref_t)); + statref_t *ref = calloc (1, sizeof (statref_t)); + ref->statement = st; ref->field = field; return ref; @@ -56,7 +57,8 @@ void PR_AddStatementRef (def_t *def, dstatement_t *st, int field) { if (def) { - statref_t *ref = PR_NewStatref (st, field); + statref_t *ref = PR_NewStatref (st, field); + ref->next = def->refs; def->refs = ref; @@ -70,15 +72,15 @@ PR_AddStatementRef (def_t *def, dstatement_t *st, int field) static unsigned long get_hash (void *_op, void *_tab) { - opcode_t *op = (opcode_t *)_op; - hashtab_t **tab = (hashtab_t **)_tab; + opcode_t *op = (opcode_t *) _op; + hashtab_t **tab = (hashtab_t **) _tab; unsigned long hash; if (tab == &opcode_type_table_ab) { - hash = ROTL(~op->type_a, 8) + ROTL(~op->type_b, 16); + hash = ROTL (~op->type_a, 8) + ROTL (~op->type_b, 16); } else if (tab == &opcode_type_table_abc) { - hash = ROTL(~op->type_a, 8) + ROTL(~op->type_b, 16) - + ROTL(~op->type_c, 24); + hash = ROTL (~op->type_a, 8) + ROTL (~op->type_b, 16) + + ROTL (~op->type_c, 24); } else { abort (); } @@ -88,10 +90,10 @@ get_hash (void *_op, void *_tab) static int compare (void *_opa, void *_opb, void *_tab) { - opcode_t *opa = (opcode_t *)_opa; - opcode_t *opb = (opcode_t *)_opb; - hashtab_t **tab = (hashtab_t **)_tab; - int cmp; + opcode_t *opa = (opcode_t *) _opa; + opcode_t *opb = (opcode_t *) _opb; + hashtab_t **tab = (hashtab_t **) _tab; + int cmp; if (tab == &opcode_type_table_ab) { cmp = (opa->type_a == opb->type_a) @@ -109,7 +111,7 @@ compare (void *_opa, void *_opb, void *_tab) opcode_t * PR_Opcode_Find (const char *name, def_t *var_a, def_t *var_b, def_t *var_c) { - opcode_t op; + opcode_t op; hashtab_t **tab; op.name = name; @@ -131,7 +133,7 @@ PR_Opcode_Find (const char *name, def_t *var_a, def_t *var_b, def_t *var_c) void PR_Opcode_Init_Tables (void) { - opcode_t *op; + opcode_t *op; PR_Opcode_Init (); opcode_type_table_ab = Hash_NewTable (1021, 0, 0, &opcode_type_table_ab); diff --git a/tools/qfcc/source/qfcc.c b/tools/qfcc/source/qfcc.c index a06fd0544..6b60f6104 100644 --- a/tools/qfcc/source/qfcc.c +++ b/tools/qfcc/source/qfcc.c @@ -56,23 +56,23 @@ #include "qfcc.h" -options_t options; +options_t options; -char *sourcedir; -const char *this_program; +char *sourcedir; +const char *this_program; static struct option const long_options[] = { - {"source", required_argument, 0, 's'}, - {"quiet", no_argument, 0, 'q'}, - {"verbose", no_argument, 0, 'v'}, - {"code", required_argument, 0, 'C'}, - {"warn", required_argument, 0, 'W'}, - {"help", no_argument, 0, 'h'}, - {"version", no_argument, 0, 'V'}, + {"source", required_argument, 0, 's'}, + {"quiet", no_argument, 0, 'q'}, + {"verbose", no_argument, 0, 'v'}, + {"code", required_argument, 0, 'C'}, + {"warn", required_argument, 0, 'W'}, + {"help", no_argument, 0, 'h'}, + {"version", no_argument, 0, 'V'}, #ifdef USE_CPP - {"define", required_argument, 0, 'D'}, - {"include", required_argument, 0, 'I'}, - {"undefine",required_argument, 0, 'U'}, + {"define", required_argument, 0, 'D'}, + {"include", required_argument, 0, 'I'}, + {"undefine", required_argument, 0, 'U'}, #endif {NULL, 0, NULL, 0} }; @@ -86,11 +86,11 @@ char debugfile[1024]; /* We reserve 6 args at the end. */ -char *cpp_argv[CPP_MAX_ARGS]; -static int cpp_argc = 0; +char *cpp_argv[CPP_MAX_ARGS]; +static int cpp_argc = 0; #endif -pr_info_t pr; +pr_info_t pr; float pr_globals[MAX_REGS]; int numpr_globals; @@ -108,7 +108,7 @@ int numfunctions; ddef_t globals[MAX_GLOBALS]; int numglobaldefs; -int num_localdefs; +int num_localdefs; const char *big_function = 0; ddef_t fields[MAX_FIELDS]; @@ -135,11 +135,12 @@ int numfiles; void WriteFiles (void) { - FILE *f; - int i; - char filename[1024]; + FILE *f; + int i; + char filename[1024]; - snprintf (filename, sizeof (filename), "%s%cfiles.dat", sourcedir, PATH_SEPARATOR); + snprintf (filename, sizeof (filename), "%s%cfiles.dat", sourcedir, + PATH_SEPARATOR); f = fopen (filename, "w"); if (!f) Error ("Couldn't open %s", filename); @@ -169,13 +170,13 @@ static hashtab_t *strings_tab; static const char * stings_get_key (void *_str, void *unsued) { - return (char*)_str; + return (char *) _str; } int CopyString (const char *str) { - int old; + int old; if (!strings_tab) { strings_tab = Hash_NewTable (16381, stings_get_key, 0, 0); @@ -190,7 +191,7 @@ CopyString (const char *str) int ReuseString (const char *str) { - char *s; + char *s; if (!strings_tab) return CopyString (str); @@ -203,7 +204,7 @@ ReuseString (const char *str) void InitData (void) { - int i; + int i; numstatements = 1; strofs = 1; @@ -220,19 +221,19 @@ InitData (void) void WriteData (int crc) { - def_t *def; - ddef_t *dd; + def_t *def; + ddef_t *dd; dprograms_t progs; pr_debug_header_t debug; - FILE *h; - int i; + FILE *h; + int i; for (def = pr.def_head.def_next; def; def = def->def_next) { if (def->scope) continue; if (def->type->type == ev_func) { -// df = &functions[numfunctions]; -// numfunctions++; +// df = &functions[numfunctions]; +// numfunctions++; } else if (def->type->type == ev_field) { dd = &fields[numfielddefs]; numfielddefs++; @@ -253,10 +254,10 @@ WriteData (int crc) dd->ofs = def->ofs; } -// PrintStrings (); -// PrintFunctions (); -// PrintFields (); -// PrintGlobals (); +// PrintStrings (); +// PrintFunctions (); +// PrintFields (); +// PrintGlobals (); strofs = (strofs + 3) & ~3; if (options.verbosity >= 0) { @@ -290,7 +291,8 @@ WriteData (int crc) progs.ofs_functions = ftell (h); progs.numfunctions = numfunctions; for (i = 0; i < numfunctions; i++) { - functions[i].first_statement = LittleLong (functions[i].first_statement); + functions[i].first_statement = + LittleLong (functions[i].first_statement); functions[i].parm_start = LittleLong (functions[i].parm_start); functions[i].s_name = LittleLong (functions[i].s_name); functions[i].s_file = LittleLong (functions[i].s_file); @@ -352,7 +354,7 @@ WriteData (int crc) fclose (h); debug.crc = LittleShort (debug.crc); debug.you_tell_me_and_we_will_both_know = 0; - + h = SafeOpenWrite (debugfile); SafeWrite (h, &debug, sizeof (debug)); @@ -399,7 +401,7 @@ char * PR_String (char *string) { static char buf[80]; - char *s; + char *s; s = buf; *s++ = '"'; @@ -436,7 +438,7 @@ PR_String (char *string) def_t * PR_DefForFieldOfs (gofs_t ofs) { - def_t *d; + def_t *d; for (d = pr.def_head.def_next; d; d = d->def_next) { if (d->type->type != ev_field) @@ -458,7 +460,7 @@ PR_DefForFieldOfs (gofs_t ofs) void PR_BeginCompilation (void) { - int i; + int i; numpr_globals = RESERVED_OFS; pr.def_tail = &pr.def_head; @@ -466,7 +468,8 @@ PR_BeginCompilation (void) for (i = 0; i < RESERVED_OFS; i++) pr_global_defs[i] = &def_void; - // link the function type in so state forward declarations match proper type + // link the function type in so state forward declarations match proper + // type pr.types = &type_function; type_function.next = NULL; pr_error_count = 0; @@ -475,7 +478,8 @@ PR_BeginCompilation (void) void PR_RelocateRefs (def_t *def) { - statref_t *ref; + statref_t *ref; + for (ref = def->refs; ref; ref = ref->next) { switch (ref->field) { case 0: @@ -488,7 +492,7 @@ PR_RelocateRefs (def_t *def) ref->statement->c = def->ofs; break; default: - abort(); + abort (); } } } @@ -499,14 +503,13 @@ PR_RelocateRefs (def_t *def) called after all files are compiled to check for errors. Returns false if errors were detected. */ -qboolean -PR_FinishCompilation (void) +qboolean PR_FinishCompilation (void) { - def_t *d; - qboolean errors = false; - function_t *f; - def_t *def; - expr_t e; + def_t *d; + qboolean errors = false; + function_t *f; + def_t *def; + expr_t e; // check to make sure all functions prototyped have code if (options.warnings.undefined_function) @@ -567,17 +570,19 @@ PR_FinishCompilation (void) int PR_WriteProgdefs (char *filename) { - def_t *d; - FILE *f; - unsigned short crc; - int c; + def_t *d; + FILE *f; + unsigned short crc; + int c; if (options.verbosity >= 1) printf ("writing %s\n", filename); f = fopen (filename, "w"); // print global vars until the first field is defined - fprintf (f, "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{\tint\tpad[%i];\n", RESERVED_OFS); + fprintf (f, + "\n/* file generated by qcc, do not modify */\n\ntypedef struct\n{\tint\tpad[%i];\n", + RESERVED_OFS); for (d = pr.def_head.def_next; d; d = d->def_next) { if (!strcmp (d->name, "end_sys_globals")) @@ -658,8 +663,8 @@ PR_WriteProgdefs (char *filename) void PR_PrintFunction (def_t *def) { - def_t *d; - statref_t *r; + def_t *d; + statref_t *r; printf ("%s\n", def->name); for (d = def->scope_next; d; d = d->scope_next) { @@ -667,7 +672,7 @@ PR_PrintFunction (def_t *def) d->name ? d->name : "", d->ofs, d->type->type, pr_type_size[d->type->type]); for (r = d->refs; r; r = r->next) - printf (" %ld", (long)(r->statement - statements)); + printf (" %ld", (long) (r->statement - statements)); printf ("\n"); } } @@ -677,31 +682,29 @@ usage (int status) { printf ("%s - QuakeForge Code Compiler\n", this_program); printf ("Usage: %s [options]\n", this_program); - printf ( -"Options:\n" -" -s, --source DIR Look for progs.src in DIR instead of \".\"\n" -" -q, --quiet Inhibit usual output\n" -" -v, --verbose Display more output than usual\n" -" -g, Generate debuggin info\n" -" -C, --code OPTION,... Set code generation options\n" -" -W, --warn OPTION,... Set warning options\n" -" -h, --help Display this help and exit\n" -" -V, --version Output version information and exit\n\n" + printf ("Options:\n" + " -s, --source DIR Look for progs.src in DIR instead of \".\"\n" + " -q, --quiet Inhibit usual output\n" + " -v, --verbose Display more output than usual\n" + " -g, Generate debuggin info\n" + " -C, --code OPTION,... Set code generation options\n" + " -W, --warn OPTION,... Set warning options\n" + " -h, --help Display this help and exit\n" + " -V, --version Output version information and exit\n\n" #ifdef USE_CPP -" -D, --define SYMBOL[=VAL],... Define symbols for the preprocessor\n" -" -I, --include DIR,... Set directories for the preprocessor \n" -" to search for #includes\n" -" -U, --undefine SYMBOL,... Undefine preprocessor symbols\n\n" + " -D, --define SYMBOL[=VAL],... Define symbols for the preprocessor\n" + " -I, --include DIR,... Set directories for the preprocessor \n" + " to search for #includes\n" + " -U, --undefine SYMBOL,... Undefine preprocessor symbols\n\n" #endif -"For help on options for --code and --warn, see the qfcc(1) manual page\n" - ); + "For help on options for --code and --warn, see the qfcc(1) manual page\n"); exit (status); } static int DecodeArgs (int argc, char **argv) { - int c; + int c; #ifdef USE_CPP for (c = 0; c < CPP_MAX_ARGS; cpp_argv[c++] = NULL); // clear the args @@ -717,44 +720,43 @@ DecodeArgs (int argc, char **argv) sourcedir = "."; - while ((c = getopt_long (argc, argv, - "s:" // source dir - "q" // quiet - "v" // verbose - "g" // debug - "C:" // code options - "W:" // warning options - "h" // help - "V" // version + while ((c = getopt_long (argc, argv, "s:" // source dir + "q" // quiet + "v" // verbose + "g" // debug + "C:" // code options + "W:" // warning options + "h" // help + "V" // version #ifdef USE_CPP - "D:" // define - "I:" // set includes - "U:" // undefine + "D:" // define + "I:" // set includes + "U:" // undefine #endif - , long_options, (int *) 0)) != EOF) { + , long_options, (int *) 0)) != EOF) { switch (c) { - case 'h': // help + case 'h': // help usage (0); break; - case 'V': // version + case 'V': // version printf ("%s version %s\n", PACKAGE, VERSION); exit (0); break; - case 's': // src dir + case 's': // src dir sourcedir = strdup (optarg); break; - case 'q': // quiet + case 'q': // quiet options.verbosity -= 1; break; - case 'v': // verbose + case 'v': // verbose options.verbosity += 1; break; - case 'g': // debug + case 'g': // debug options.code.debug = 1; break; - case 'C': { // code options - char *opts = strdup (optarg); - char *temp = strtok (opts, ","); + case 'C':{ // code options + char *opts = strdup (optarg); + char *temp = strtok (opts, ","); while (temp) { if (!(strcasecmp (temp, "cow"))) { @@ -782,9 +784,9 @@ DecodeArgs (int argc, char **argv) free (opts); } break; - case 'W': { // warning options - char *opts = strdup (optarg); - char *temp = strtok (opts, ","); + case 'W':{ // warning options + char *opts = strdup (optarg); + char *temp = strtok (opts, ","); while (temp) { if (!(strcasecmp (temp, "all"))) { @@ -824,45 +826,45 @@ DecodeArgs (int argc, char **argv) } break; #ifdef USE_CPP - case 'D': { // defines for cpp - char *opts = strdup (optarg); - char *temp = strtok (opts, ","); + case 'D':{ // defines for cpp + char *opts = strdup (optarg); + char *temp = strtok (opts, ","); while (temp && (cpp_argc < CPP_MAX_USER_ARGS)) { - char temp2[1024]; + char temp2[1024]; snprintf (temp2, sizeof (temp2), "%s%s", "-D", temp); cpp_argv[cpp_argc++] = strdup (temp2); temp = strtok (NULL, ","); - } + } free (opts); } break; - case 'I': { // includes - char *opts = strdup (optarg); - char *temp = strtok (opts, ","); + case 'I':{ // includes + char *opts = strdup (optarg); + char *temp = strtok (opts, ","); while (temp && (cpp_argc < CPP_MAX_USER_ARGS)) { - char temp2[1024]; + char temp2[1024]; snprintf (temp2, sizeof (temp2), "%s%s", "-I", temp); cpp_argv[cpp_argc++] = strdup (temp2); temp = strtok (NULL, ","); - } + } free (opts); } break; - case 'U': { // undefines - char *opts = strdup (optarg); - char *temp = strtok (opts, ","); + case 'U':{ // undefines + char *opts = strdup (optarg); + char *temp = strtok (opts, ","); while (temp && (cpp_argc < CPP_MAX_USER_ARGS)) { - char temp2[1024]; + char temp2[1024]; snprintf (temp2, sizeof (temp2), "%s%s", "-U", temp); cpp_argv[cpp_argc++] = strdup (temp2); temp = strtok (NULL, ","); - } + } free (opts); } break; @@ -873,7 +875,7 @@ DecodeArgs (int argc, char **argv) } return optind; } - + //============================================================================ /* @@ -884,10 +886,10 @@ DecodeArgs (int argc, char **argv) int main (int argc, char **argv) { - char *src; - char filename[1024]; - int crc; - double start, stop; + char *src; + char filename[1024]; + int crc; + double start, stop; start = Sys_DoubleTime (); @@ -914,7 +916,8 @@ main (int argc, char **argv) printf ("outputfile: %s\n", destfile); } if (options.code.debug) { - char *s; + char *s; + strcpy (debugfile, com_token); s = debugfile + strlen (debugfile); @@ -937,23 +940,24 @@ main (int argc, char **argv) while ((src = Parse (src))) { #ifdef USE_CPP # ifndef _WIN32 - pid_t pid; - int tempfd; + pid_t pid; + int tempfd; # endif - char *temp1; - char *temp2 = strrchr (argv[0], PATH_SEPARATOR); - char tempname[1024]; + char *temp1; + char *temp2 = strrchr (argv[0], PATH_SEPARATOR); + char tempname[1024]; #endif - int error; + int error; extern FILE *yyin; - int yyparse (void); + int yyparse (void); extern void clear_frame_macros (void); - //extern int yydebug; - //yydebug = 1; + // extern int yydebug; + // yydebug = 1; - snprintf (filename, sizeof (filename), "%s%c%s", sourcedir, PATH_SEPARATOR, com_token); + snprintf (filename, sizeof (filename), "%s%c%s", sourcedir, + PATH_SEPARATOR, com_token); if (options.verbosity >= 2) printf ("compiling %s\n", filename); @@ -977,7 +981,7 @@ main (int argc, char **argv) fclose (yyin); { - int status = spawnvp (_P_WAIT, "cpp", cpp_argv); + int status = spawnvp (_P_WAIT, "cpp", cpp_argv); if (status) { fprintf (stderr, "cpp returned error code %d", status); @@ -992,19 +996,21 @@ main (int argc, char **argv) perror ("fork"); return 1; } - if (!pid) { // we're a child, check for abuse + if (!pid) { + // we're a child, check for abuse cpp_argv[cpp_argc++] = "-o"; cpp_argv[cpp_argc++] = tempname; cpp_argv[cpp_argc++] = filename; - + execvp ("cpp", cpp_argv); printf ("Child shouldn't reach here\n"); exit (1); - } else { // give parental guidance (or bury it in the back yard) - int status; - pid_t rc; - -// printf ("pid = %d\n", pid); + } else { + // give parental guidance (or bury it in the back yard) + int status; + pid_t rc; + +// printf ("pid = %d\n", pid); if ((rc = waitpid (0, &status, 0 | WUNTRACED)) != pid) { if (rc == -1) { perror ("wait"); diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c index e29dfe4f3..750400785 100644 --- a/tools/qfcc/source/switch.c +++ b/tools/qfcc/source/switch.c @@ -27,7 +27,7 @@ Boston, MA 02111-1307, USA */ -static const char rcsid[] = +static const char rcsid[] = "$Id$"; #include @@ -49,7 +49,7 @@ typedef struct case_node_s { static unsigned long get_hash (void *_cl, void *unused) { - case_label_t *cl = (case_label_t*)_cl; + case_label_t *cl = (case_label_t *) _cl; return cl->value ? cl->value->e.integer_val : 0; } @@ -57,8 +57,8 @@ get_hash (void *_cl, void *unused) static int compare (void *_cla, void *_clb, void *unused) { - case_label_t *cla = (case_label_t*)_cla; - case_label_t *clb = (case_label_t*)_clb; + case_label_t *cla = (case_label_t *) _cla; + case_label_t *clb = (case_label_t *) _clb; expr_t *v1 = cla->value; expr_t *v2 = clb->value; @@ -102,6 +102,7 @@ switch_block_t * new_switch_block (void) { switch_block_t *switch_block = malloc (sizeof (switch_block_t)); + if (!switch_block) Sys_Error ("new_switch_block: Memory Allocation Failure\n"); switch_block->labels = Hash_NewTable (127, 0, 0, 0); @@ -113,8 +114,8 @@ new_switch_block (void) static int label_compare (const void *_a, const void *_b) { - const case_label_t **a = (const case_label_t **)_a; - const case_label_t **b = (const case_label_t **)_b; + const case_label_t **a = (const case_label_t **) _a; + const case_label_t **b = (const case_label_t **) _b; const char *s1, *s2; switch ((*a)->value->type) { @@ -149,6 +150,7 @@ new_case_node (expr_t *low, expr_t *high) node->_label = 0; } else { int size; + if (low->type != ex_integer) { error (low, "switch: internal error"); abort (); @@ -185,11 +187,12 @@ build_case_tree (case_label_t **labels, int count, int range) { case_node_t **nodes; int i, j, k; - int num_nodes = 0; + int num_nodes = 0; qsort (labels, count, sizeof (*labels), label_compare); - nodes = (case_node_t **) malloc (count * sizeof (case_node_t*)); + nodes = (case_node_t **) malloc (count * sizeof (case_node_t *)); + if (!nodes) Sys_Error ("out of memory"); @@ -224,7 +227,7 @@ build_case_tree (case_label_t **labels, int count, int range) } static void -build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, +build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, expr_t *temp, expr_t *default_label) { expr_t *test; @@ -326,6 +329,7 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, for (i = 0; i <= high - low; i++) { dstatement_t *st; statref_t *ref; + st = (dstatement_t *) &pr_globals[G_INT (def->ofs) + i]; ref = PR_NewStatref (st, 3); ref->next = tree->labels[i]->e.label.refs; @@ -335,7 +339,7 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, } struct expr_s * -switch_expr (switch_block_t *switch_block, expr_t *break_label, +switch_expr (switch_block_t *switch_block, expr_t *break_label, expr_t *statements) { case_label_t **labels, **l; @@ -349,10 +353,10 @@ switch_expr (switch_block_t *switch_block, expr_t *break_label, sw_val->line = switch_block->test->line; sw_val->file = switch_block->test->file; - + default_label->value = 0; default_label = Hash_DelElement (switch_block->labels, default_label); - labels = (case_label_t **)Hash_GetList (switch_block->labels); + labels = (case_label_t **) Hash_GetList (switch_block->labels); if (!default_label) { default_label = &_default_label; @@ -368,14 +372,14 @@ switch_expr (switch_block_t *switch_block, expr_t *break_label, num_labels++; if (options.code.progsversion == PROG_ID_VERSION || (type != &type_string - && type != &type_float - && type != &type_integer) + && type != &type_float && type != &type_integer) || num_labels < 8) { for (l = labels; *l; l++) { expr_t *cmp = binary_expr (EQ, sw_val, (*l)->value); expr_t *test = new_binary_expr ('i', test_expr (cmp, 1), (*l)->label); + test->line = cmp->line = sw_val->line; test->file = cmp->file = sw_val->file; append_expr (sw, test);