qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-02-17 01:11:45 +00:00
Code Issues Projects Releases Packages Wiki Activity

indent whitespace cleanup. not perfect, but a bit more consistent now

Browse source
This commit is contained in:
Bill Currie 2001-12-06 19:49:40 +00:00
parent 61786182d2
commit 3c2c4aa9e6
12 changed files with 557 additions and 503 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
tools/qfcc/source/.indent.pro vendored
View file

@ -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

37
tools/qfcc/source/cmdlib.c
View file

@ -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);

4
tools/qfcc/source/debug.c
View file

@ -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)

66
tools/qfcc/source/emit.c
View file

@ -27,7 +27,7 @@
Boston, MA 02111-1307, USA
*/
static const char rcsid[] =
static const char rcsid[] =
"$Id$";
#include <stdlib.h>
@ -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;

257
tools/qfcc/source/expr.c
View file

@ -27,7 +27,7 @@
Boston, MA 02111-1307, USA
*/
static const char rcsid[] =
static const char rcsid[] =
"$Id$";
#include <stdlib.h>
@ -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 "<bind>";
case 's': return "<state>";
case 'c': return "<call>";
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);
}

12
tools/qfcc/source/pr_comp.c
View file

@ -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;

85
tools/qfcc/source/pr_def.c
View file

@ -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;

91
tools/qfcc/source/pr_imm.c
View file

@ -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);
}
}

97
tools/qfcc/source/pr_lex.c
View file

@ -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";

56
tools/qfcc/source/pr_opcode.c
View file

@ -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);

284
tools/qfcc/source/qfcc.c
View file

@ -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 : "<temp>",
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");

32
tools/qfcc/source/switch.c
View file

@ -27,7 +27,7 @@
Boston, MA 02111-1307, USA
*/
static const char rcsid[] =
static const char rcsid[] =
"$Id$";
#include <QF/hash.h>
@ -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);