qf
/
quakeforge
mirror of https://git.code.sf.net/p/quake/quakeforge
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[gamecode] Rename ev_integer to ev_int 

And other related fields so integer is now int (and uinteger is uint). I
really don't know why I went with integer in the first place, but this
will make using macros easier for dealing with types.
This commit is contained in:
Bill Currie 2022-01-18 13:21:06 +09:00
parent 978d6fd3e8
commit cfe7c44df0
59 changed files with 969 additions and 972 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
include/QF/progs.h
View File

@ -416,29 +416,29 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_
*/
#define G_DOUBLE(p,o) (*(double *) ((p)->pr_globals + o))
/** Access an integer global. Can be assigned to.
/** Access an int global. Can be assigned to.
\par QC type:
\c integer
\c int
\param p pointer to ::progs_t VM struct
\param o offset into global data space
\return int lvalue
\hideinitializer
*/
#define G_INT(p,o) G_var (p, o, integer)
#define G_INT(p,o) G_var (p, o, int)
/** Access an unsigned integer global. Can be assigned to.
/** Access an unsigned int global. Can be assigned to.
\par QC type:
\c uinteger
\c uint
\param p pointer to ::progs_t VM struct
\param o offset into global data space
\return unsigned int lvalue
\hideinitializer
*/
#define G_UINT(p,o) G_var (p, o, uinteger)
#define G_UINT(p,o) G_var (p, o, uint)
/** Access a vector global. Can be assigned to.
@ -632,29 +632,29 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_
*/
#define P_DOUBLE(p,n) P_PACKED(p, double, n)
/** Access an integer parameter. Can be assigned to.
/** Access an int parameter. Can be assigned to.
\par QC type:
\c integer
\c int
\param p pointer to ::progs_t VM struct
\param n parameter number (0-7)
\return int lvalue
\hideinitializer
*/
#define P_INT(p,n) P_var (p, n, integer)
#define P_INT(p,n) P_var (p, n, int)
/** Access an unsigned integer parameter. Can be assigned to.
/** Access an unsigned int parameter. Can be assigned to.
\par QC type:
\c uinteger
\c uint
\param p pointer to ::progs_t VM struct
\param n parameter number (0-7)
\return unsigned int lvalue
\hideinitializer
*/
#define P_UINT(p,n) P_var (p, n, uinteger)
#define P_UINT(p,n) P_var (p, n, uint)
/** Access a vector parameter. Can be used any way a vec3_t variable can.
@ -850,24 +850,24 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_
/** Access the VM function return value as a \c ::pr_int_t (AKA int32_t)
\par QC type:
\c integer
\c int
\param p pointer to ::progs_t VM struct
\return ::pr_int_t lvalue
\hideinitializer
*/
#define R_INT(p) R_var (p, integer)
#define R_INT(p) R_var (p, int)
/** Access the VM function return value as a \c ::pr_uint_t (AKA uint32_t)
\par QC type:
\c uinteger
\c uint
\param p pointer to ::progs_t VM struct
\return ::pr_int_t lvalue
\hideinitializer
*/
#define R_UINT(p) R_var (p, uinteger)
#define R_UINT(p) R_var (p, uint)
/** Access the VM function return value as a \c ::vec3_t vector.
@ -1036,29 +1036,29 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_
*/
#define E_DOUBLE(e,o) (*(double *) ((e)->v + o))
/** Access an integer entity field. Can be assigned to.
/** Access an int entity field. Can be assigned to.
\par QC type:
\c integer
\c int
\param e pointer to the entity
\param o field offset into entity data space
\return int lvalue
\hideinitializer
*/
#define E_INT(e,o) E_var (e, o, integer)
#define E_INT(e,o) E_var (e, o, int)
/** Access an unsigned integer entity field. Can be assigned to.
/** Access an unsigned int entity field. Can be assigned to.
\par QC type:
\c uinteger
\c uint
\param e pointer to the entity
\param o field offset into entity data space
\return unsigned int lvalue
\hideinitializer
*/
#define E_UINT(e,o) E_var (e, o, uinteger)
#define E_UINT(e,o) E_var (e, o, uint)
/** Access a vector entity field. Can be used any way a vec3_t variable can.
@ -1452,14 +1452,14 @@ void PR_FreeTempStrings (progs_t *pr);
<ul>
<li>\c '@' \c id Not yet implemented. Silently ignored.
<li>\c 'e' \c entity Prints the edict number of the given entity ("%i")
<li>\c 'i' \c integer Print a integer value. ("%i")
<li>\c 'i' \c int Print a int value. ("%i")
<li>\c 'f' \c float Print a float value. ("%f")
<li>\c 'g' \c float Print a float value. ("%f")
<li>\c 'p' \c void * Print a pointer value. ("%#x")
<li>\c 's' \c string Print a string value. ("%s")
<li>\c 'v' \c vector Print a vector value. ("'%g %g %g'")
<li>\c 'q' \c quaternion Print a quaternion value. ("'%g %g %g %g'")
<li>\c 'x' \c uinteger Print an unsigned integer value. ("%x")
<li>\c 'x' \c uint Print an unsigned int value. ("%x")
</ul>
</ul>
@ -1528,7 +1528,7 @@ void *PR_Resources_Find (progs_t *pr, const char *name);
/** \name Resource Map support
These macros can be used to create functions for mapping C resources
to QuakeC integer handles.
to QuakeC int handles.
Valid handles are always negative.
@ -1731,8 +1731,8 @@ typedef struct type_view_s {
type_view_func func_view;
type_view_func pointer_view;
type_view_func quat_view;
type_view_func integer_view;
type_view_func uinteger_view;
type_view_func int_view;
type_view_func uint_view;
type_view_func short_view;
type_view_func double_view;
type_view_func long_view;

4
include/QF/progs/pr_comp.h
View File

@ -524,9 +524,9 @@ typedef union pr_type_u {
pr_uint_t entity_var;
float vector_var; // really [3], but this structure must be 32 bits
float quat_var; // really [4], but this structure must be 32 bits
pr_int_t integer_var;
pr_int_t int_var;
pr_ptr_t pointer_var;
pr_uint_t uinteger_var;
pr_uint_t uint_var;
} pr_type_t;
typedef struct pr_va_list_s {

4
include/QF/progs/pr_type_names.h
View File

@ -39,8 +39,8 @@ EV_TYPE(field)
EV_TYPE(func)
EV_TYPE(pointer) // end of v6 types
EV_TYPE(quat)
EV_TYPE(integer)
EV_TYPE(uinteger)
EV_TYPE(int)
EV_TYPE(uint)
EV_TYPE(short) // value is embedded in the opcode
EV_TYPE(double)
EV_TYPE(long)

38
libs/gamecode/opcodes.py
View File

@ -48,8 +48,8 @@ branch_fmt = [
]
compare_ccc = [ "eq", "lt", "gt", None, "ne", "ge", "le", None]
type_tt = ['I', 'F', 'L', 'D']
etype_tt = ["ev_integer", "ev_float", "ev_long", "ev_double"]
unsigned_t = ["ev_uinteger", "ev_ulong"]
etype_tt = ["ev_int", "ev_float", "ev_long", "ev_double"]
unsigned_t = ["ev_uint", "ev_ulong"]
float_t = ["ev_float", "ev_double"]
all_formats = {
@ -58,7 +58,7 @@ all_formats = {
"opname": "all",
"format": "%Ga, %gc",
"widths": "{ss+1}, 0, 1",
"types": "ev_integer, ev_integer, ev_integer",
"types": "ev_int, ev_int, ev_int",
}
any_formats = {
"opcode": "OP_ANY_{ss+1}",
@ -66,7 +66,7 @@ any_formats = {
"opname": "any",
"format": "%Ga, %gc",
"widths": "{ss+1}, 0, 1",
"types": "ev_integer, ev_integer, ev_integer",
"types": "ev_int, ev_int, ev_int",
}
bitops_formats = {
"opcode": "OP_{op_bit[oo].upper()}_{bit_type[t]}_{ss+1}",
@ -78,7 +78,7 @@ bitops_formats = {
"args": {
"op_bit": ["bitand", "bitor", "bitxor", "bitnot"],
"bit_type": ["I", "L"],
"bit_types": ["ev_integer", "ev_long"],
"bit_types": ["ev_int", "ev_long"],
"bit_fmt": [
"%Ga, %Gb, %gc",
"%Ga, %Gb, %gc",
@ -93,7 +93,7 @@ branch_formats = {
"opname": "{op_cond[c*4+cc]}",
"format": "{cond_fmt[c*4+cc]}{branch_fmt[0]}",
"widths": "{cond_widths[c*4+cc]}",
"types": "ev_void, ev_void, ev_integer",
"types": "ev_void, ev_void, ev_int",
"args": {
"op_mode": "ABCD",
"op_cond": ["ifz", "ifb", "ifa", None,
@ -134,7 +134,7 @@ compare_formats = {
"mnemonic": "{op_cmp[ccc]}.{cmp_type[tt]}",
"opname": "{op_cmp[ccc]}",
"widths": "{ss+1}, {ss+1}, {ss+1}",
"types": "{cmp_types[tt]}, {cmp_types[tt]}, ev_integer",
"types": "{cmp_types[tt]}, {cmp_types[tt]}, ev_int",
"args": {
"op_cmp": compare_ccc,
"cmp_type": type_tt,
@ -146,7 +146,7 @@ compare2_formats = {
"mnemonic": "{op_cmp[ccc]}.{cmp_type[t]}",
"opname": "{op_cmp[ccc]}",
"widths": "{ss+1}, {ss+1}, {ss+1}",
"types": "{cmp_types[t]}, {cmp_types[t]}, ev_integer",
"types": "{cmp_types[t]}, {cmp_types[t]}, ev_int",
"args": {
"op_cmp": compare_ccc,
"cmp_type": ['u', 'U'],
@ -228,7 +228,7 @@ memset_formats = {
"opname": "memset",
"format": "{memset_fmt[oo]}",
"widths": "0, 0, 0",
"types": "ev_integer, ev_void, ev_void",
"types": "ev_int, ev_void, ev_void",
"args": {
"op_memset": ["i", "p", "pi", None],
"memset_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None],
@ -240,7 +240,7 @@ move_formats = {
"opname": "memset",
"format": "{move_fmt[oo]}",
"widths": "0, 0, 0",
"types": "ev_integer, ev_void, ev_void",
"types": "ev_int, ev_void, ev_void",
"args": {
"op_move": ["i", "p", "pi", None],
"move_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None],
@ -252,7 +252,7 @@ none_formats = {
"opname": "none",
"format": "%Ga, %gc",
"widths": "{ss+1}, 0, 1",
"types": "ev_integer, ev_invalid, ev_integer",
"types": "ev_int, ev_invalid, ev_int",
}
push_formats = {
"opcode": "OP_PUSH_{op_mode[mm]}_{ss+1}",
@ -325,7 +325,7 @@ shiftops_formats = {
"op_shift": ["shl", "asr", "shl", "shr"],
"shift_type": ['I', 'L', 'u', 'U'],
"shift_types": [
["ev_integer", "ev_uinteger"],
["ev_int", "ev_uint"],
["ev_long", "ev_ulong"],
],
},
@ -393,14 +393,14 @@ string_formats = {
"%Ga, %gc",
],
"str_types": [
"ev_string, ev_string, ev_integer",
"ev_string, ev_string, ev_integer",
"ev_string, ev_string, ev_integer",
"ev_string, ev_string, ev_int",
"ev_string, ev_string, ev_int",
"ev_string, ev_string, ev_int",
"ev_string, ev_string, ev_string",
"ev_string, ev_string, ev_integer",
"ev_string, ev_string, ev_integer",
"ev_string, ev_string, ev_integer",
"ev_string, ev_invalid, ev_integer",
"ev_string, ev_string, ev_int",
"ev_string, ev_string, ev_int",
"ev_string, ev_string, ev_int",
"ev_string, ev_invalid, ev_int",
],
},
}

50
libs/gamecode/pr_debug.c
View File

@ -137,9 +137,9 @@ static void pr_debug_pointer_view (qfot_type_t *type, pr_type_t *value,
void *_data);
static void pr_debug_quat_view (qfot_type_t *type, pr_type_t *value,
void *_data);
static void pr_debug_integer_view (qfot_type_t *type, pr_type_t *value,
static void pr_debug_int_view (qfot_type_t *type, pr_type_t *value,
void *_data);
static void pr_debug_uinteger_view (qfot_type_t *type, pr_type_t *value,
static void pr_debug_uint_view (qfot_type_t *type, pr_type_t *value,
void *_data);
static void pr_debug_short_view (qfot_type_t *type, pr_type_t *value,
void *_data);
@ -170,8 +170,8 @@ static type_view_t raw_type_view = {
pr_debug_func_view,
pr_debug_pointer_view,
pr_debug_quat_view,
pr_debug_integer_view,
pr_debug_uinteger_view,
pr_debug_int_view,
pr_debug_uint_view,
pr_debug_short_view,
pr_debug_double_view,
pr_debug_long_view,
@ -269,7 +269,7 @@ pr_debug_type_size (const progs_t *pr, const qfot_type_t *type)
}
return size;
case ty_enum:
return pr_type_size[ev_integer];
return pr_type_size[ev_int];
case ty_array:
aux_type = &G_STRUCT (pr, qfot_type_t, type->array.type);
size = pr_debug_type_size (pr, aux_type);
@ -356,7 +356,7 @@ parse_expression (progs_t *pr, const char *expr, int conditional)
goto error;
if (!Script_GetToken (es, 1))
goto error;
pr->wp_val.integer_var = strtol (es->token->str, &e, 0);
pr->wp_val.int_var = strtol (es->token->str, &e, 0);
if (e == es->token->str)
goto error;
if (*e == '.' || *e == 'e' || *e == 'E')
@ -404,7 +404,7 @@ pr_debug_clear (progs_t *pr, void *data)
pr->watch = 0;
pr->wp_conditional = 0;
pr->wp_val.integer_var = 0;
pr->wp_val.int_var = 0;
for (int i = 0; i < ev_type_count; i++ ) {
res->type_encodings[i] = &res->void_type;
@ -1056,11 +1056,11 @@ value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value)
case ev_quat:
raw_type_view.quat_view (type, value, data);
break;
case ev_integer:
raw_type_view.integer_view (type, value, data);
case ev_int:
raw_type_view.int_view (type, value, data);
break;
case ev_uinteger:
raw_type_view.uinteger_view (type, value, data);
case ev_uint:
raw_type_view.uint_view (type, value, data);
break;
case ev_short:
raw_type_view.short_view (type, value, data);
@ -1242,9 +1242,9 @@ pr_debug_float_view (qfot_type_t *type, pr_type_t *value, void *_data)
dstring_t *dstr = data->dstr;
if (data->pr->progs->version == PROG_ID_VERSION
&& ISDENORM (value->integer_var)
&& value->uinteger_var != 0x80000000) {
dasprintf (dstr, "<%08x>", value->integer_var);
&& ISDENORM (value->int_var)
&& value->uint_var != 0x80000000) {
dasprintf (dstr, "<%08x>", value->int_var);
} else {
dasprintf (dstr, "%.9g", value->float_var);
}
@ -1284,12 +1284,12 @@ pr_debug_field_view (qfot_type_t *type, pr_type_t *value, void *_data)
__auto_type data = (pr_debug_data_t *) _data;
progs_t *pr = data->pr;
dstring_t *dstr = data->dstr;
pr_def_t *def = PR_FieldAtOfs (pr, value->integer_var);
pr_def_t *def = PR_FieldAtOfs (pr, value->int_var);
if (def) {
dasprintf (dstr, ".%s", PR_GetString (pr, def->name));
} else {
dasprintf (dstr, ".<$%04x>", value->integer_var);
dasprintf (dstr, ".<$%04x>", value->int_var);
}
}
@ -1316,7 +1316,7 @@ pr_debug_pointer_view (qfot_type_t *type, pr_type_t *value, void *_data)
__auto_type data = (pr_debug_data_t *) _data;
progs_t *pr = data->pr;
dstring_t *dstr = data->dstr;
pr_ptr_t offset = value->integer_var;
pr_ptr_t offset = value->int_var;
pr_ptr_t offs = offset;
pr_def_t *def = 0;
@ -1342,21 +1342,21 @@ pr_debug_quat_view (qfot_type_t *type, pr_type_t *value, void *_data)
}
static void
pr_debug_integer_view (qfot_type_t *type, pr_type_t *value, void *_data)
pr_debug_int_view (qfot_type_t *type, pr_type_t *value, void *_data)
{
__auto_type data = (pr_debug_data_t *) _data;
dstring_t *dstr = data->dstr;
dasprintf (dstr, "%d", value->integer_var);
dasprintf (dstr, "%d", value->int_var);
}
static void
pr_debug_uinteger_view (qfot_type_t *type, pr_type_t *value, void *_data)
pr_debug_uint_view (qfot_type_t *type, pr_type_t *value, void *_data)
{
__auto_type data = (pr_debug_data_t *) _data;
dstring_t *dstr = data->dstr;
dasprintf (dstr, "$%08x", value->uinteger_var);
dasprintf (dstr, "$%08x", value->uint_var);
}
static void
@ -1365,7 +1365,7 @@ pr_debug_short_view (qfot_type_t *type, pr_type_t *value, void *_data)
__auto_type data = (pr_debug_data_t *) _data;
dstring_t *dstr = data->dstr;
dasprintf (dstr, "%04x", (short)value->integer_var);
dasprintf (dstr, "%04x", (short)value->int_var);
}
static void
@ -1468,7 +1468,7 @@ PR_Debug_Watch (progs_t *pr, const char *expr)
(int) (intptr_t) (pr->watch - pr->pr_globals));
if (pr->wp_conditional)
Sys_Printf (" if new val == %d\n",
pr->wp_val.integer_var);
pr->wp_val.int_var);
} else { Sys_Printf (" none active\n");
}
return;
@ -1481,7 +1481,7 @@ PR_Debug_Watch (progs_t *pr, const char *expr)
if (pr->watch) {
Sys_Printf ("watchpoint set to [%d]\n", PR_SetPointer (pr, pr->watch));
if (pr->wp_conditional)
Sys_Printf (" if new val == %d\n", pr->wp_val.integer_var);
Sys_Printf (" if new val == %d\n", pr->wp_val.int_var);
} else {
Sys_Printf ("watchpoint cleared\n");
}
@ -1672,7 +1672,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents)
{
edict_t *ed = 0;
opval = pr->pr_globals[s->a].entity_var;
parm_ind = pr->pr_globals[s->b].uinteger_var;
parm_ind = pr->pr_globals[s->b].uint_var;
if (parm_ind < pr->progs->entityfields
&& opval > 0
&& opval < pr->pr_edict_area_size) {

86
libs/gamecode/pr_exec.c
View File

@ -282,7 +282,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f)
if (pr_deadbeef_locals->int_val)
for (i = f->parm_start; i < f->parm_start + f->locals; i++)
pr->pr_globals[i].integer_var = 0xdeadbeef;
pr->pr_globals[i].int_var = 0xdeadbeef;
// copy parameters
if (f->numparms >= 0) {
@ -297,8 +297,8 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f)
copy_param (dstParams[i], pr->pr_params[i], f->parm_size[i].size);
}
copy_args = pr->pr_argc - i;
argc->integer_var = copy_args;
argv->integer_var = dstParams[i] - pr->pr_globals;
argc->int_var = copy_args;
argv->int_var = dstParams[i] - pr->pr_globals;
if (i < MAX_PARMS) {
memcpy (dstParams[i], pr->pr_params[i],
(copy_args * pr->pr_param_size) * sizeof (pr_type_t));
@ -461,7 +461,7 @@ static inline void
pr_memset (pr_type_t *dst, int val, int count)
{
while (count-- > 0) {
(*dst++).integer_var = val;
(*dst++).int_var = val;
}
}
@ -783,10 +783,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
case OP_STOREP_P_v6p:
pointer = OPB(int);
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
ptr = pr->pr_globals + pointer;
ptr->integer_var = OPA(int);
ptr->int_var = OPA(int);
break;
case OP_STOREP_V_v6p:
pointer = OPB(int);
@ -857,7 +857,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
"field in an edict");
}
fldofs = OPA(uint) + OPB(int);
OPC(int) = pr->pr_edict_area[fldofs].integer_var;
OPC(int) = pr->pr_edict_area[fldofs].int_var;
break;
case OP_LOAD_V_v6p:
if (pr_boundscheck->int_val) {
@ -905,10 +905,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
case OP_LOADB_P_v6p:
pointer = OPA(int) + OPB(int);
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
ptr = pr->pr_globals + pointer;
OPC(int) = ptr->integer_var;
OPC(int) = ptr->int_var;
break;
case OP_LOADB_V_v6p:
pointer = OPA(int) + OPB(int);
@ -944,10 +944,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
case OP_LOADBI_P_v6p:
pointer = OPA(int) + (short) st->b;
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
ptr = pr->pr_globals + pointer;
OPC(int) = ptr->integer_var;
OPC(int) = ptr->int_var;
break;
case OP_LOADBI_V_v6p:
pointer = OPA(int) + (short) st->b;
@ -993,10 +993,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
case OP_STOREB_P_v6p:
pointer = OPB(int) + OPC(int);
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
ptr = pr->pr_globals + pointer;
ptr->integer_var = OPA(int);
ptr->int_var = OPA(int);
break;
case OP_STOREB_V_v6p:
pointer = OPB(int) + OPC(int);
@ -1032,10 +1032,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
case OP_STOREBI_P_v6p:
pointer = OPB(int) + (short) st->c;
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
ptr = pr->pr_globals + pointer;
ptr->integer_var = OPA(int);
ptr->int_var = OPA(int);
break;
case OP_STOREBI_V_v6p:
pointer = OPB(int) + (short) st->c;
@ -1075,7 +1075,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 1);
}
stk->integer_var = OPA(int);
stk->int_var = OPA(int);
*pr->globals.stack = stack;
}
break;
@ -1118,10 +1118,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 1);
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
stk->integer_var = ptr->integer_var;
stk->int_var = ptr->int_var;
*pr->globals.stack = stack;
}
break;
@ -1135,7 +1135,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 3);
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
VectorCopy (&ptr->vector_var, &stk->vector_var);
@ -1176,10 +1176,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 1);
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
stk->integer_var = ptr->integer_var;
stk->int_var = ptr->int_var;
*pr->globals.stack = stack;
}
break;
@ -1193,7 +1193,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 3);
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
VectorCopy (&ptr->vector_var, &stk->vector_var);
@ -1231,7 +1231,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 1);
}
OPA(int) = stk->integer_var;
OPA(int) = stk->int_var;
*pr->globals.stack = stack + 1;
}
break;
@ -1274,10 +1274,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 1);
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
ptr->integer_var = stk->integer_var;
ptr->int_var = stk->int_var;
*pr->globals.stack = stack + 1;
}
break;
@ -1291,7 +1291,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 3);
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
VectorCopy (&stk->vector_var, &ptr->vector_var);
@ -1332,10 +1332,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 1);
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
ptr->integer_var = stk->integer_var;
ptr->int_var = stk->int_var;
*pr->globals.stack = stack + 1;
}
break;
@ -1349,7 +1349,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
if (pr_boundscheck->int_val) {
check_stack_pointer (pr, stack, 3);
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
VectorCopy (&stk->vector_var, &ptr->vector_var);
@ -1426,10 +1426,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth)
case OP_JUMPB_v6p:
pointer = st->a + OPB(int);
if (pr_boundscheck->int_val) {
PR_BoundsCheck (pr, pointer, ev_integer);
PR_BoundsCheck (pr, pointer, ev_int);
}
ptr = pr->pr_globals + pointer;
pointer = ptr->integer_var;
pointer = ptr->int_var;
if (pr_boundscheck->int_val
&& (pointer >= pr->progs->numstatements)) {
PR_RunError (pr, "Invalid jump destination");
@ -1695,8 +1695,8 @@ op_call:
OPC(float) = OPA(double) < OPB(double);
break;
case OP_NOT_D_v6p:
OPC(int) = (op_a[0].integer_var
|| (op_a[1].integer_var & ~0x80000000u));
OPC(int) = (op_a[0].int_var
|| (op_a[1].int_var & ~0x80000000u));
break;
case OP_EQ_D_v6p:
OPC(int) = OPA(double) == OPB(double);
@ -1730,17 +1730,17 @@ op_call:
default:
PR_RunError (pr, "Bad opcode %i", st->op & ~OP_BREAK);
}
if (pr->watch && pr->watch->integer_var != old_val.integer_var) {
if (pr->watch && pr->watch->int_var != old_val.int_var) {
if (!pr->wp_conditional
|| pr->watch->integer_var == pr->wp_val.integer_var) {
|| pr->watch->int_var == pr->wp_val.int_var) {
if (pr->debug_handler) {
pr->debug_handler (prd_watchpoint, 0, pr->debug_data);
} else {
PR_RunError (pr, "watchpoint hit: %d -> %d",
old_val.integer_var, pr->watch->integer_var);
old_val.int_var, pr->watch->int_var);
}
}
old_val.integer_var = pr->watch->integer_var;
old_val.int_var = pr->watch->int_var;
}
}
exit_program:
@ -3355,7 +3355,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth)
int think = pr->fields.think + self;
double time = *pr->globals.dtime + 0.1;
*(double *) (&pr->pr_edict_area[nextthink]) = time;
pr->pr_edict_area[frame].integer_var = OPA(int);
pr->pr_edict_area[frame].int_var = OPA(int);
pr->pr_edict_area[think].func_var = op_b->func_var;
}
break;
@ -3386,7 +3386,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth)
int think = pr->fields.think + self;
double time = *pr->globals.dtime + OPC(double);
*(double *) (&pr->pr_edict_area[nextthink]) = time;
pr->pr_edict_area[frame].integer_var = OPA(int);
pr->pr_edict_area[frame].int_var = OPA(int);
pr->pr_edict_area[think].func_var = op_b->func_var;
}
break;
@ -3440,17 +3440,17 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth)
default:
PR_RunError (pr, "Bad opcode o%03o", st->op & OP_MASK);
}
if (pr->watch && pr->watch->integer_var != old_val.integer_var) {
if (pr->watch && pr->watch->int_var != old_val.int_var) {
if (!pr->wp_conditional
|| pr->watch->integer_var == pr->wp_val.integer_var) {
|| pr->watch->int_var == pr->wp_val.int_var) {
if (pr->debug_handler) {
pr->debug_handler (prd_watchpoint, 0, pr->debug_data);
} else {
PR_RunError (pr, "watchpoint hit: %d -> %d",
old_val.integer_var, pr->watch->integer_var);
old_val.int_var, pr->watch->int_var);
}
}
old_val.integer_var = pr->watch->integer_var;
old_val.int_var = pr->watch->int_var;
}
}
exit_program:

4
libs/gamecode/pr_opcode.c
View File

@ -43,8 +43,8 @@ VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = {
1, // ev_func
1, // ev_pointer
4, // ev_quat
1, // ev_integer
1, // ev_uinteger
1, // ev_int
1, // ev_uint
0, // ev_short value in opcode
2, // ev_double
2, // ev_long

10
libs/gamecode/pr_parse.c
View File

@ -79,7 +79,7 @@ PR_UglyValueString (progs_t *pr, etype_t type, pr_type_t *val, dstring_t *line)
dsprintf (line, "%s", PR_GetString (pr, f->name));
break;
case ev_field:
def = PR_FieldAtOfs (pr, val->integer_var);
def = PR_FieldAtOfs (pr, val->int_var);
dsprintf (line, "%s", PR_GetString (pr, def->name));
break;
case ev_void:
@ -88,8 +88,8 @@ PR_UglyValueString (progs_t *pr, etype_t type, pr_type_t *val, dstring_t *line)
case ev_float:
dsprintf (line, "%.9g", val->float_var);
break;
case ev_integer:
dsprintf (line, "%d", val->integer_var);
case ev_int:
dsprintf (line, "%d", val->int_var);
break;
case ev_vector:
dsprintf (line, "%.9g %.9g %.9g", VectorExpand (&val->vector_var));
@ -132,7 +132,7 @@ ED_EntityDict (progs_t *pr, edict_t *ed)
// if the value is still all 0, skip the field
type = d->type & ~DEF_SAVEGLOBAL;
for (j = 0; j < pr_type_size[type]; j++)
if (v[j].integer_var)
if (v[j].int_var)
break;
if (j == pr_type_size[type])
continue;
@ -257,7 +257,7 @@ ED_ParseEpair (progs_t *pr, pr_type_t *base, pr_def_t *key, const char *s)
Sys_Printf ("Can't find field %s\n", s);
return false;
}
d->integer_var = G_INT (pr, def->ofs);
d->int_var = G_INT (pr, def->ofs);
break;
case ev_func:

276
libs/gamecode/pr_v6p_opcode.c
View File

@ -183,109 +183,109 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_EQ_D_v6p] = {"==", "eq.d",
ev_double, ev_double, ev_integer,
ev_double, ev_double, ev_int,
PROG_V6P_VERSION,
},
[OP_EQ_F_v6p] = {"==", "eq.f",
ev_float, ev_float, ev_integer,
ev_float, ev_float, ev_int,
PROG_ID_VERSION,
},
[OP_EQ_V_v6p] = {"==", "eq.v",
ev_vector, ev_vector, ev_integer,
ev_vector, ev_vector, ev_int,
PROG_ID_VERSION,
},
[OP_EQ_Q_v6p] = {"==", "eq.q",
ev_quat, ev_quat, ev_integer,
ev_quat, ev_quat, ev_int,
PROG_V6P_VERSION,
},
[OP_EQ_S_v6p] = {"==", "eq.s",
ev_string, ev_string, ev_integer,
ev_string, ev_string, ev_int,
PROG_ID_VERSION,
},
[OP_EQ_E_v6p] = {"==", "eq.e",
ev_entity, ev_entity, ev_integer,
ev_entity, ev_entity, ev_int,
PROG_ID_VERSION,
},
[OP_EQ_FN_v6p] = {"==", "eq.fn",
ev_func, ev_func, ev_integer,
ev_func, ev_func, ev_int,
PROG_ID_VERSION,
},
[OP_NE_D_v6p] = {"!=", "ne.d",
ev_double, ev_double, ev_integer,
ev_double, ev_double, ev_int,
PROG_V6P_VERSION,
},
[OP_NE_F_v6p] = {"!=", "ne.f",
ev_float, ev_float, ev_integer,
ev_float, ev_float, ev_int,
PROG_ID_VERSION,
},
[OP_NE_V_v6p] = {"!=", "ne.v",
ev_vector, ev_vector, ev_integer,
ev_vector, ev_vector, ev_int,
PROG_ID_VERSION,
},
[OP_NE_Q_v6p] = {"!=", "ne.q",
ev_quat, ev_quat, ev_integer,
ev_quat, ev_quat, ev_int,
PROG_V6P_VERSION,
},
[OP_NE_S_v6p] = {"!=", "ne.s",
ev_string, ev_string, ev_integer,
ev_string, ev_string, ev_int,
PROG_ID_VERSION,
},
[OP_NE_E_v6p] = {"!=", "ne.e",
ev_entity, ev_entity, ev_integer,
ev_entity, ev_entity, ev_int,
PROG_ID_VERSION,
},
[OP_NE_FN_v6p] = {"!=", "ne.fn",
ev_func, ev_func, ev_integer,
ev_func, ev_func, ev_int,
PROG_ID_VERSION,
},
[OP_LE_D_v6p] = {"<=", "le.d",
ev_double, ev_double, ev_integer,
ev_double, ev_double, ev_int,
PROG_V6P_VERSION,
},
[OP_LE_F_v6p] = {"<=", "le.f",
ev_float, ev_float, ev_integer,
ev_float, ev_float, ev_int,
PROG_ID_VERSION,
},
[OP_GE_D_v6p] = {">=", "ge.d",
ev_double, ev_double, ev_integer,
ev_double, ev_double, ev_int,
PROG_V6P_VERSION,
},
[OP_GE_F_v6p] = {">=", "ge.f",
ev_float, ev_float, ev_integer,
ev_float, ev_float, ev_int,
PROG_ID_VERSION,
},
[OP_LE_S_v6p] = {"<=", "le.s",
ev_string, ev_string, ev_integer,
ev_string, ev_string, ev_int,
PROG_V6P_VERSION,
},
[OP_GE_S_v6p] = {">=", "ge.s",
ev_string, ev_string, ev_integer,
ev_string, ev_string, ev_int,
PROG_V6P_VERSION,
},
[OP_LT_D_v6p] = {"<", "lt.d",
ev_double, ev_double, ev_integer,
ev_double, ev_double, ev_int,
PROG_V6P_VERSION,
},
[OP_LT_F_v6p] = {"<", "lt.f",
ev_float, ev_float, ev_integer,
ev_float, ev_float, ev_int,
PROG_ID_VERSION,
},
[OP_GT_D_v6p] = {">", "gt.d",
ev_double, ev_double, ev_integer,
ev_double, ev_double, ev_int,
PROG_V6P_VERSION,
},
[OP_GT_F_v6p] = {">", "gt.f",
ev_float, ev_float, ev_integer,
ev_float, ev_float, ev_int,
PROG_ID_VERSION,
},
[OP_LT_S_v6p] = {"<", "lt.s",
ev_string, ev_string, ev_integer,
ev_string, ev_string, ev_int,
PROG_V6P_VERSION,
},
[OP_GT_S_v6p] = {">", "gt.s",
ev_string, ev_string, ev_integer,
ev_string, ev_string, ev_int,
PROG_V6P_VERSION,
},
@ -330,7 +330,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga.%Gb(%Ec), %gc",
},
[OP_LOAD_I_v6p] = {".", "load.i",
ev_entity, ev_field, ev_integer,
ev_entity, ev_field, ev_int,
PROG_V6P_VERSION,
"%Ga.%Gb(%Ec), %gc",
},
@ -341,52 +341,52 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_LOADB_D_v6p] = {".", "loadb.d",
ev_pointer, ev_integer, ev_double,
ev_pointer, ev_int, ev_double,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_F_v6p] = {".", "loadb.f",
ev_pointer, ev_integer, ev_float,
ev_pointer, ev_int, ev_float,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_V_v6p] = {".", "loadb.v",
ev_pointer, ev_integer, ev_vector,
ev_pointer, ev_int, ev_vector,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_Q_v6p] = {".", "loadb.q",
ev_pointer, ev_integer, ev_quat,
ev_pointer, ev_int, ev_quat,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_S_v6p] = {".", "loadb.s",
ev_pointer, ev_integer, ev_string,
ev_pointer, ev_int, ev_string,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_ENT_v6p] = {".", "loadb.ent",
ev_pointer, ev_integer, ev_entity,
ev_pointer, ev_int, ev_entity,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_FLD_v6p] = {".", "loadb.fld",
ev_pointer, ev_integer, ev_field,
ev_pointer, ev_int, ev_field,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_FN_v6p] = {".", "loadb.fn",
ev_pointer, ev_integer, ev_func,
ev_pointer, ev_int, ev_func,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_I_v6p] = {".", "loadb.i",
ev_pointer, ev_integer, ev_integer,
ev_pointer, ev_int, ev_int,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
[OP_LOADB_P_v6p] = {".", "loadb.p",
ev_pointer, ev_integer, ev_pointer,
ev_pointer, ev_int, ev_pointer,
PROG_V6P_VERSION,
"*(%Ga + %Gb), %gc",
},
@ -432,7 +432,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"*(%Ga + %sb), %gc",
},
[OP_LOADBI_I_v6p] = {".", "loadbi.i",
ev_pointer, ev_short, ev_integer,
ev_pointer, ev_short, ev_int,
PROG_V6P_VERSION,
"*(%Ga + %sb), %gc",
},
@ -494,7 +494,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga, %gc",
},
[OP_ADDRESS_I_v6p] = {"&", "address.i",
ev_integer, ev_invalid, ev_pointer,
ev_int, ev_invalid, ev_pointer,
PROG_V6P_VERSION,
"%Ga, %gc",
},
@ -505,7 +505,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_LEA_v6p] = {"&", "lea",
ev_pointer, ev_integer, ev_pointer,
ev_pointer, ev_int, ev_pointer,
PROG_V6P_VERSION,
"(%Ga + %Gb), %gc",
},
@ -516,22 +516,22 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_CONV_IF_v6p] = {"<CONV>", "conv.if",
ev_integer, ev_invalid, ev_float,
ev_int, ev_invalid, ev_float,
PROG_V6P_VERSION,
"%Ga, %gc",
},
[OP_CONV_FI_v6p] = {"<CONV>", "conv.fi",
ev_float, ev_invalid, ev_integer,
ev_float, ev_invalid, ev_int,
PROG_V6P_VERSION,
"%Ga, %gc",
},
[OP_CONV_ID_v6p] = {"<CONV>", "conv.id",
ev_integer, ev_invalid, ev_double,
ev_int, ev_invalid, ev_double,
PROG_V6P_VERSION,
"%Ga, %gc",
},
[OP_CONV_DI_v6p] = {"<CONV>", "conv.di",
ev_double, ev_invalid, ev_integer,
ev_double, ev_invalid, ev_int,
PROG_V6P_VERSION,
"%Ga, %gc",
},
@ -587,7 +587,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga, %gb",
},
[OP_STORE_I_v6p] = {"=", "store.i",
ev_integer, ev_integer, ev_invalid,
ev_int, ev_int, ev_invalid,
PROG_V6P_VERSION,
"%Ga, %gb",
},
@ -638,7 +638,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga, *%Gb",
},
[OP_STOREP_I_v6p] = {".=", "storep.i",
ev_integer, ev_pointer, ev_invalid,
ev_int, ev_pointer, ev_invalid,
PROG_V6P_VERSION,
"%Ga, *%Gb",
},
@ -649,52 +649,52 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_STOREB_D_v6p] = {".=", "storeb.d",
ev_double, ev_pointer, ev_integer,
ev_double, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_F_v6p] = {".=", "storeb.f",
ev_float, ev_pointer, ev_integer,
ev_float, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_V_v6p] = {".=", "storeb.v",
ev_vector, ev_pointer, ev_integer,
ev_vector, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_Q_v6p] = {".=", "storeb.q",
ev_quat, ev_pointer, ev_integer,
ev_quat, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_S_v6p] = {".=", "storeb.s",
ev_string, ev_pointer, ev_integer,
ev_string, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_ENT_v6p] = {".=", "storeb.ent",
ev_entity, ev_pointer, ev_integer,
ev_entity, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_FLD_v6p] = {".=", "storeb.fld",
ev_field, ev_pointer, ev_integer,
ev_field, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_FN_v6p] = {".=", "storeb.fn",
ev_func, ev_pointer, ev_integer,
ev_func, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_I_v6p] = {".=", "storeb.i",
ev_integer, ev_pointer, ev_integer,
ev_int, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
[OP_STOREB_P_v6p] = {".=", "storeb.p",
ev_pointer, ev_pointer, ev_integer,
ev_pointer, ev_pointer, ev_int,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %Gc)",
},
@ -740,7 +740,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga, *(%Gb + %sc)",
},
[OP_STOREBI_I_v6p] = {".=", "storebi.i",
ev_integer, ev_pointer, ev_short,
ev_int, ev_pointer, ev_short,
PROG_V6P_VERSION,
"%Ga, *(%Gb + %sc)",
},
@ -763,73 +763,73 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_NOT_D_v6p] = {"!", "not.d",
ev_double, ev_invalid, ev_integer,
ev_double, ev_invalid, ev_int,
PROG_V6P_VERSION,
"%Ga, %gc",
},
[OP_NOT_F_v6p] = {"!", "not.f",
ev_float, ev_invalid, ev_integer,
ev_float, ev_invalid, ev_int,
PROG_ID_VERSION,
"%Ga, %gc",
},
[OP_NOT_V_v6p] = {"!", "not.v",
ev_vector, ev_invalid, ev_integer,
ev_vector, ev_invalid, ev_int,
PROG_ID_VERSION,
"%Ga, %gc",
},
[OP_NOT_Q_v6p] = {"!", "not.q",
ev_quat, ev_invalid, ev_integer,
ev_quat, ev_invalid, ev_int,
PROG_V6P_VERSION,
"%Ga, %gc",
},
[OP_NOT_S_v6p] = {"!", "not.s",
ev_string, ev_invalid, ev_integer,
ev_string, ev_invalid, ev_int,
PROG_ID_VERSION,
"%Ga, %gc",
},
[OP_NOT_ENT_v6p] = {"!", "not.ent",
ev_entity, ev_invalid, ev_integer,
ev_entity, ev_invalid, ev_int,
PROG_ID_VERSION,
"%Ga, %gc",
},
[OP_NOT_FN_v6p] = {"!", "not.fn",
ev_func, ev_invalid, ev_integer,
ev_func, ev_invalid, ev_int,
PROG_ID_VERSION,
"%Ga, %gc",
},
[OP_NOT_P_v6p] = {"!", "not.p",
ev_pointer, ev_invalid, ev_integer,
ev_pointer, ev_invalid, ev_int,
PROG_V6P_VERSION,
"%Ga, %gc",
},
[OP_IF_v6p] = {"<IF>", "if",
ev_integer, ev_short, ev_invalid,
ev_int, ev_short, ev_invalid,
PROG_ID_VERSION,
"%Ga branch %sb (%Ob)",
},
[OP_IFNOT_v6p] = {"<IFNOT>", "ifnot",
ev_integer, ev_short, ev_invalid,
ev_int, ev_short, ev_invalid,
PROG_ID_VERSION,
"%Ga branch %sb (%Ob)",
},
[OP_IFBE_v6p] = {"<IFBE>", "ifbe",
ev_integer, ev_short, ev_invalid,
ev_int, ev_short, ev_invalid,
PROG_V6P_VERSION,
"%Ga branch %sb (%Ob)",
},
[OP_IFB_v6p] = {"<IFB>", "ifb",
ev_integer, ev_short, ev_invalid,
ev_int, ev_short, ev_invalid,
PROG_V6P_VERSION,
"%Ga branch %sb (%Ob)",
},
[OP_IFAE_v6p] = {"<IFAE>", "ifae",
ev_integer, ev_short, ev_invalid,
ev_int, ev_short, ev_invalid,
PROG_V6P_VERSION,
"%Ga branch %sb (%Ob)",
},
[OP_IFA_v6p] = {"<IFA>", "ifa",
ev_integer, ev_short, ev_invalid,
ev_int, ev_short, ev_invalid,
PROG_V6P_VERSION,
"%Ga branch %sb (%Ob)",
},
@ -944,22 +944,22 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"branch %sa (%Oa)",
},
[OP_JUMP_v6p] = {"<JUMP>", "jump",
ev_integer, ev_invalid, ev_invalid,
ev_int, ev_invalid, ev_invalid,
PROG_V6P_VERSION,
"%Ga",
},
[OP_JUMPB_v6p] = {"<JUMPB>", "jumpb",
ev_void, ev_integer, ev_invalid,
ev_void, ev_int, ev_invalid,
PROG_V6P_VERSION,
"%Ga[%Gb]",
},
[OP_AND_v6p] = {"&&", "and.f",
ev_float, ev_float, ev_integer,
ev_float, ev_float, ev_int,
PROG_ID_VERSION,
},
[OP_OR_v6p] = {"||", "or.f",
ev_float, ev_float, ev_integer,
ev_float, ev_float, ev_int,
PROG_ID_VERSION,
},
@ -972,15 +972,15 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
PROG_V6P_VERSION,
},
[OP_SHL_I_v6p] = {"<<", "shl.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_SHR_I_v6p] = {">>", "shr.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_SHR_U_v6p] = {">>", "shr.u",
ev_uinteger, ev_integer, ev_uinteger,
ev_uint, ev_int, ev_uint,
PROG_V6P_VERSION,
},
@ -994,35 +994,35 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_ADD_I_v6p] = {"+", "add.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_SUB_I_v6p] = {"-", "sub.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_MUL_I_v6p] = {"*", "mul.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_DIV_I_v6p] = {"/", "div.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_REM_I_v6p] = {"%", "rem.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_MOD_I_v6p] = {"%%", "mod.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_BITAND_I_v6p] = {"&", "bitand.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_BITOR_I_v6p] = {"|", "bitor.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
@ -1037,58 +1037,58 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_GE_I_v6p] = {">=", "ge.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_LE_I_v6p] = {"<=", "le.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_GT_I_v6p] = {">", "gt.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_LT_I_v6p] = {"<", "lt.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_AND_I_v6p] = {"&&", "and.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_OR_I_v6p] = {"||", "or.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_NOT_I_v6p] = {"!", "not.i",
ev_integer, ev_invalid, ev_integer,
ev_int, ev_invalid, ev_int,
PROG_V6P_VERSION,
"%Ga, %gc",
},
[OP_EQ_I_v6p] = {"==", "eq.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_NE_I_v6p] = {"!=", "ne.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_GE_U_v6p] = {">=", "ge.u",
ev_uinteger, ev_uinteger, ev_integer,
ev_uint, ev_uint, ev_int,
PROG_V6P_VERSION,
},
[OP_LE_U_v6p] = {"<=", "le.u",
ev_uinteger, ev_uinteger, ev_integer,
ev_uint, ev_uint, ev_int,
PROG_V6P_VERSION,
},
[OP_GT_U_v6p] = {">", "gt.u",
ev_uinteger, ev_uinteger, ev_integer,
ev_uint, ev_uint, ev_int,
PROG_V6P_VERSION,
},
[OP_LT_U_v6p] = {"<", "lt.u",
ev_uinteger, ev_uinteger, ev_integer,
ev_uint, ev_uint, ev_int,
PROG_V6P_VERSION,
},
@ -1102,37 +1102,37 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga, %gc",
},
[OP_BITXOR_I_v6p] = {"^", "bitxor.i",
ev_integer, ev_integer, ev_integer,
ev_int, ev_int, ev_int,
PROG_V6P_VERSION,
},
[OP_BITNOT_I_v6p] = {"~", "bitnot.i",
ev_integer, ev_invalid, ev_integer,
ev_int, ev_invalid, ev_int,
PROG_V6P_VERSION,
"%Ga, %gc",
},
[OP_GE_P_v6p] = {">=", "ge.p",
ev_pointer, ev_pointer, ev_integer,
ev_pointer, ev_pointer, ev_int,
PROG_V6P_VERSION,
},
[OP_LE_P_v6p] = {"<=", "le.p",
ev_pointer, ev_pointer, ev_integer,
ev_pointer, ev_pointer, ev_int,
PROG_V6P_VERSION,
},
[OP_GT_P_v6p] = {">", "gt.p",
ev_pointer, ev_pointer, ev_integer,
ev_pointer, ev_pointer, ev_int,
PROG_V6P_VERSION,
},
[OP_LT_P_v6p] = {"<", "lt.p",
ev_pointer, ev_pointer, ev_integer,
ev_pointer, ev_pointer, ev_int,
PROG_V6P_VERSION,
},
[OP_EQ_P_v6p] = {"==", "eq.p",
ev_pointer, ev_pointer, ev_integer,
ev_pointer, ev_pointer, ev_int,
PROG_V6P_VERSION,
},
[OP_NE_P_v6p] = {"!=", "ne.p",
ev_pointer, ev_pointer, ev_integer,
ev_pointer, ev_pointer, ev_int,
PROG_V6P_VERSION,
},
@ -1142,7 +1142,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga, %sb, %gc",
},
[OP_MOVEP_v6p] = {"<MOVEP>", "movep",
ev_pointer, ev_integer, ev_pointer,
ev_pointer, ev_int, ev_pointer,
PROG_V6P_VERSION,
"%Ga, %Gb, %Gc",
},
@ -1152,17 +1152,17 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga, %sb, %Gc",
},
[OP_MEMSETI_v6p] = {"<MEMSET>", "memseti",
ev_integer, ev_short, ev_void,
ev_int, ev_short, ev_void,
PROG_V6P_VERSION,
"%Ga, %sb, %gc",
},
[OP_MEMSETP_v6p] = {"<MEMSETP>", "memsetp",
ev_integer, ev_integer, ev_pointer,
ev_int, ev_int, ev_pointer,
PROG_V6P_VERSION,
"%Ga, %Gb, %Gc",
},
[OP_MEMSETPI_v6p] = {"<MEMSETP>", "memsetpi",
ev_integer, ev_short, ev_pointer,
ev_int, ev_short, ev_pointer,
PROG_V6P_VERSION,
"%Ga, %sb, %Gc",
},
@ -1208,7 +1208,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%Ga",
},
[OP_PUSH_I_v6p] = {"<PUSH>", "push.i",
ev_integer, ev_invalid, ev_invalid,
ev_int, ev_invalid, ev_invalid,
PROG_V6P_VERSION,
"%Ga",
},
@ -1219,52 +1219,52 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_PUSHB_S_v6p] = {"<PUSH>", "pushb.s",
ev_pointer, ev_integer, ev_string,
ev_pointer, ev_int, ev_string,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_F_v6p] = {"<PUSH>", "pushb.f",
ev_pointer, ev_integer, ev_float,
ev_pointer, ev_int, ev_float,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_V_v6p] = {"<PUSH>", "pushb.v",
ev_pointer, ev_integer, ev_vector,
ev_pointer, ev_int, ev_vector,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_ENT_v6p] = {"<PUSH>", "pushb.ent",
ev_pointer, ev_integer, ev_entity,
ev_pointer, ev_int, ev_entity,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_FLD_v6p] = {"<PUSH>", "pushb.fld",
ev_pointer, ev_integer, ev_field,
ev_pointer, ev_int, ev_field,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_FN_v6p] = {"<PUSH>", "pushb.fn",
ev_pointer, ev_integer, ev_func,
ev_pointer, ev_int, ev_func,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_P_v6p] = {"<PUSH>", "pushb.p",
ev_pointer, ev_integer, ev_pointer,
ev_pointer, ev_int, ev_pointer,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_Q_v6p] = {"<PUSH>", "pushb.q",
ev_pointer, ev_integer, ev_quat,
ev_pointer, ev_int, ev_quat,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_I_v6p] = {"<PUSH>", "pushb.i",
ev_pointer, ev_integer, ev_integer,
ev_pointer, ev_int, ev_int,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_PUSHB_D_v6p] = {"<PUSH>", "pushb.d",
ev_pointer, ev_integer, ev_double,
ev_pointer, ev_int, ev_double,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
@ -1310,7 +1310,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"*(%Ga + %sb)",
},
[OP_PUSHBI_I_v6p] = {"<PUSH>", "pushbi.i",
ev_pointer, ev_short, ev_integer,
ev_pointer, ev_short, ev_int,
PROG_V6P_VERSION,
"*(%Ga + %sb)",
},
@ -1361,7 +1361,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"%ga",
},
[OP_POP_I_v6p] = {"<POP>", "pop.i",
ev_integer, ev_invalid, ev_invalid,
ev_int, ev_invalid, ev_invalid,
PROG_V6P_VERSION,
"%ga",
},
@ -1372,52 +1372,52 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
},
[OP_POPB_S_v6p] = {"<POP>", "popb.s",
ev_pointer, ev_integer, ev_string,
ev_pointer, ev_int, ev_string,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_F_v6p] = {"<POP>", "popb.f",
ev_pointer, ev_integer, ev_float,
ev_pointer, ev_int, ev_float,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_V_v6p] = {"<POP>", "popb.v",
ev_pointer, ev_integer, ev_vector,
ev_pointer, ev_int, ev_vector,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_ENT_v6p] = {"<POP>", "popb.ent",
ev_pointer, ev_integer, ev_entity,
ev_pointer, ev_int, ev_entity,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_FLD_v6p] = {"<POP>", "popb.fld",
ev_pointer, ev_integer, ev_field,
ev_pointer, ev_int, ev_field,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_FN_v6p] = {"<POP>", "popb.fn",
ev_pointer, ev_integer, ev_func,
ev_pointer, ev_int, ev_func,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_P_v6p] = {"<POP>", "popb.p",
ev_pointer, ev_integer, ev_pointer,
ev_pointer, ev_int, ev_pointer,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_Q_v6p] = {"<POP>", "popb.q",
ev_pointer, ev_integer, ev_quat,
ev_pointer, ev_int, ev_quat,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_I_v6p] = {"<POP>", "popb.i",
ev_pointer, ev_integer, ev_integer,
ev_pointer, ev_int, ev_int,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
[OP_POPB_D_v6p] = {"<POP>", "popb.d",
ev_pointer, ev_integer, ev_double,
ev_pointer, ev_int, ev_double,
PROG_V6P_VERSION,
"*(%Ga + %Gb)",
},
@ -1463,7 +1463,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
"*(%Ga + %sb)",
},
[OP_POPBI_I_v6p] = {"<POP>", "popbi.i",
ev_pointer, ev_short, ev_integer,
ev_pointer, ev_short, ev_int,
PROG_V6P_VERSION,
"*(%Ga + %sb)",
},
@ -1652,7 +1652,7 @@ PR_Check_Opcodes (progs_t *pr)
break;
case OP_DONE_v6p:
case OP_RETURN_v6p:
check_global (pr, st, op, ev_integer, st->a, 1);
check_global (pr, st, op, ev_int, st->a, 1);
check_global (pr, st, op, ev_void, st->b, 0);
check_global (pr, st, op, ev_void, st->c, 0);
break;
@ -1666,8 +1666,8 @@ PR_Check_Opcodes (progs_t *pr)
case OP_RCALL7_v6p:
case OP_RCALL8_v6p:
if (st_op > OP_RCALL1_v6p)
check_global (pr, st, op, ev_integer, st->c, 1);
check_global (pr, st, op, ev_integer, st->b, 1);
check_global (pr, st, op, ev_int, st->c, 1);
check_global (pr, st, op, ev_int, st->b, 1);
check_global (pr, st, op, ev_func, st->a, 1);
break;
case OP_STATE_v6p:

2
libs/gib/bi_gib.c
View File

@ -86,7 +86,7 @@ bi_gib_builtin_f (void)
pr_list = PR_Zone_Malloc (builtin->pr, GIB_Argc() * sizeof (pr_type_t));
for (i = 0; i < GIB_Argc(); i++)
pr_list[i].integer_var = PR_SetTempString (builtin->pr, GIB_Argv(i));
pr_list[i].int_var = PR_SetTempString (builtin->pr, GIB_Argv(i));
PR_RESET_PARAMS (builtin->pr);
P_INT (builtin->pr, 0) = GIB_Argc();

10
libs/ruamoko/pr_cmds.c
View File

@ -295,7 +295,7 @@ PF_Find (progs_t *pr)
continue;
RETURN_EDICT (pr, ed);
return;
case ev_integer:
case ev_int:
case ev_entity:
if (P_INT (pr, 2) != E_INT (ed, f))
continue;
@ -420,7 +420,7 @@ PF_nextent (progs_t *pr)
#endif
/*
integer (float f) ftoi
int (float f) ftoi
*/
static void
PF_ftoi (progs_t *pr)
@ -453,7 +453,7 @@ PF_ftos (progs_t *pr)
}
/*
float (integer i) itof
float (int i) itof
*/
static void
PF_itof (progs_t *pr)
@ -462,7 +462,7 @@ PF_itof (progs_t *pr)
}
/*
string (integer i) itos
string (int i) itos
*/
static void
PF_itos (progs_t *pr)
@ -484,7 +484,7 @@ PF_stof (progs_t *pr)
}
/*
integer (string s) stoi
int (string s) stoi
*/
static void
PF_stoi (progs_t *pr)

6
libs/ruamoko/rua_hash.c
View File

@ -259,7 +259,7 @@ bi_Hash_FindList (progs_t *pr)
pr_list = PR_Zone_Malloc (pr, count * sizeof (pr_type_t));
// the hash tables stores progs pointers...
for (count = 0, l = list; *l; l++)
pr_list[count++].integer_var = (intptr_t) *l;
pr_list[count++].int_var = (intptr_t) *l;
free (list);
RETURN_POINTER (pr, pr_list);
}
@ -278,7 +278,7 @@ bi_Hash_FindElementList (progs_t *pr)
pr_list = PR_Zone_Malloc (pr, count * sizeof (pr_type_t));
// the hash tables stores progs pointers...
for (count = 0, l = list; *l; l++)
pr_list[count++].integer_var = (intptr_t) *l;
pr_list[count++].int_var = (intptr_t) *l;
free (list);
RETURN_POINTER (pr, pr_list);
}
@ -334,7 +334,7 @@ bi_Hash_GetList (progs_t *pr)
pr_list = PR_Zone_Malloc (pr, count * sizeof (pr_type_t));
// the hash tables stores progs pointers...
for (count = 0, l = list; *l; l++)
pr_list[count++].integer_var = (intptr_t) *l;
pr_list[count++].int_var = (intptr_t) *l;
free (list);
RETURN_POINTER (pr, pr_list);
}

6
libs/ruamoko/rua_obj.c
View File

@ -1444,21 +1444,21 @@ static void
rua_obj_increment_retaincount (progs_t *pr)
{
pr_type_t *obj = &P_STRUCT (pr, pr_type_t, 0);
R_INT (pr) = ++(*--obj).integer_var;
R_INT (pr) = ++(*--obj).int_var;
}
static void
rua_obj_decrement_retaincount (progs_t *pr)
{
pr_type_t *obj = &P_STRUCT (pr, pr_type_t, 0);
R_INT (pr) = --(*--obj).integer_var;
R_INT (pr) = --(*--obj).int_var;
}
static void
rua_obj_get_retaincount (progs_t *pr)
{
pr_type_t *obj = &P_STRUCT (pr, pr_type_t, 0);
R_INT (pr) = (*--obj).integer_var;
R_INT (pr) = (*--obj).int_var;
}
static void

4
libs/video/renderer/vulkan/vkgen/vktype.r
View File

@ -77,7 +77,7 @@ static string get_type_key (void *type, void *unused)
-(string) name
{
if (type.meta == ty_basic) {
if (type.type == ev_integer) {
if (type.type == ev_int) {
return "int";
}
return pr_type_name[type.type];
@ -123,7 +123,7 @@ static string get_type_key (void *type, void *unused)
-(string) parseData
{
if (type.meta == ty_basic) {
if (type.type == ev_integer) {
if (type.type == ev_int) {
return "&cexpr_int";
}
return "&cexpr_" + pr_type_name[type.type];

2
nq/include/sv_progs.h
View File

@ -187,7 +187,7 @@ extern progs_t sv_pr_state;
#define SVfunc(e,f) SVFIELD (e, f, func)
#define SVentity(e,f) SVFIELD (e, f, entity)
#define SVvector(e,f) (&SVFIELD (e, f, vector))
#define SVinteger(e,f) SVFIELD (e, f, integer)
#define SVint(e,f) SVFIELD (e, f, int)
#if TYPECHECK_PROGS
#define SVdouble(e,f) E_DOUBLE (e, PR_AccessField (&sv_pr_state, #f, ev_##t, __FILE__, __LINE__))
#else

6
nq/source/sv_progs.c
View File

@ -323,7 +323,7 @@ static sv_def_t nq_opt_funcs[] = {
};
static sv_def_t nq_opt_fields[] = {
{ev_integer, 0, "rotated_bbox", &sv_fields.rotated_bbox},
{ev_int, 0, "rotated_bbox", &sv_fields.rotated_bbox},
{ev_float, 0, "alpha", &sv_fields.alpha},
{ev_float, 0, "gravity", &sv_fields.gravity},
{ev_float, 0, "items2", &sv_fields.items2},
@ -355,8 +355,8 @@ set_address (sv_def_t *def, void *address)
case ev_field:
case ev_func:
case ev_pointer:
case ev_integer:
case ev_uinteger:
case ev_int:
case ev_uint:
*(pr_int_t **)def->field = (pr_int_t *) address;
break;
case ev_long:

6
nq/source/world.c
View File

@ -215,7 +215,7 @@ SV_HullForEntity (edict_t *ent, const vec3_t mins, const vec3_t maxs,
vec3_t hullmins, hullmaxs, size;
if ((sv_fields.rotated_bbox != -1
&& SVinteger (ent, rotated_bbox))
&& SVint (ent, rotated_bbox))
|| SVfloat (ent, solid) == SOLID_BSP) {
VectorSubtract (maxs, mins, size);
if (size[0] < 3)
@ -226,8 +226,8 @@ SV_HullForEntity (edict_t *ent, const vec3_t mins, const vec3_t maxs,
hull_index = 2;
}
if (sv_fields.rotated_bbox != -1
&& SVinteger (ent, rotated_bbox)) {
int h = SVinteger (ent, rotated_bbox) - 1;
&& SVint (ent, rotated_bbox)) {
int h = SVint (ent, rotated_bbox) - 1;
hull_list = pf_hull_list[h]->hulls;
} if (SVfloat (ent, solid) == SOLID_BSP) {
// explicit hulls in the BSP model

2
qw/include/sv_progs.h
View File

@ -194,7 +194,7 @@ extern progs_t sv_pr_state;
#define SVfunc(e,f) SVFIELD (e, f, func)
#define SVentity(e,f) SVFIELD (e, f, entity)
#define SVvector(e,f) (&SVFIELD (e, f, vector))
#define SVinteger(e,f) SVFIELD (e, f, integer)
#define SVint(e,f) SVFIELD (e, f, int)
#if TYPECHECK_PROGS
#define SVdouble(e,f) E_DOUBLE (e, PR_AccessField (&sv_pr_state, #f, ev_##t, __FILE__, __LINE__))
#else

6
qw/source/sv_progs.c
View File

@ -352,7 +352,7 @@ static sv_def_t qw_opt_funcs[] = {
};
static sv_def_t qw_opt_fields[] = {
{ev_integer, 0, "rotated_bbox", &sv_fields.rotated_bbox},
{ev_int, 0, "rotated_bbox", &sv_fields.rotated_bbox},
{ev_float, 0, "alpha", &sv_fields.alpha},
{ev_float, 0, "scale", &sv_fields.scale},
{ev_float, 0, "glow_size", &sv_fields.glow_size},
@ -388,8 +388,8 @@ set_address (sv_def_t *def, void *address)
case ev_field:
case ev_func:
case ev_pointer:
case ev_integer:
case ev_uinteger:
case ev_int:
case ev_uint:
*(pr_int_t **)def->field = (pr_int_t *) address;
break;
case ev_long:

4
qw/source/sv_user.c
View File

@ -1548,8 +1548,8 @@ AddLinksToPmove (areanode_t *node)
pe->info = NUM_FOR_EDICT (&sv_pr_state, check);
if (sv_fields.rotated_bbox != -1
&& SVinteger (check, rotated_bbox)) {
int h = SVinteger (check, rotated_bbox) - 1;
&& SVint (check, rotated_bbox)) {
int h = SVint (check, rotated_bbox) - 1;
pe->hull = pf_hull_list[h]->hulls[1];
} else {

6
qw/source/world.c
View File

@ -215,7 +215,7 @@ SV_HullForEntity (edict_t *ent, const vec3_t mins, const vec3_t maxs,
vec3_t hullmins, hullmaxs, size;
if ((sv_fields.rotated_bbox != -1
&& SVinteger (ent, rotated_bbox))
&& SVint (ent, rotated_bbox))
|| SVfloat (ent, solid) == SOLID_BSP) {
VectorSubtract (maxs, mins, size);
if (size[0] < 3)
@ -226,8 +226,8 @@ SV_HullForEntity (edict_t *ent, const vec3_t mins, const vec3_t maxs,
hull_index = 2;
}
if (sv_fields.rotated_bbox != -1
&& SVinteger (ent, rotated_bbox)) {
int h = SVinteger (ent, rotated_bbox) - 1;
&& SVint (ent, rotated_bbox)) {
int h = SVint (ent, rotated_bbox) - 1;
hull_list = pf_hull_list[h]->hulls;
} if (SVfloat (ent, solid) == SOLID_BSP) {
// explicit hulls in the BSP model

2
ruamoko/cl_menu/plistmenu.r
View File

@ -84,7 +84,7 @@ class_from_plist (PLDictionary *pldict)
if (str_str (paramstr, ".") >= 0)
va_list.list[j].float_val = stof (paramstr);
else
va_list.list[j].integer_val = stoi (paramstr);
va_list.list[j].int_val = stoi (paramstr);
break;
}
}

4
ruamoko/include/types.h
View File

@ -11,8 +11,8 @@ typedef enum {
ev_func,
ev_pointer, // end of v6 types
ev_quat,
ev_integer,
ev_uinteger,
ev_int,
ev_uint,
ev_short, // value is embedded in the opcode
ev_double,

2
ruamoko/qwaq/debugger/typeencodings.r
View File

@ -221,7 +221,7 @@ error:
break;
case ty_enum:
// enums are ints
size = pr_type_size[ev_integer];
size = pr_type_size[ev_int];
break;
case ty_class:
//FIXME

32
tools/qfcc/include/expr.h
View File

@ -201,8 +201,8 @@ typedef struct ex_value_s {
ex_func_t func_val; ///< function constant
ex_pointer_t pointer; ///< pointer constant
float quaternion_val[4]; ///< quaternion constant
int integer_val; ///< integer constant
unsigned uinteger_val; ///< unsigned integer constant
int int_val; ///< int constant
unsigned uint_val; ///< unsigned int constant
short short_val; ///< short constant
} v;
} ex_value_t;
@ -571,23 +571,23 @@ expr_t *new_pointer_expr (int val, struct type_s *type, struct def_s *def);
expr_t *new_quaternion_expr (const float *quaternion_val);
const float *expr_quaternion (expr_t *e) __attribute__((pure));
/** Create a new integer constant expression node.
/** Create a new itn constant expression node.
\param integer_val The integer constant being represented.
\return The new integer constant expression node
(expr_t::e::integer_val).
\param int_val The int constant being represented.
\return The new int constant expression node
(expr_t::e::int_val).
*/
expr_t *new_integer_expr (int integer_val);
int expr_integer (expr_t *e) __attribute__((pure));
expr_t *new_int_expr (int int_val);
int expr_int (expr_t *e) __attribute__((pure));
/** Create a new integer constant expression node.
/** Create a new int constant expression node.
\param uinteger_val The integer constant being represented.
\return The new integer constant expression node
(expr_t::e::integer_val).
\param uint_val The int constant being represented.
\return The new int constant expression node
(expr_t::e::int_val).
*/
expr_t *new_uinteger_expr (unsigned uinteger_val);
unsigned expr_uinteger (expr_t *e) __attribute__((pure));
expr_t *new_uint_expr (unsigned uint_val);
unsigned expr_uint (expr_t *e) __attribute__((pure));
/** Create a new short constant expression node.
@ -652,8 +652,8 @@ int is_string_val (expr_t *e) __attribute__((pure));
int is_float_val (expr_t *e) __attribute__((pure));
int is_vector_val (expr_t *e) __attribute__((pure));
int is_quaternion_val (expr_t *e) __attribute__((pure));
int is_integer_val (expr_t *e) __attribute__((pure));
int is_uinteger_val (expr_t *e) __attribute__((pure));
int is_int_val (expr_t *e) __attribute__((pure));
int is_uint_val (expr_t *e) __attribute__((pure));
int is_short_val (expr_t *e) __attribute__((pure));
int is_integral_val (expr_t *e) __attribute__((pure));
int is_pointer_val (expr_t *e) __attribute__((pure));

8
tools/qfcc/include/obj_file.h
View File

@ -334,10 +334,10 @@ enum {
*/
#define QFO_FLOAT(q, s, o) QFO_var (q, s, float, o)
/** Access a integer variable in the object file. Can be assigned to.
/** Access a int variable in the object file. Can be assigned to.
\par QC type:
\c integer
\c int
\param q pointer to ::qfo_t struct
\param s space index
\param o offset into object file data space
@ -345,7 +345,7 @@ enum {
\hideinitializer
*/
#define QFO_INT(q, s, o) QFO_var (q, s, integer, o)
#define QFO_INT(q, s, o) QFO_var (q, s, int, o)
/** Access a vector variable in the object file. Can be assigned to.
@ -438,7 +438,7 @@ enum {
\hideinitializer
*/
#define QFO_POINTER(q, s, t, o) ((t *)(char *)&QFO_var (q, s, integer, o))
#define QFO_POINTER(q, s, t, o) ((t *)(char *)&QFO_var (q, s, int, o))
/** Access a structure variable in the object file. Can be assigned to.

2
tools/qfcc/include/qfcc.h
View File

@ -100,7 +100,7 @@ extern pr_info_t pr;
#define D_var(t, d) ((d)->space->data[(d)->offset].t##_var)
#define D_DOUBLE(d) (*(double *) ((d)->space->data + (d)->offset))
#define D_FLOAT(d) D_var (float, d)
#define D_INT(d) D_var (integer, d)
#define D_INT(d) D_var (int, d)
#define D_VECTOR(d) (&D_var (vector, d))
#define D_QUAT(d) (&D_var (quat, d))
#define D_STRING(d) D_var (string, d)

8
tools/qfcc/include/type.h
View File

@ -108,8 +108,8 @@ extern type_t type_function;
extern type_t type_pointer;
extern type_t type_floatfield;
extern type_t type_quaternion;
extern type_t type_integer;
extern type_t type_uinteger;
extern type_t type_int;
extern type_t type_uint;
extern type_t type_short;
extern type_t *type_nil; // for passing nil into ...
@ -161,8 +161,8 @@ void encode_type (struct dstring_s *encoding, const type_t *type);
const char *type_get_encoding (const type_t *type);
int is_void (const type_t *type) __attribute__((pure));
int is_enum (const type_t *type) __attribute__((pure));
int is_integer (const type_t *type) __attribute__((pure));
int is_uinteger (const type_t *type) __attribute__((pure));
int is_int (const type_t *type) __attribute__((pure));
int is_uint (const type_t *type) __attribute__((pure));
int is_short (const type_t *type) __attribute__((pure));
int is_integral (const type_t *type) __attribute__((pure));
int is_double (const type_t *type) __attribute__((pure));

4
tools/qfcc/include/value.h
View File

@ -53,8 +53,8 @@ struct ex_value_s *new_pointer_val (int val, struct type_s *type,
struct def_s *def,
struct operand_s *tempop);
struct ex_value_s *new_quaternion_val (const float *quaternion_val);
struct ex_value_s *new_integer_val (int integer_val);
struct ex_value_s *new_uinteger_val (int uinteger_val);
struct ex_value_s *new_int_val (int int_val);
struct ex_value_s *new_uint_val (int uint_val);
struct ex_value_s *new_short_val (short short_val);
struct ex_value_s *new_nil_val (struct type_s *type);

48
tools/qfcc/source/class.c
View File

@ -132,7 +132,7 @@ static struct_def_t category_struct[] = {
static struct_def_t ivar_struct[] = {
{"ivar_name", &type_string},
{"ivar_type", &type_string},
{"ivar_offset", &type_integer},
{"ivar_offset", &type_int},
{0, 0}
};
@ -143,8 +143,8 @@ static struct_def_t super_struct[] = {
};
static struct_def_t module_struct[] = {
{"version", &type_integer},
{"size", &type_integer},
{"version", &type_int},
{"size", &type_int},
{"name", &type_string},
{"symtab", &type_pointer},
{0, 0}
@ -154,9 +154,9 @@ static struct_def_t class_struct[] = {
{"class_pointer", &type_Class},
{"super_class", &type_Class},
{"name", &type_string},
{"version", &type_integer},
{"info", &type_integer},
{"instance_size", &type_integer},
{"version", &type_int},
{"info", &type_int},
{"instance_size", &type_int},
{"ivars", &type_pointer},
{"methods", &type_pointer},
{"dtable", &type_pointer},
@ -729,8 +729,8 @@ emit_ivar_count (def_t *def, void *data, int index)
{
ivar_data_t *ivar_data = (ivar_data_t *) data;
if (!is_integer(def->type))
internal_error (0, "%s: expected integer def", __FUNCTION__);
if (!is_int(def->type))
internal_error (0, "%s: expected int def", __FUNCTION__);
D_INT (def) = ivar_data->count;
}
@ -774,8 +774,8 @@ static def_t *
emit_ivars (symtab_t *ivars, const char *name)
{
static struct_def_t ivar_list_struct[] = {
{"ivar_count", &type_integer, emit_ivar_count},
{"ivar_list", 0, emit_ivar_list_item},
{"ivar_count", &type_int, emit_ivar_count},
{"ivar_list", 0, emit_ivar_list_item},
{0, 0}
};
ivar_data_t ivar_data = {0, 0, 0};
@ -1411,8 +1411,8 @@ emit_symtab_ref_cnt (def_t *def, void *data, int index)
{
obj_symtab_data_t *da = (obj_symtab_data_t *)data;
if (!is_integer(def->type))
internal_error (0, "%s: expected integer def", __FUNCTION__);
if (!is_int(def->type))
internal_error (0, "%s: expected int def", __FUNCTION__);
D_INT (def) = 0;
if (da->refs)
D_INT (def) = da->refs->type->t.array.size;
@ -1435,8 +1435,8 @@ emit_symtab_cls_def_cnt (def_t *def, void *data, int index)
{
obj_symtab_data_t *da = (obj_symtab_data_t *)data;
if (!is_integer(def->type))
internal_error (0, "%s: expected integer def", __FUNCTION__);
if (!is_int(def->type))
internal_error (0, "%s: expected int def", __FUNCTION__);
D_INT (def) = da->cls_def_cnt;
}
@ -1445,8 +1445,8 @@ emit_symtab_cat_def_cnt (def_t *def, void *data, int index)
{
obj_symtab_data_t *da = (obj_symtab_data_t *)data;
if (!is_integer(def->type))
internal_error (0, "%s: expected integer def", __FUNCTION__);
if (!is_int(def->type))
internal_error (0, "%s: expected int def", __FUNCTION__);
D_INT (def) = da->cat_def_cnt;
}
@ -1489,11 +1489,11 @@ void
class_finish_module (void)
{
static struct_def_t symtab_struct[] = {
{"sel_ref_cnt", &type_integer, emit_symtab_ref_cnt},
{"refs", &type_SEL, emit_symtab_refs},
{"cls_def_cnt", &type_integer, emit_symtab_cls_def_cnt},
{"cat_def_cnt", &type_integer, emit_symtab_cat_def_cnt},
{"defs", 0, emit_symtab_defs},
{"sel_ref_cnt", &type_int, emit_symtab_ref_cnt},
{"refs", &type_SEL, emit_symtab_refs},
{"cls_def_cnt", &type_int, emit_symtab_cls_def_cnt},
{"cat_def_cnt", &type_int, emit_symtab_cat_def_cnt},
{"defs", 0, emit_symtab_defs},
{0, 0}
};
@ -1750,8 +1750,8 @@ emit_protocol_count (def_t *def, void *data, int index)
{
protocollist_t *protocols = (protocollist_t *) data;
if (!is_integer(def->type)) {
internal_error (0, "%s: expected integer def", __FUNCTION__);
if (!is_int(def->type)) {
internal_error (0, "%s: expected int def", __FUNCTION__);
}
D_INT (def) = protocols->count;
}
@ -1777,7 +1777,7 @@ emit_protocol_list (protocollist_t *protocols, const char *name)
{
static struct_def_t proto_list_struct[] = {
{"next", &type_pointer, emit_protocol_next},
{"count", &type_integer, emit_protocol_count},
{"count", &type_int, emit_protocol_count},
{"list", 0, emit_protocol_list_item},
{0, 0},
};

186
tools/qfcc/source/constfold.c
View File

@ -76,7 +76,7 @@ cmp_result_expr (int result)
if (is_float (type_default)) {
return new_float_expr (result);
} else {
return new_integer_expr(result);
return new_int_expr(result);
}
}
@ -92,7 +92,7 @@ do_op_string (int op, expr_t *e, expr_t *e1, expr_t *e2)
if (is_compare (op) || is_logic (op)) {
if (options.code.progsversion > PROG_ID_VERSION)
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
else
e->e.expr.type = &type_float;
} else {
@ -153,7 +153,7 @@ convert_to_float (expr_t *e)
switch (e->type) {
case ex_value:
switch (e->e.value->lltype) {
case ev_integer:
case ev_int:
convert_int (e);
return e;
case ev_short:
@ -188,8 +188,8 @@ convert_to_double (expr_t *e)
switch (e->type) {
case ex_value:
switch (e->e.value->lltype) {
case ev_integer:
e->e.value = new_double_val (expr_integer (e));
case ev_int:
e->e.value = new_double_val (expr_int (e));
return e;
case ev_short:
e->e.value = new_double_val (expr_short (e));
@ -235,7 +235,7 @@ do_op_float (int op, expr_t *e, expr_t *e1, expr_t *e2)
}
if (is_compare (op) || is_logic (op)) {
if (options.code.progsversion > PROG_ID_VERSION)
type = &type_integer;
type = &type_int;
else
type = &type_float;
}
@ -354,7 +354,7 @@ do_op_double (int op, expr_t *e, expr_t *e1, expr_t *e2)
e->e.expr.e2 = e2 = conv;
}
if (is_compare (op) || is_logic (op)) {
type = &type_integer;
type = &type_int;
}
e->e.expr.type = type;
@ -456,7 +456,7 @@ do_op_vector (int op, expr_t *e, expr_t *e1, expr_t *e2)
}
if (is_compare (op) || is_logic (op)) {
if (options.code.progsversion > PROG_ID_VERSION)
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
else
e->e.expr.type = &type_float;
} else if (op == '*' && is_vector(get_type (e2))) {
@ -555,7 +555,7 @@ do_op_entity (int op, expr_t *e, expr_t *e1, expr_t *e2)
}
if (op == EQ || op == NE) {
if (options.code.progsversion > PROG_ID_VERSION)
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
else
e->e.expr.type = &type_float;
return e;
@ -577,7 +577,7 @@ do_op_func (int op, expr_t *e, expr_t *e1, expr_t *e2)
{
if (op == EQ || op == NE) {
if (options.code.progsversion > PROG_ID_VERSION)
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
else
e->e.expr.type = &type_float;
return e;
@ -606,23 +606,23 @@ do_op_pointer (int op, expr_t *e, expr_t *e1, expr_t *e2)
type = get_type (e1);
if (type != get_type (e2))
return error (e2, "invalid operands to binary -");
e1 = new_alias_expr (&type_integer, e1);
e2 = new_alias_expr (&type_integer, e2);
e1 = new_alias_expr (&type_int, e1);
e2 = new_alias_expr (&type_int, e2);
e = binary_expr ('-', e1, e2);
if (type_size (type) != 1)
e = binary_expr ('/', e, new_integer_expr (type_size (type)));
e = binary_expr ('/', e, new_int_expr (type_size (type)));
return e;
}
if (op == EQ || op == NE) {
if (options.code.progsversion > PROG_ID_VERSION)
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
else
e->e.expr.type = &type_float;
}
if (op != '.' && extract_type (e1) != extract_type (e2))
return type_mismatch (e1, e2, op);
if (op == '.' && is_uinteger(get_type (e2)))
e->e.expr.e2 = cf_cast_expr (&type_integer, e2);
if (op == '.' && is_uint(get_type (e2)))
e->e.expr.e2 = cf_cast_expr (&type_int, e2);
return e;
}
@ -677,7 +677,7 @@ do_op_quaternion (int op, expr_t *e, expr_t *e1, expr_t *e2)
}
if (is_compare (op) || is_logic (op)) {
if (options.code.progsversion > PROG_ID_VERSION)
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
else
e->e.expr.type = &type_float;
} else if (op == '/' && !is_constant (e1)) {
@ -759,7 +759,7 @@ do_op_quaternion (int op, expr_t *e, expr_t *e1, expr_t *e2)
}
static expr_t *
do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2)
do_op_int (int op, expr_t *e, expr_t *e1, expr_t *e2)
{
int isval1 = 0, isval2 = 0;
int val1 = 0, val2 = 0;
@ -769,33 +769,33 @@ do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2)
};
if (!valid_op (op, valid))
return error (e1, "invalid operator for integer");
return error (e1, "invalid operator for int");
if (is_short_val (e1)) {
isval1 = 1;
val1 = expr_short (e1);
}
if (is_integer_val (e1)) {
if (is_int_val (e1)) {
isval1 = 1;
val1 = expr_integer (e1);
val1 = expr_int (e1);
}
if (is_short_val (e2)) {
isval2 = 1;
val2 = expr_short (e2);
}
if (is_integer_val (e2)) {
if (is_int_val (e2)) {
isval2 = 1;
val2 = expr_integer (e2);
val2 = expr_int (e2);
}
if (is_compare (op) || is_logic (op)) {
if (options.code.progsversion > PROG_ID_VERSION)
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
else
e->e.expr.type = &type_float;
} else {
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
}
if (op == '*' && isval1 && val1 == 1)
@ -824,36 +824,36 @@ do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2)
switch (op) {
case '+':
e = new_integer_expr (val1 + val2);
e = new_int_expr (val1 + val2);
break;
case '-':
e = new_integer_expr (val1 - val2);
e = new_int_expr (val1 - val2);
break;
case '*':
e = new_integer_expr (val1 * val2);
e = new_int_expr (val1 * val2);
break;
case '/':
if (options.warnings.integer_divide)
warning (e2, "%d / %d == %d", val1, val2, val1 / val2);
e = new_integer_expr (val1 / val2);
e = new_int_expr (val1 / val2);
break;
case '&':
e = new_integer_expr (val1 & val2);
e = new_int_expr (val1 & val2);
break;
case '|':
e = new_integer_expr (val1 | val2);
e = new_int_expr (val1 | val2);
break;
case '^':
e = new_integer_expr (val1 ^ val2);
e = new_int_expr (val1 ^ val2);
break;
case '%':
e = new_integer_expr (val1 % val2);
e = new_int_expr (val1 % val2);
break;
case SHL:
e = new_integer_expr (val1 << val2);
e = new_int_expr (val1 << val2);
break;
case SHR:
e = new_integer_expr (val1 >> val2);
e = new_int_expr (val1 >> val2);
break;
case AND:
e = cmp_result_expr (val1 && val2);
@ -888,7 +888,7 @@ do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2)
}
static expr_t *
do_op_uinteger (int op, expr_t *e, expr_t *e1, expr_t *e2)
do_op_uint (int op, expr_t *e, expr_t *e1, expr_t *e2)
{
return e;
}
@ -907,7 +907,7 @@ do_op_short (int op, expr_t *e, expr_t *e1, expr_t *e2)
if (is_compare (op) || is_logic (op)) {
if (options.code.progsversion > PROG_ID_VERSION)
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
else
e->e.expr.type = &type_float;
} else {
@ -1004,14 +1004,14 @@ do_op_compound (int op, expr_t *e, expr_t *e1, expr_t *e2)
return do_op_float (op, e, e1, e2);
if (t2->type == ev_double)
return do_op_float (op, e, e1, e2);
return do_op_integer (op, e, e1, e2);
return do_op_int (op, e, e1, e2);
}
if (is_enum (t2)) {
if (t1->type == ev_double)
return do_op_double (op, e, e1, e2);
if (t1->type == ev_float)
return do_op_float (op, e, e1, e2);
return do_op_integer (op, e, e1, e2);
return do_op_int (op, e, e1, e2);
}
}
return error (e1, "invalid operator for compound");
@ -1062,8 +1062,8 @@ static operation_t op_void[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_invalid, // ev_quaternion
do_op_invalid, // ev_integer
do_op_invalid, // ev_uinteger
do_op_invalid, // ev_int
do_op_invalid, // ev_uint
do_op_invalid, // ev_short
do_op_invalid, // ev_double
0, // ev_long
@ -1081,8 +1081,8 @@ static operation_t op_string[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_invalid, // ev_quaternion
do_op_invalid, // ev_integer
do_op_invalid, // ev_uinteger
do_op_invalid, // ev_int
do_op_invalid, // ev_uint
do_op_invalid, // ev_short
do_op_invalid, // ev_double
0, // ev_long
@ -1100,8 +1100,8 @@ static operation_t op_float[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_quaternion, // ev_quaternion
do_op_float, // ev_integer
do_op_float, // ev_uinteger
do_op_float, // ev_int
do_op_float, // ev_uint
do_op_float, // ev_short
do_op_double, // ev_double
0, // ev_long
@ -1119,8 +1119,8 @@ static operation_t op_vector[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_invalid, // ev_quaternion
do_op_vector, // ev_integer
do_op_vector, // ev_uinteger
do_op_vector, // ev_int
do_op_vector, // ev_uint
do_op_vector, // ev_short
do_op_vector, // ev_double
0, // ev_long
@ -1138,8 +1138,8 @@ static operation_t op_entity[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_invalid, // ev_quaternion
do_op_invalid, // ev_integer
do_op_invalid, // ev_uinteger
do_op_invalid, // ev_int
do_op_invalid, // ev_uint
do_op_invalid, // ev_short
do_op_invalid, // ev_double
0, // ev_long
@ -1157,8 +1157,8 @@ static operation_t op_field[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_invalid, // ev_quaternion
do_op_invalid, // ev_integer
do_op_invalid, // ev_uinteger
do_op_invalid, // ev_int
do_op_invalid, // ev_uint
do_op_invalid, // ev_short
do_op_invalid, // ev_double
0, // ev_long
@ -1176,8 +1176,8 @@ static operation_t op_func[ev_type_count] = {
do_op_func, // ev_func
do_op_func, // ev_pointer
do_op_func, // ev_quaternion
do_op_func, // ev_integer
do_op_func, // ev_uinteger
do_op_func, // ev_int
do_op_func, // ev_uint
do_op_func, // ev_short
do_op_func, // ev_double
0, // ev_long
@ -1195,8 +1195,8 @@ static operation_t op_pointer[ev_type_count] = {
do_op_pointer, // ev_func
do_op_pointer, // ev_pointer
do_op_pointer, // ev_quaternion
do_op_pointer, // ev_integer
do_op_pointer, // ev_uinteger
do_op_pointer, // ev_int
do_op_pointer, // ev_uint
do_op_pointer, // ev_short
do_op_pointer, // ev_double
0, // ev_long
@ -1214,8 +1214,8 @@ static operation_t op_quaternion[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_quaternion, // ev_quaternion
do_op_quaternion, // ev_integer
do_op_quaternion, // ev_uinteger
do_op_quaternion, // ev_int
do_op_quaternion, // ev_uint
do_op_quaternion, // ev_short
do_op_quaternion, // ev_double
0, // ev_long
@ -1223,7 +1223,7 @@ static operation_t op_quaternion[ev_type_count] = {
do_op_invalid, // ev_invalid
};
static operation_t op_integer[ev_type_count] = {
static operation_t op_int[ev_type_count] = {
do_op_invalid, // ev_void
do_op_invalid, // ev_string
do_op_float, // ev_float
@ -1233,16 +1233,16 @@ static operation_t op_integer[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_quaternion, // ev_quaternion
do_op_integer, // ev_integer
do_op_uinteger, // ev_uinteger
do_op_integer, // ev_short
do_op_int, // ev_int
do_op_uint, // ev_uint
do_op_int, // ev_short
do_op_double, // ev_double
0, // ev_long
0, // ev_ulong
do_op_invalid, // ev_invalid
};
static operation_t op_uinteger[ev_type_count] = {
static operation_t op_uint[ev_type_count] = {
do_op_invalid, // ev_void
do_op_invalid, // ev_string
do_op_float, // ev_float
@ -1252,9 +1252,9 @@ static operation_t op_uinteger[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_quaternion, // ev_quaternion
do_op_uinteger, // ev_integer
do_op_uinteger, // ev_uinteger
do_op_uinteger, // ev_short
do_op_uint, // ev_int
do_op_uint, // ev_uint
do_op_uint, // ev_short
do_op_double, // ev_double
0, // ev_long
0, // ev_ulong
@ -1271,8 +1271,8 @@ static operation_t op_short[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_quaternion, // ev_quaternion
do_op_integer, // ev_integer
do_op_uinteger, // ev_uinteger
do_op_int, // ev_int
do_op_uint, // ev_uint
do_op_short, // ev_short
do_op_double, // ev_double
0, // ev_long
@ -1290,8 +1290,8 @@ static operation_t op_double[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_quaternion, // ev_quaternion
do_op_integer, // ev_integer
do_op_uinteger, // ev_uinteger
do_op_int, // ev_int
do_op_uint, // ev_uint
do_op_short, // ev_short
do_op_double, // ev_double
0, // ev_long
@ -1309,8 +1309,8 @@ static operation_t op_compound[ev_type_count] = {
do_op_invalid, // ev_func
do_op_invalid, // ev_pointer
do_op_invalid, // ev_quaternion
do_op_compound, // ev_integer
do_op_compound, // ev_uinteger
do_op_compound, // ev_int
do_op_compound, // ev_uint
do_op_compound, // ev_short
do_op_compound, // ev_double
do_op_compound, // ev_long
@ -1328,8 +1328,8 @@ static operation_t *do_op[ev_type_count] = {
op_func, // ev_func
op_pointer, // ev_pointer
op_quaternion, // ev_quaternion
op_integer, // ev_integer
op_uinteger, // ev_uinteger
op_int, // ev_int
op_uint, // ev_uint
op_short, // ev_short
op_double, // ev_double
0, // ev_long
@ -1390,7 +1390,7 @@ uop_float (int op, expr_t *e, expr_t *e1)
if (op == '+')
return e1;
type = get_type (e);
if (op == 'C' && !is_integer(type) && !is_double(type))
if (op == 'C' && !is_int(type) && !is_double(type))
return error (e1, "invalid cast of float");
if (!is_constant (e1))
return e;
@ -1403,8 +1403,8 @@ uop_float (int op, expr_t *e, expr_t *e1)
case '~':
return new_float_expr (~(int) expr_float (e1));
case 'C':
if (is_integer(type)) {
return new_integer_expr (expr_float (e1));
if (is_int(type)) {
return new_int_expr (expr_float (e1));
} else {
return new_double_expr (expr_float (e1));
}
@ -1533,7 +1533,7 @@ uop_quaternion (int op, expr_t *e, expr_t *e1)
}
static expr_t *
uop_integer (int op, expr_t *e, expr_t *e1)
uop_int (int op, expr_t *e, expr_t *e1)
{
static int valid[] = { '+', '-', '!', '~', 'C', 0 };
@ -1548,19 +1548,19 @@ uop_integer (int op, expr_t *e, expr_t *e1)
return e;
switch (op) {
case '-':
return new_integer_expr (-expr_integer (e1));
return new_int_expr (-expr_int (e1));
case '!':
return cmp_result_expr (!expr_integer (e1));
return cmp_result_expr (!expr_int (e1));
case '~':
return new_integer_expr (~expr_integer (e1));
return new_int_expr (~expr_int (e1));
case 'C':
return new_float_expr (expr_integer (e1));
return new_float_expr (expr_int (e1));
}
internal_error (e, "integer unary op blew up");
internal_error (e, "int unary op blew up");
}
static expr_t *
uop_uinteger (int op, expr_t *e, expr_t *e1)
uop_uint (int op, expr_t *e, expr_t *e1)
{
static int valid[] = { '+', '-', '!', '~', 0 };
@ -1573,13 +1573,13 @@ uop_uinteger (int op, expr_t *e, expr_t *e1)
return e;
switch (op) {
case '-':
return new_uinteger_expr (-expr_uinteger (e1));
return new_uint_expr (-expr_uint (e1));
case '!':
return cmp_result_expr (!expr_uinteger (e1));
return cmp_result_expr (!expr_uint (e1));
case '~':
return new_uinteger_expr (~expr_uinteger (e1));
return new_uint_expr (~expr_uint (e1));
}
internal_error (e, "uinteger unary op blew up");
internal_error (e, "uint unary op blew up");
}
static expr_t *
@ -1617,7 +1617,7 @@ uop_double (int op, expr_t *e, expr_t *e1)
if (op == '+')
return e1;
type = get_type (e);
if (op == 'C' && !is_integer(type) && !is_float(type))
if (op == 'C' && !is_int(type) && !is_float(type))
return error (e1, "invalid cast of double");
if (!is_constant (e1))
return e;
@ -1628,8 +1628,8 @@ uop_double (int op, expr_t *e, expr_t *e1)
print_type (get_type (e));
return cmp_result_expr (!expr_double (e1));
case 'C':
if (is_integer(type)) {
return new_integer_expr (expr_double (e1));
if (is_int(type)) {
return new_int_expr (expr_double (e1));
} else {
return new_float_expr (expr_double (e1));
}
@ -1644,7 +1644,7 @@ uop_compound (int op, expr_t *e, expr_t *e1)
if (is_scalar (t1)) {
if (is_enum (t1)) {
return uop_integer (op, e, e1);
return uop_int (op, e, e1);
}
}
return error (e1, "invalid operand for unary %s", get_op_string (op));
@ -1660,8 +1660,8 @@ static unaryop_t do_unary_op[ev_type_count] = {
uop_func, // ev_func
uop_pointer, // ev_pointer
uop_quaternion, // ev_quaternion
uop_integer, // ev_integer
uop_uinteger, // ev_uinteger
uop_int, // ev_int
uop_uint, // ev_uint
uop_short, // ev_short
uop_double, // ev_double
uop_compound, // ev_invalid

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

@ -164,7 +164,7 @@ emit_basedir (def_t *def, void *data, int index)
static void
emit_num_files (def_t *def, void *data, int index)
{
if (!is_integer (def->type)) {
if (!is_int (def->type)) {
internal_error (0, "%s: expected int def", __FUNCTION__);
}
D_INT (def) = pr.comp_files.size;
@ -189,7 +189,7 @@ emit_compunit (const char *modname)
static struct_def_t compunit_struct[] = {
{"unit_name", &type_string, emit_unit_name},
{"basedir", &type_string, emit_basedir},
{"num_files", &type_integer, emit_num_files},
{"num_files", &type_int, emit_num_files},
{"files", 0, emit_files_item},
{0, 0}
};

5
tools/qfcc/source/def.c
View File

@ -378,8 +378,7 @@ init_elements (struct def_s *def, expr_t *eles)
reloc_def_op (c->e.labelref.label, &dummy);
continue;
} else if (c->type == ex_value) {
if (c->e.value->lltype == ev_integer
&& is_float (element->type)) {
if (c->e.value->lltype == ev_int && is_float (element->type)) {
convert_int (c);
}
if (is_double (get_type (c)) && is_float (element->type)
@ -610,7 +609,7 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space,
}
while (init->type == ex_alias) {
if (init->e.alias.offset) {
offset += expr_integer (init->e.alias.offset);
offset += expr_int (init->e.alias.offset);
}
init = init->e.alias.expr;
}

12
tools/qfcc/source/dot_expr.c
View File

@ -573,16 +573,16 @@ print_value (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
break;
case ev_entity:
label = va (0, "ent %d", e->e.value->v.integer_val);
label = va (0, "ent %d", e->e.value->v.int_val);
break;
case ev_func:
label = va (0, "func %d", e->e.value->v.integer_val);
label = va (0, "func %d", e->e.value->v.int_val);
break;
case ev_integer:
label = va (0, "i %d", e->e.value->v.integer_val);
case ev_int:
label = va (0, "i %d", e->e.value->v.int_val);
break;
case ev_uinteger:
label = va (0, "u %u", e->e.value->v.uinteger_val);
case ev_uint:
label = va (0, "u %u", e->e.value->v.uint_val);
break;
case ev_long:
label = va (0, "i %"PRIi64, e->e.value->v.long_val);

2
tools/qfcc/source/dot_type.c
View File

@ -169,7 +169,7 @@ print_struct (dstring_t *dstr, type_t *t, int level, int id)
int val;
const char *port = "";
if (sym->sy_type == sy_const) {
val = sym->s.value->v.integer_val;
val = sym->s.value->v.int_val;
} else {
if (sym->sy_type != sy_var) {
continue;

4
tools/qfcc/source/dump_globals.c
View File

@ -141,7 +141,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent)
G_QUAT (pr, offset)[2],
G_QUAT (pr, offset)[3]);
break;
case ev_integer:
case ev_int:
comment = va (0, " %d", G_INT (pr, offset));
break;
case ev_short:
@ -327,7 +327,7 @@ qfo_globals (qfo_t *qfo)
QFO_TYPESTR (qfo, def->type));
if (!(def->flags & QFOD_EXTERNAL) && qfo->spaces[space].data)
printf (" %d",
qfo->spaces[space].data[def->offset].integer_var);
qfo->spaces[space].data[def->offset].int_var);
puts ("");
}
}

150
tools/qfcc/source/expr.c
View File

@ -91,7 +91,7 @@ convert_name (expr_t *e)
}
if (!strcmp (sym->name, "__LINE__")
&& current_func) {
new = new_integer_expr (e->line);
new = new_int_expr (e->line);
goto convert;
}
if (!strcmp (sym->name, "__INFINITY__")
@ -230,7 +230,7 @@ get_type (expr_t *e)
case ex_bool:
if (options.code.progsversion == PROG_ID_VERSION)
return &type_float;
return &type_integer;
return &type_int;
case ex_nil:
if (e->e.nil) {
return e->e.nil;
@ -888,20 +888,20 @@ new_quaternion_expr (const float *quaternion_val)
}
expr_t *
new_integer_expr (int integer_val)
new_int_expr (int int_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_integer_val (integer_val);
e->e.value = new_int_val (int_val);
return e;
}
expr_t *
new_uinteger_expr (unsigned uinteger_val)
new_uint_expr (unsigned uint_val)
{
expr_t *e = new_expr ();
e->type = ex_value;
e->e.value = new_uinteger_val (uinteger_val);
e->e.value = new_uint_val (uint_val);
return e;
}
@ -1104,12 +1104,12 @@ expr_quaternion (expr_t *e)
}
int
is_integer_val (expr_t *e)
is_int_val (expr_t *e)
{
if (e->type == ex_nil) {
return 1;
}
if (e->type == ex_value && e->e.value->lltype == ev_integer) {
if (e->type == ex_value && e->e.value->lltype == ev_int) {
return 1;
}
if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const
@ -1124,18 +1124,18 @@ is_integer_val (expr_t *e)
}
int
expr_integer (expr_t *e)
expr_int (expr_t *e)
{
if (e->type == ex_nil) {
return 0;
}
if (e->type == ex_value && e->e.value->lltype == ev_integer) {
return e->e.value->v.integer_val;
if (e->type == ex_value && e->e.value->lltype == ev_int) {
return e->e.value->v.int_val;
}
if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const
&& (e->e.symbol->type->type == ev_integer
&& (e->e.symbol->type->type == ev_int
|| is_enum (e->e.symbol->type))) {
return e->e.symbol->s.value->v.integer_val;
return e->e.symbol->s.value->v.int_val;
}
if (e->type == ex_symbol && e->e.symbol->sy_type == sy_var
&& e->e.symbol->s.def->constant
@ -1146,16 +1146,16 @@ expr_integer (expr_t *e)
&& is_integral (e->e.def->type)) {
return D_INT (e->e.def);
}
internal_error (e, "not an integer constant");
internal_error (e, "not an int constant");
}
int
is_uinteger_val (expr_t *e)
is_uint_val (expr_t *e)
{
if (e->type == ex_nil) {
return 1;
}
if (e->type == ex_value && e->e.value->lltype == ev_uinteger) {
if (e->type == ex_value && e->e.value->lltype == ev_uint) {
return 1;
}
if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const
@ -1170,17 +1170,17 @@ is_uinteger_val (expr_t *e)
}
unsigned
expr_uinteger (expr_t *e)
expr_uint (expr_t *e)
{
if (e->type == ex_nil) {
return 0;
}
if (e->type == ex_value && e->e.value->lltype == ev_uinteger) {
return e->e.value->v.uinteger_val;
if (e->type == ex_value && e->e.value->lltype == ev_uint) {
return e->e.value->v.uint_val;
}
if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const
&& e->e.symbol->type->type == ev_uinteger) {
return e->e.symbol->s.value->v.uinteger_val;
&& e->e.symbol->type->type == ev_uint) {
return e->e.symbol->s.value->v.uint_val;
}
if (e->type == ex_symbol && e->e.symbol->sy_type == sy_var
&& e->e.symbol->s.def->constant
@ -1230,10 +1230,10 @@ int
is_integral_val (expr_t *e)
{
if (is_constant (e)) {
if (is_integer_val (e)) {
if (is_int_val (e)) {
return 1;
}
if (is_uinteger_val (e)) {
if (is_uint_val (e)) {
return 1;
}
if (is_short_val (e)) {
@ -1247,11 +1247,11 @@ int
expr_integral (expr_t *e)
{
if (is_constant (e)) {
if (is_integer_val (e)) {
return expr_integer (e);
if (is_int_val (e)) {
return expr_int (e);
}
if (is_uinteger_val (e)) {
return expr_uinteger (e);
if (is_uint_val (e)) {
return expr_uint (e);
}
if (is_short_val (e)) {
return expr_short (e);
@ -1293,7 +1293,7 @@ new_offset_alias_expr (type_t *type, expr_t *expr, int offset)
if (!is_constant (ofs_expr)) {
internal_error (ofs_expr, "non-constant offset for alias expr");
}
offset += expr_integer (ofs_expr);
offset += expr_int (ofs_expr);
if (expr->e.alias.expr->type == ex_alias) {
internal_error (expr, "alias expr of alias expr");
@ -1305,7 +1305,7 @@ new_offset_alias_expr (type_t *type, expr_t *expr, int offset)
alias->type = ex_alias;
alias->e.alias.type = type;
alias->e.alias.expr = expr;
alias->e.alias.offset = new_integer_expr (offset);
alias->e.alias.offset = new_int_expr (offset);
alias->file = expr->file;
alias->line = expr->line;
return alias;
@ -1517,14 +1517,14 @@ convert_from_bool (expr_t *e, type_t *type)
if (is_float (type)) {
one = new_float_expr (1);
zero = new_float_expr (0);
} else if (is_integer (type)) {
one = new_integer_expr (1);
zero = new_integer_expr (0);
} else if (is_int (type)) {
one = new_int_expr (1);
zero = new_int_expr (0);
} else if (is_enum (type) && enum_as_bool (type, &zero, &one)) {
// don't need to do anything
} else if (is_uinteger (type)) {
one = new_uinteger_expr (1);
zero = new_uinteger_expr (0);
} else if (is_uint (type)) {
one = new_uint_expr (1);
zero = new_uint_expr (0);
} else {
return error (e, "can't convert from bool value");
}
@ -1541,7 +1541,7 @@ convert_from_bool (expr_t *e, type_t *type)
void
convert_int (expr_t *e)
{
float float_val = expr_integer (e);
float float_val = expr_int (e);
e->type = ex_value;
e->e.value = new_float_val (float_val);
}
@ -1557,9 +1557,9 @@ convert_short (expr_t *e)
void
convert_short_int (expr_t *e)
{
float integer_val = expr_short (e);
float int_val = expr_short (e);
e->type = ex_value;
e->e.value = new_integer_val (integer_val);
e->e.value = new_int_val (int_val);
}
void
@ -1712,10 +1712,10 @@ unary_expr (int op, expr_t *e)
case ev_long:
case ev_ulong:
internal_error (e, "long not implemented");
case ev_integer:
return new_integer_expr (-expr_integer (e));
case ev_uinteger:
return new_uinteger_expr (-expr_uinteger (e));
case ev_int:
return new_int_expr (-expr_int (e));
case ev_uint:
return new_uint_expr (-expr_uint (e));
case ev_short:
return new_short_expr (-expr_short (e));
case ev_invalid:
@ -1801,22 +1801,22 @@ unary_expr (int op, expr_t *e)
internal_error (e, 0);
case ev_string:
s = expr_string (e);
return new_integer_expr (!s || !s[0]);
return new_int_expr (!s || !s[0]);
case ev_double:
return new_integer_expr (!expr_double (e));
return new_int_expr (!expr_double (e));
case ev_float:
return new_integer_expr (!expr_float (e));
return new_int_expr (!expr_float (e));
case ev_vector:
return new_integer_expr (!VectorIsZero (expr_vector (e)));
return new_int_expr (!VectorIsZero (expr_vector (e)));
case ev_quat:
return new_integer_expr (!QuatIsZero (expr_quaternion (e)));
return new_int_expr (!QuatIsZero (expr_quaternion (e)));
case ev_long:
case ev_ulong:
internal_error (e, "long not implemented");
case ev_integer:
return new_integer_expr (!expr_integer (e));
case ev_uinteger:
return new_uinteger_expr (!expr_uinteger (e));
case ev_int:
return new_int_expr (!expr_int (e));
case ev_uint:
return new_uint_expr (!expr_uint (e));
case ev_short:
return new_short_expr (!expr_short (e));
case ev_invalid:
@ -1856,7 +1856,7 @@ unary_expr (int op, expr_t *e)
expr_t *n = new_unary_expr (op, e);
if (options.code.progsversion > PROG_ID_VERSION)
n->e.expr.type = &type_integer;
n->e.expr.type = &type_int;
else
n->e.expr.type = &type_float;
return n;
@ -1887,16 +1887,16 @@ unary_expr (int op, expr_t *e)
case ev_long:
case ev_ulong:
internal_error (e, "long not implemented");
case ev_integer:
return new_integer_expr (~expr_integer (e));
case ev_uinteger:
return new_uinteger_expr (~expr_uinteger (e));
case ev_int:
return new_int_expr (~expr_int (e));
case ev_uint:
return new_uint_expr (~expr_uint (e));
case ev_short:
return new_short_expr (~expr_short (e));
case ev_invalid:
t = get_type (e);
if (t->meta == ty_enum) {
return new_integer_expr (~expr_integer (e));
return new_int_expr (~expr_int (e));
}
break;
case ev_type_count:
@ -1936,13 +1936,13 @@ unary_expr (int op, expr_t *e)
case ex_assign:
bitnot_expr:
if (options.code.progsversion == PROG_ID_VERSION) {
expr_t *n1 = new_integer_expr (-1);
expr_t *n1 = new_int_expr (-1);
return binary_expr ('-', n1, e);
} else {
expr_t *n = new_unary_expr (op, e);
type_t *t = get_type (e);
if (!is_integer(t) && !is_float(t)
if (!is_int(t) && !is_float(t)
&& !is_quaternion(t))
return error (e, "invalid type for unary ~");
n->e.expr.type = t;
@ -2052,7 +2052,7 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params)
convert_nil (e, t = type_nil);
if (e->type == ex_bool)
convert_from_bool (e, get_type (e));
if (is_integer_val (e)
if (is_int_val (e)
&& options.code.progsversion == PROG_ID_VERSION)
convert_int (e);
if (options.code.promote_float) {
@ -2070,8 +2070,8 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params)
}
}
}
if (is_integer_val (e) && options.warnings.vararg_integer)
warning (e, "passing integer constant into ... function");
if (is_int_val (e) && options.warnings.vararg_integer)
warning (e, "passing int constant into ... function");
}
arg_types[arg_count - 1 - i] = t;
}
@ -2265,7 +2265,7 @@ return_expr (function_t *f, expr_t *e)
if (e->type == ex_bool) {
e = convert_from_bool (e, (type_t *) ret_type); //FIXME cast
}
if (is_float(ret_type) && is_integer_val (e)) {
if (is_float(ret_type) && is_int_val (e)) {
convert_int (e);
t = &type_float;
}
@ -2352,7 +2352,7 @@ incop_expr (int op, expr_t *e, int postop)
if (e->type == ex_error)
return e;
one = new_integer_expr (1); // integer constants get auto-cast to float
one = new_int_expr (1); // int constants get auto-cast to float
if (postop) {
expr_t *t1, *t2;
type_t *type = get_type (e);
@ -2398,22 +2398,22 @@ array_expr (expr_t *array, expr_t *index)
return error (index, "invalid array index type");
if (is_short_val (index))
ind = expr_short (index);
if (is_integer_val (index))
ind = expr_integer (index);
if (is_int_val (index))
ind = expr_int (index);
if (array_type->t.func.num_params
&& is_constant (index)
&& (ind < array_type->t.array.base
|| ind - array_type->t.array.base >= array_type->t.array.size))
return error (index, "array index out of bounds");
scale = new_integer_expr (type_size (array_type->t.array.type));
scale = new_int_expr (type_size (array_type->t.array.type));
index = binary_expr ('*', index, scale);
base = new_integer_expr (array_type->t.array.base);
base = new_int_expr (array_type->t.array.base);
offset = binary_expr ('*', base, scale);
index = binary_expr ('-', index, offset);
if (is_short_val (index))
ind = expr_short (index);
if (is_integer_val (index))
ind = expr_integer (index);
if (is_int_val (index))
ind = expr_int (index);
if ((is_constant (index) && ind < 32768 && ind >= -32768))
index = new_short_expr (ind);
if (is_array (array_type)) {
@ -2438,7 +2438,7 @@ pointer_expr (expr_t *pointer)
return pointer;
if (pointer_type->type != ev_pointer)
return error (pointer, "not a pointer");
return array_expr (pointer, new_integer_expr (0));
return array_expr (pointer, new_int_expr (0));
}
expr_t *
@ -2754,7 +2754,7 @@ build_state_expr (expr_t *e)
step = think->next;
if (think->type == ex_symbol)
think = think_expr (think->e.symbol);
if (is_integer_val (frame))
if (is_int_val (frame))
convert_int (frame);
if (!type_assignable (&type_float, get_type (frame)))
return error (frame, "invalid type for frame number");
@ -2763,7 +2763,7 @@ build_state_expr (expr_t *e)
if (step) {
if (step->next)
return error (step->next, "too many state arguments");
if (is_integer_val (step))
if (is_int_val (step))
convert_int (step);
if (!type_assignable (&type_float, get_type (step)))
return error (step, "invalid type for step");
@ -2843,7 +2843,7 @@ cast_expr (type_t *dstType, expr_t *e)
} else if (is_double (def->type)) {
val = new_double_val (D_DOUBLE (def));
} else if (is_integral (def->type)) {
val = new_integer_val (D_INT (def));
val = new_int_val (D_INT (def));
}
} else if (e->type == ex_value) {
val = e->e.value;
@ -2889,7 +2889,7 @@ sizeof_expr (expr_t *expr, struct type_s *type)
internal_error (0, 0);
if (!type)
type = get_type (expr);
expr = new_integer_expr (type_size (type));
expr = new_int_expr (type_size (type));
return expr;
}

524
tools/qfcc/source/expr_binary.c
View File

@ -53,12 +53,12 @@ static expr_t *double_compare (int op, expr_t *e1, expr_t *e2);
static expr_type_t string_string[] = {
{'+', &type_string},
{EQ, &type_integer},
{NE, &type_integer},
{LE, &type_integer},
{GE, &type_integer},
{LT, &type_integer},
{GT, &type_integer},
{EQ, &type_int},
{NE, &type_int},
{LE, &type_int},
{GE, &type_int},
{LT, &type_int},
{GT, &type_int},
{0, 0}
};
@ -74,14 +74,14 @@ static expr_type_t float_float[] = {
{MOD, &type_float},
{SHL, &type_float},
{SHR, &type_float},
{AND, &type_integer},
{OR, &type_integer},
{EQ, &type_integer},
{NE, &type_integer},
{LE, &type_integer},
{GE, &type_integer},
{LT, &type_integer},
{GT, &type_integer},
{AND, &type_int},
{OR, &type_int},
{EQ, &type_int},
{NE, &type_int},
{LE, &type_int},
{GE, &type_int},
{LT, &type_int},
{GT, &type_int},
{0, 0}
};
@ -95,7 +95,7 @@ static expr_type_t float_quat[] = {
{0, 0}
};
static expr_type_t float_integer[] = {
static expr_type_t float_int[] = {
{'+', &type_float, 0, &type_float},
{'-', &type_float, 0, &type_float},
{'*', &type_float, 0, &type_float},
@ -107,16 +107,16 @@ static expr_type_t float_integer[] = {
{MOD, &type_float, 0, &type_float},
{SHL, &type_float, 0, &type_float},
{SHR, &type_float, 0, &type_float},
{EQ, &type_integer, 0, &type_float},
{NE, &type_integer, 0, &type_float},
{LE, &type_integer, 0, &type_float},
{GE, &type_integer, 0, &type_float},
{LT, &type_integer, 0, &type_float},
{GT, &type_integer, 0, &type_float},
{EQ, &type_int, 0, &type_float},
{NE, &type_int, 0, &type_float},
{LE, &type_int, 0, &type_float},
{GE, &type_int, 0, &type_float},
{LT, &type_int, 0, &type_float},
{GT, &type_int, 0, &type_float},
{0, 0}
};
#define float_uinteger float_integer
#define float_short float_integer
#define float_uint float_int
#define float_short float_int
static expr_type_t float_double[] = {
{'+', &type_double, &type_double, 0},
@ -144,13 +144,13 @@ static expr_type_t vector_vector[] = {
{'+', &type_vector},
{'-', &type_vector},
{'*', &type_float},
{EQ, &type_integer},
{NE, &type_integer},
{EQ, &type_int},
{NE, &type_int},
{0, 0}
};
#define vector_integer vector_float
#define vector_uinteger vector_float
#define vector_int vector_float
#define vector_uint vector_float
#define vector_short vector_float
static expr_type_t vector_double[] = {
@ -160,20 +160,20 @@ static expr_type_t vector_double[] = {
};
static expr_type_t entity_entity[] = {
{EQ, &type_integer},
{NE, &type_integer},
{EQ, &type_int},
{NE, &type_int},
{0, 0}
};
static expr_type_t field_field[] = {
{EQ, &type_integer},
{NE, &type_integer},
{EQ, &type_int},
{NE, &type_int},
{0, 0}
};
static expr_type_t func_func[] = {
{EQ, &type_integer},
{NE, &type_integer},
{EQ, &type_int},
{NE, &type_int},
{0, 0}
};
@ -188,13 +188,13 @@ static expr_type_t pointer_pointer[] = {
{0, 0}
};
static expr_type_t pointer_integer[] = {
static expr_type_t pointer_int[] = {
{'+', 0, 0, 0, pointer_arithmetic},
{'-', 0, 0, 0, pointer_arithmetic},
{0, 0}
};
#define pointer_uinteger pointer_integer
#define pointer_short pointer_integer
#define pointer_uint pointer_int
#define pointer_short pointer_int
static expr_type_t quat_float[] = {
{'*', &type_quaternion},
@ -211,18 +211,18 @@ static expr_type_t quat_quat[] = {
{'+', &type_quaternion},
{'-', &type_quaternion},
{'*', &type_quaternion},
{EQ, &type_integer},
{NE, &type_integer},
{EQ, &type_int},
{NE, &type_int},
{0, 0}
};
static expr_type_t quat_integer[] = {
static expr_type_t quat_int[] = {
{'*', &type_quaternion, 0, &type_float},
{'/', 0, 0, 0, inverse_multiply},
{0, 0}
};
#define quat_uinteger quat_integer
#define quat_short quat_integer
#define quat_uint quat_int
#define quat_short quat_int
static expr_type_t quat_double[] = {
{'*', &type_quaternion},
@ -230,7 +230,7 @@ static expr_type_t quat_double[] = {
{0, 0}
};
static expr_type_t integer_float[] = {
static expr_type_t int_float[] = {
{'+', &type_float, &type_float, 0},
{'-', &type_float, &type_float, 0},
{'*', &type_float, &type_float, 0},
@ -240,206 +240,206 @@ static expr_type_t integer_float[] = {
{'^', &type_float, &type_float, 0},
{'%', &type_float, &type_float, 0},
{MOD, &type_float, &type_float, 0},
{SHL, &type_integer, 0, &type_integer}, //FIXME?
{SHR, &type_integer, 0, &type_integer}, //FIXME?
{EQ, &type_integer, &type_float, 0},
{NE, &type_integer, &type_float, 0},
{LE, &type_integer, &type_float, 0},
{GE, &type_integer, &type_float, 0},
{LT, &type_integer, &type_float, 0},
{GT, &type_integer, &type_float, 0},
{SHL, &type_int, 0, &type_int}, //FIXME?
{SHR, &type_int, 0, &type_int}, //FIXME?
{EQ, &type_int, &type_float, 0},
{NE, &type_int, &type_float, 0},
{LE, &type_int, &type_float, 0},
{GE, &type_int, &type_float, 0},
{LT, &type_int, &type_float, 0},
{GT, &type_int, &type_float, 0},
{0, 0}
};
static expr_type_t integer_vector[] = {
static expr_type_t int_vector[] = {
{'*', &type_vector, &type_float, 0},
{0, 0}
};
static expr_type_t integer_pointer[] = {
static expr_type_t int_pointer[] = {
{'+', 0, 0, 0, pointer_arithmetic},
{0, 0}
};
static expr_type_t integer_quat[] = {
static expr_type_t int_quat[] = {
{'*', &type_quaternion, &type_float, 0},
{0, 0}
};
static expr_type_t integer_integer[] = {
{'+', &type_integer},
{'-', &type_integer},
{'*', &type_integer},
{'/', &type_integer},
{'&', &type_integer},
{'|', &type_integer},
{'^', &type_integer},
{'%', &type_integer},
{MOD, &type_integer},
{SHL, &type_integer},
{SHR, &type_integer},
{AND, &type_integer},
{OR, &type_integer},
{EQ, &type_integer},
{NE, &type_integer},
{LE, &type_integer},
{GE, &type_integer},
{LT, &type_integer},
{GT, &type_integer},
static expr_type_t int_int[] = {
{'+', &type_int},
{'-', &type_int},
{'*', &type_int},
{'/', &type_int},
{'&', &type_int},
{'|', &type_int},
{'^', &type_int},
{'%', &type_int},
{MOD, &type_int},
{SHL, &type_int},
{SHR, &type_int},
{AND, &type_int},
{OR, &type_int},
{EQ, &type_int},
{NE, &type_int},
{LE, &type_int},
{GE, &type_int},
{LT, &type_int},
{GT, &type_int},
{0, 0}
};
static expr_type_t integer_uinteger[] = {
{'+', &type_integer},
{'-', &type_integer},
{'*', &type_integer},
{'/', &type_integer},
{'&', &type_integer},
{'|', &type_integer},
{'^', &type_integer},
{'%', &type_integer},
{MOD, &type_integer},
{SHL, &type_integer},
{SHR, &type_integer},
{EQ, &type_integer},
{NE, &type_integer},
{LE, &type_integer},
{GE, &type_integer},
{LT, &type_integer},
{GT, &type_integer},
static expr_type_t int_uint[] = {
{'+', &type_int},
{'-', &type_int},
{'*', &type_int},
{'/', &type_int},
{'&', &type_int},
{'|', &type_int},
{'^', &type_int},
{'%', &type_int},
{MOD, &type_int},
{SHL, &type_int},
{SHR, &type_int},
{EQ, &type_int},
{NE, &type_int},
{LE, &type_int},
{GE, &type_int},
{LT, &type_int},
{GT, &type_int},
{0, 0}
};
static expr_type_t integer_short[] = {
{'+', &type_integer, 0, &type_integer},
{'-', &type_integer, 0, &type_integer},
{'*', &type_integer, 0, &type_integer},
{'/', &type_integer, 0, &type_integer},
{'&', &type_integer, 0, &type_integer},
{'|', &type_integer, 0, &type_integer},
{'^', &type_integer, 0, &type_integer},
{'%', &type_integer, 0, &type_integer},
{MOD, &type_integer, 0, &type_integer},
{SHL, &type_integer, 0, &type_integer},
{SHR, &type_integer, 0, &type_integer},
{EQ, &type_integer, 0, &type_integer},
{NE, &type_integer, 0, &type_integer},
{LE, &type_integer, 0, &type_integer},
{GE, &type_integer, 0, &type_integer},
{LT, &type_integer, 0, &type_integer},
{GT, &type_integer, 0, &type_integer},
static expr_type_t int_short[] = {
{'+', &type_int, 0, &type_int},
{'-', &type_int, 0, &type_int},
{'*', &type_int, 0, &type_int},
{'/', &type_int, 0, &type_int},
{'&', &type_int, 0, &type_int},
{'|', &type_int, 0, &type_int},
{'^', &type_int, 0, &type_int},
{'%', &type_int, 0, &type_int},
{MOD, &type_int, 0, &type_int},
{SHL, &type_int, 0, &type_int},
{SHR, &type_int, 0, &type_int},
{EQ, &type_int, 0, &type_int},
{NE, &type_int, 0, &type_int},
{LE, &type_int, 0, &type_int},
{GE, &type_int, 0, &type_int},
{LT, &type_int, 0, &type_int},
{GT, &type_int, 0, &type_int},
{0, 0}
};
static expr_type_t integer_double[] = {
static expr_type_t int_double[] = {
{'+', &type_double, &type_double, 0},
{'-', &type_double, &type_double, 0},
{'*', &type_double, &type_double, 0},
{'/', &type_double, &type_double, 0},
{'%', &type_double, &type_double, 0},
{MOD, &type_double, &type_double, 0},
{EQ, &type_integer, &type_double, 0},
{NE, &type_integer, &type_double, 0},
{LE, &type_integer, &type_double, 0},
{GE, &type_integer, &type_double, 0},
{LT, &type_integer, &type_double, 0},
{GT, &type_integer, &type_double, 0},
{EQ, &type_int, &type_double, 0},
{NE, &type_int, &type_double, 0},
{LE, &type_int, &type_double, 0},
{GE, &type_int, &type_double, 0},
{LT, &type_int, &type_double, 0},
{GT, &type_int, &type_double, 0},
{0, 0}
};
#define uinteger_float integer_float
#define uinteger_vector integer_vector
#define uinteger_pointer integer_pointer
#define uinteger_quat integer_quat
#define uint_float int_float
#define uint_vector int_vector
#define uint_pointer int_pointer
#define uint_quat int_quat
static expr_type_t uinteger_integer[] = {
{'+', &type_integer},
{'-', &type_integer},
{'*', &type_integer},
{'/', &type_integer},
{'&', &type_integer},
{'|', &type_integer},
{'^', &type_integer},
{'%', &type_integer},
{MOD, &type_integer},
{SHL, &type_uinteger},
{SHR, &type_uinteger},
{EQ, &type_integer},
{NE, &type_integer},
{LE, &type_integer},
{GE, &type_integer},
{LT, &type_integer},
{GT, &type_integer},
static expr_type_t uint_int[] = {
{'+', &type_int},
{'-', &type_int},
{'*', &type_int},
{'/', &type_int},
{'&', &type_int},
{'|', &type_int},
{'^', &type_int},
{'%', &type_int},
{MOD, &type_int},
{SHL, &type_uint},
{SHR, &type_uint},
{EQ, &type_int},
{NE, &type_int},
{LE, &type_int},
{GE, &type_int},
{LT, &type_int},
{GT, &type_int},
{0, 0}
};
static expr_type_t uinteger_uinteger[] = {
{'+', &type_uinteger},
{'-', &type_uinteger},
{'*', &type_uinteger},
{'/', &type_uinteger},
{'&', &type_uinteger},
{'|', &type_uinteger},
{'^', &type_uinteger},
{'%', &type_uinteger},
{MOD, &type_uinteger},
{SHL, &type_uinteger},
{SHR, &type_uinteger},
{EQ, &type_integer},
{NE, &type_integer},
{LE, &type_integer},
{GE, &type_integer},
{LT, &type_integer},
{GT, &type_integer},
static expr_type_t uint_uint[] = {
{'+', &type_uint},
{'-', &type_uint},
{'*', &type_uint},
{'/', &type_uint},
{'&', &type_uint},
{'|', &type_uint},
{'^', &type_uint},
{'%', &type_uint},
{MOD, &type_uint},
{SHL, &type_uint},
{SHR, &type_uint},
{EQ, &type_int},
{NE, &type_int},
{LE, &type_int},
{GE, &type_int},
{LT, &type_int},
{GT, &type_int},
{0, 0}
};
#define uinteger_short uinteger_integer
#define uinteger_double integer_double
#define uint_short uint_int
#define uint_double int_double
#define short_float integer_float
#define short_vector integer_vector
#define short_pointer integer_pointer
#define short_quat integer_quat
#define short_float int_float
#define short_vector int_vector
#define short_pointer int_pointer
#define short_quat int_quat
static expr_type_t short_integer[] = {
{'+', &type_integer, &type_integer, 0},
{'-', &type_integer, &type_integer, 0},
{'*', &type_integer, &type_integer, 0},
{'/', &type_integer, &type_integer, 0},
{'&', &type_integer, &type_integer, 0},
{'|', &type_integer, &type_integer, 0},
{'^', &type_integer, &type_integer, 0},
{'%', &type_integer, &type_integer, 0},
{MOD, &type_integer, &type_integer, 0},
static expr_type_t short_int[] = {
{'+', &type_int, &type_int, 0},
{'-', &type_int, &type_int, 0},
{'*', &type_int, &type_int, 0},
{'/', &type_int, &type_int, 0},
{'&', &type_int, &type_int, 0},
{'|', &type_int, &type_int, 0},
{'^', &type_int, &type_int, 0},
{'%', &type_int, &type_int, 0},
{MOD, &type_int, &type_int, 0},
{SHL, &type_short},
{SHR, &type_short},
{EQ, &type_integer, &type_integer, 0},
{NE, &type_integer, &type_integer, 0},
{LE, &type_integer, &type_integer, 0},
{GE, &type_integer, &type_integer, 0},
{LT, &type_integer, &type_integer, 0},
{GT, &type_integer, &type_integer, 0},
{EQ, &type_int, &type_int, 0},
{NE, &type_int, &type_int, 0},
{LE, &type_int, &type_int, 0},
{GE, &type_int, &type_int, 0},
{LT, &type_int, &type_int, 0},
{GT, &type_int, &type_int, 0},
{0, 0}
};
static expr_type_t short_uinteger[] = {
{'+', &type_uinteger, &type_uinteger, 0},
{'-', &type_uinteger, &type_uinteger, 0},
{'*', &type_uinteger, &type_uinteger, 0},
{'/', &type_uinteger, &type_uinteger, 0},
{'&', &type_uinteger, &type_uinteger, 0},
{'|', &type_uinteger, &type_uinteger, 0},
{'^', &type_uinteger, &type_uinteger, 0},
{'%', &type_uinteger, &type_uinteger, 0},
{MOD, &type_uinteger, &type_uinteger, 0},
static expr_type_t short_uint[] = {
{'+', &type_uint, &type_uint, 0},
{'-', &type_uint, &type_uint, 0},
{'*', &type_uint, &type_uint, 0},
{'/', &type_uint, &type_uint, 0},
{'&', &type_uint, &type_uint, 0},
{'|', &type_uint, &type_uint, 0},
{'^', &type_uint, &type_uint, 0},
{'%', &type_uint, &type_uint, 0},
{MOD, &type_uint, &type_uint, 0},
{SHL, &type_short},
{SHR, &type_short},
{EQ, &type_integer, &type_uinteger, 0},
{NE, &type_integer, &type_uinteger, 0},
{LE, &type_integer, &type_uinteger, 0},
{GE, &type_integer, &type_uinteger, 0},
{LT, &type_integer, &type_uinteger, 0},
{GT, &type_integer, &type_uinteger, 0},
{EQ, &type_int, &type_uint, 0},
{NE, &type_int, &type_uint, 0},
{LE, &type_int, &type_uint, 0},
{GE, &type_int, &type_uint, 0},
{LT, &type_int, &type_uint, 0},
{GT, &type_int, &type_uint, 0},
{0, 0}
};
@ -455,15 +455,15 @@ static expr_type_t short_short[] = {
{MOD, &type_short},
{SHL, &type_short},
{SHR, &type_short},
{EQ, &type_integer},
{NE, &type_integer},
{LE, &type_integer},
{GE, &type_integer},
{LT, &type_integer},
{GT, &type_integer},
{EQ, &type_int},
{NE, &type_int},
{LE, &type_int},
{GE, &type_int},
{LT, &type_int},
{GT, &type_int},
{0, 0}
};
#define short_double integer_double
#define short_double int_double
static expr_type_t double_float[] = {
{'+', &type_double, 0, &type_double},
@ -491,7 +491,7 @@ static expr_type_t double_quat[] = {
{0, 0}
};
static expr_type_t double_integer[] = {
static expr_type_t double_int[] = {
{'+', &type_double, 0, &type_double},
{'-', &type_double, 0, &type_double},
{'*', &type_double, 0, &type_double},
@ -506,8 +506,8 @@ static expr_type_t double_integer[] = {
{GT, 0, 0, 0, double_compare},
{0, 0}
};
#define double_uinteger double_integer
#define double_short double_integer
#define double_uint double_int
#define double_short double_int
static expr_type_t double_double[] = {
{'+', &type_double},
@ -516,12 +516,12 @@ static expr_type_t double_double[] = {
{'/', &type_double},
{'%', &type_double},
{MOD, &type_double},
{EQ, &type_integer},
{NE, &type_integer},
{LE, &type_integer},
{GE, &type_integer},
{LT, &type_integer},
{GT, &type_integer},
{EQ, &type_int},
{NE, &type_int},
{LE, &type_int},
{GE, &type_int},
{LT, &type_int},
{GT, &type_int},
{0, 0}
};
@ -535,8 +535,8 @@ static expr_type_t *string_x[ev_type_count] = {
0, // ev_func
0, // ev_pointer
0, // ev_quat
0, // ev_integer
0, // ev_uinteger
0, // ev_int
0, // ev_uint
0, // ev_short
0, // ev_double
};
@ -551,8 +551,8 @@ static expr_type_t *float_x[ev_type_count] = {
0, // ev_func
0, // ev_pointer
float_quat,
float_integer,
float_uinteger,
float_int,
float_uint,
float_short,
float_double,
};
@ -567,8 +567,8 @@ static expr_type_t *vector_x[ev_type_count] = {
0, // ev_func
0, // ev_pointer
0, // ev_quaternion
vector_integer,
vector_uinteger,
vector_int,
vector_uint,
vector_short,
vector_double,
};
@ -583,8 +583,8 @@ static expr_type_t *entity_x[ev_type_count] = {
0, // ev_func
0, // ev_pointer
0, // ev_quaternion
0, // ev_integer
0, // ev_uinteger
0, // ev_int
0, // ev_uint
0, // ev_short
0, // ev_double
};
@ -599,8 +599,8 @@ static expr_type_t *field_x[ev_type_count] = {
0, // ev_func
0, // ev_pointer
0, // ev_quaternion
0, // ev_integer
0, // ev_uinteger
0, // ev_int
0, // ev_uint
0, // ev_short
0, // ev_double
};
@ -615,8 +615,8 @@ static expr_type_t *func_x[ev_type_count] = {
func_func, // ev_func
0, // ev_pointer
0, // ev_quaternion
0, // ev_integer
0, // ev_uinteger
0, // ev_int
0, // ev_uint
0, // ev_short
0, // ev_double
};
@ -631,8 +631,8 @@ static expr_type_t *pointer_x[ev_type_count] = {
0, // ev_func
pointer_pointer,
0, // ev_quat
pointer_integer,
pointer_uinteger,
pointer_int,
pointer_uint,
pointer_short,
0, // ev_double
};
@ -647,42 +647,42 @@ static expr_type_t *quat_x[ev_type_count] = {
0, // ev_func
0, // ev_pointer
quat_quat,
quat_integer,
quat_uinteger,
quat_int,
quat_uint,
quat_short,
quat_double,
};
static expr_type_t *integer_x[ev_type_count] = {
static expr_type_t *int_x[ev_type_count] = {
0, // ev_void
0, // ev_string
integer_float,
integer_vector,
int_float,
int_vector,
0, // ev_entity
0, // ev_field
0, // ev_func
integer_pointer,
integer_quat,
integer_integer,
integer_uinteger,
integer_short,
integer_double,
int_pointer,
int_quat,
int_int,
int_uint,
int_short,
int_double,
};
static expr_type_t *uinteger_x[ev_type_count] = {
static expr_type_t *uint_x[ev_type_count] = {
0, // ev_void
0, // ev_string
uinteger_float,
uinteger_vector,
uint_float,
uint_vector,
0, // ev_entity
0, // ev_field
0, // ev_func
uinteger_pointer,
uinteger_quat,
uinteger_integer,
uinteger_uinteger,
uinteger_short,
uinteger_double,
uint_pointer,
uint_quat,
uint_int,
uint_uint,
uint_short,
uint_double,
};
static expr_type_t *short_x[ev_type_count] = {
@ -695,8 +695,8 @@ static expr_type_t *short_x[ev_type_count] = {
0, // ev_func
short_pointer,
short_quat,
short_integer,
short_uinteger,
short_int,
short_uint,
short_short,
short_double,
};
@ -711,8 +711,8 @@ static expr_type_t *double_x[ev_type_count] = {
0, // ev_func
0, // ev_pointer
double_quat,
double_integer,
double_uinteger,
double_int,
double_uint,
double_short,
double_double,
};
@ -727,8 +727,8 @@ static expr_type_t **binary_expr_types[ev_type_count] = {
func_x,
pointer_x,
quat_x,
integer_x,
uinteger_x,
int_x,
uint_x,
short_x,
double_x
};
@ -755,20 +755,20 @@ pointer_arithmetic (int op, expr_t *e1, expr_t *e2)
return error (e2, "cannot use %c on pointers of different types",
op);
}
e1 = cast_expr (&type_integer, e1);
e2 = cast_expr (&type_integer, e2);
psize = new_integer_expr (type_size (t1->t.fldptr.type));
e1 = cast_expr (&type_int, e1);
e2 = cast_expr (&type_int, e2);
psize = new_int_expr (type_size (t1->t.fldptr.type));
return binary_expr ('/', binary_expr ('-', e1, e2), psize);
} else if (is_pointer (t1)) {
offset = cast_expr (&type_integer, e2);
ptr = cast_expr (&type_integer, e1);
offset = cast_expr (&type_int, e2);
ptr = cast_expr (&type_int, e1);
ptype = t1;
} else if (is_pointer (t2)) {
offset = cast_expr (&type_integer, e1);
ptr = cast_expr (&type_integer, e2);
offset = cast_expr (&type_int, e1);
ptr = cast_expr (&type_int, e2);
ptype = t2;
}
psize = new_integer_expr (type_size (ptype->t.fldptr.type));
psize = new_int_expr (type_size (ptype->t.fldptr.type));
e = binary_expr (op, ptr, binary_expr ('*', offset, psize));
return cast_expr (ptype, e);
}
@ -785,7 +785,7 @@ pointer_compare (int op, expr_t *e1, expr_t *e2)
get_op_string (op));
}
e = new_binary_expr (op, e1, e2);
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
return e;
}
@ -817,19 +817,19 @@ double_compare (int op, expr_t *e1, expr_t *e2)
if (is_float (t2)) {
warning (e2, "comparison between double and float");
} else if (!is_constant (e2)) {
warning (e2, "comparison between double and integer");
warning (e2, "comparison between double and int");
}
e2 = cast_expr (&type_double, e2);
} else if (is_double (t2)) {
if (is_float (t1)) {
warning (e1, "comparison between float and double");
} else if (!is_constant (e1)) {
warning (e1, "comparison between integer and double");
warning (e1, "comparison between int and double");
}
e1 = cast_expr (&type_double, e1);
}
e = new_binary_expr (op, e1, e2);
e->e.expr.type = &type_integer;
e->e.expr.type = &type_int;
return e;
}

10
tools/qfcc/source/expr_bool.c
View File

@ -97,10 +97,10 @@ test_expr (expr_t *e)
case ev_long:
case ev_ulong:
internal_error (e, "long not implemented");
case ev_uinteger:
case ev_integer:
case ev_uint:
case ev_int:
case ev_short:
if (!is_integer(type_default)) {
if (!is_int(type_default)) {
if (is_constant (e)) {
return cast_expr (type_default, e);
}
@ -285,8 +285,8 @@ convert_bool (expr_t *e, int block)
int val;
b = goto_expr (0);
if (is_integer_val (e)) {
val = expr_integer (e);
if (is_int_val (e)) {
val = expr_int (e);
} else {
val = expr_float (e) != 0;
}

6
tools/qfcc/source/function.c
View File

@ -665,7 +665,7 @@ build_builtin_function (symbol_t *sym, expr_t *bi_val, int far,
error (bi_val, "%s redefined", sym->name);
return 0;
}
if (!is_integer_val (bi_val) && !is_float_val (bi_val)) {
if (!is_int_val (bi_val) && !is_float_val (bi_val)) {
error (bi_val, "invalid constant for = #");
return 0;
}
@ -681,8 +681,8 @@ build_builtin_function (symbol_t *sym, expr_t *bi_val, int far,
sym->s.func->def->nosave = 1;
add_function (sym->s.func);
if (is_integer_val (bi_val))
bi = expr_integer (bi_val);
if (is_int_val (bi_val))
bi = expr_int (bi_val);
else
bi = expr_float (bi_val);
if (bi < 0) {

16
tools/qfcc/source/method.c
View File

@ -543,8 +543,8 @@ emit_methods_count (def_t *def, void *data, int index)
{
methodlist_t *methods = (methodlist_t *) data;
if (!is_integer(def->type))
internal_error (0, "%s: expected integer def", __FUNCTION__);
if (!is_int(def->type))
internal_error (0, "%s: expected int def", __FUNCTION__);
D_INT (def) = methods->count;
}
@ -586,7 +586,7 @@ emit_methods (methodlist_t *methods, const char *name, int instance)
{
static struct_def_t methods_struct[] = {
{"method_next", &type_pointer, emit_methods_next},
{"method_count", &type_integer, emit_methods_count},
{"method_count", &type_int, emit_methods_count},
{"method_list", 0, emit_methods_list_item},
{0, 0}
};
@ -622,8 +622,8 @@ emit_method_list_count (def_t *def, void *data, int index)
{
methodlist_t *methods = (methodlist_t *) data;
if (!is_integer(def->type))
internal_error (0, "%s: expected integer def", __FUNCTION__);
if (!is_int(def->type))
internal_error (0, "%s: expected int def", __FUNCTION__);
D_INT (def) = methods->count;
}
@ -660,7 +660,7 @@ emit_method_descriptions (methodlist_t *methods, const char *name,
int instance)
{
static struct_def_t method_list_struct[] = {
{"count", &type_integer, emit_method_list_count},
{"count", &type_int, emit_method_list_count},
{"method_list", 0, emit_method_list_item},
{0, 0}
};
@ -746,8 +746,8 @@ method_check_params (method_t *method, expr_t *args)
}
}
} else {
if (is_integer_val (e) && options.warnings.vararg_integer) {
warning (e, "passing integer consant into ... function");
if (is_int_val (e) && options.warnings.vararg_integer) {
warning (e, "passing int consant into ... function");
}
}
}

8
tools/qfcc/source/obj_file.c
View File

@ -434,7 +434,7 @@ qfo_byteswap_space (void *space, int size, qfos_type_t type)
case qfos_type:
case qfos_debug:
for (val = (pr_type_t *) space, c = 0; c < size; c++, val++)
val->integer_var = LittleLong (val->integer_var);
val->int_var = LittleLong (val->int_var);
break;
}
}
@ -696,7 +696,7 @@ get_def_type (qfo_t *qfo, pr_ptr_t type)
case ty_enum:
if (options.code.progsversion == PROG_ID_VERSION)
return ev_float;
return ev_integer;
return ev_int;
case ty_array:
case ty_class:
return ev_invalid;
@ -732,7 +732,7 @@ get_type_size (qfo_t *qfo, pr_ptr_t type)
}
return size;
case ty_enum:
return pr_type_size[ev_integer];
return pr_type_size[ev_int];
case ty_array:
return type_def->array.size
* get_type_size (qfo, type_def->array.type);
@ -781,7 +781,7 @@ get_type_alignment_log (qfo_t *qfo, pr_ptr_t type)
}
return alignment;
case ty_enum:
return qfo_log2 (ev_types[ev_integer]->alignment);
return qfo_log2 (ev_types[ev_int]->alignment);
case ty_array:
return get_type_alignment_log (qfo, type_def->array.type);
case ty_class:

2
tools/qfcc/source/obj_type.c
View File

@ -214,7 +214,7 @@ qfo_encode_struct (type_t *type, defspace_t *space)
if (i == num_fields)
internal_error (0, "whoa, what happened?");
if (sym->sy_type == sy_const)
offset = sym->s.value->v.integer_val;
offset = sym->s.value->v.int_val;
else
offset = sym->s.offset;
ENC_DEF (strct->fields[i].type, field_types[i]);

6
tools/qfcc/source/opcodes.c
View File

@ -241,11 +241,11 @@ v6p_opcode_init (void)
// treats the operands of certain operands as integers
// irrespective the progs version, so convert the engine's
// view of the operands to the prog's view.
if (mop->type_a == ev_integer)
if (mop->type_a == ev_int)
mop->type_a = ev_float;
if (mop->type_b == ev_integer)
if (mop->type_b == ev_int)
mop->type_b = ev_float;
if (mop->type_c == ev_integer)
if (mop->type_c == ev_int)
mop->type_c = ev_float;
}
Hash_AddElement (v6p_opcode_type_table, mop);

2
tools/qfcc/source/pragma.c
View File

@ -67,7 +67,7 @@ set_traditional (int traditional)
options.traditional = 0;
options.advanced = true;
options.code.progsversion = PROG_V6P_VERSION;
type_default = &type_integer;
type_default = &type_int;
break;
case 1:
options.traditional = 1;

12
tools/qfcc/source/qc-lex.l
View File

@ -131,9 +131,9 @@ STRING \"(\\.|[^"\\])*\"
else
i = strtol (yytext, 0, 0);
if (*c == 'u' || *c == 'U')
qc_yylval.expr = new_integer_expr (i);//FIXME
qc_yylval.expr = new_int_expr (i);//FIXME
else
qc_yylval.expr = new_integer_expr (i);
qc_yylval.expr = new_int_expr (i);
return VALUE;
}
@ -208,7 +208,7 @@ STRING \"(\\.|[^"\\])*\"
if (str[1])
warning (0, "multibyte char constant");
qc_yylval.expr = new_integer_expr (*str);
qc_yylval.expr = new_int_expr (*str);
return VALUE;
}
@ -269,7 +269,7 @@ STRING \"(\\.|[^"\\])*\"
"$"{s}*{FRAMEID} {
int ret = do_grab (yytext);
if (ret >= 0) {
qc_yylval.expr = new_integer_expr (ret);
qc_yylval.expr = new_int_expr (ret);
return VALUE;
} else {
BEGIN (-ret);
@ -376,8 +376,8 @@ static keyword_t at_keywords[] = {
static keyword_t qf_keywords[] = {
{"quaternion", TYPE, &type_quaternion},
{"double", TYPE, &type_double},
{"int", TYPE, &type_integer },
{"unsigned", TYPE, &type_integer },//FIXME
{"int", TYPE, &type_int },
{"unsigned", TYPE, &type_int },//FIXME
{"@function", TYPE, &type_function },
{"@args", ARGS, 0 },

6
tools/qfcc/source/qc-parse.y
View File

@ -969,11 +969,11 @@ abs_decl
array_decl
: '[' expr ']'
{
if (!is_integer_val ($2) || expr_integer ($2) < 1) {
if (!is_int_val ($2) || expr_int ($2) < 1) {
error (0, "invalid array size");
$$ = 0;
} else {
$$ = expr_integer ($2);
$$ = expr_int ($2);
}
}
| '[' ']' { $$ = 0; }
@ -1104,7 +1104,7 @@ non_code_func
if (sym->s.def)
sym->s.def->nosave |= spec.nosave;
} else {
if (is_integer_val ($2) || is_float_val ($2)) {
if (is_int_val ($2) || is_float_val ($2)) {
error (0, "invalid function initializer."
" did you forget #?");
} else {

8
tools/qfcc/source/qfcc.c
View File

@ -246,7 +246,7 @@ WriteProgs (dprograms_t *progs, int size)
fielddefs[i].name = LittleLong (fielddefs[i].name);
}
for (i = 0; i < progs->numglobals; i++)
globals[i].integer_var = LittleLong (globals[i].integer_var);
globals[i].int_var = LittleLong (globals[i].int_var);
if (!(h = Qopen (options.output_file, "wb")))
Sys_Error ("%s: %s\n", options.output_file, strerror(errno));
@ -307,7 +307,7 @@ WriteSym (pr_debug_header_t *sym, int size)
debug_defs[i].type_encoding = LittleLong (debug_defs[i].type_encoding);
}
for (i = 0; i < sym->debug_data_size; i++) {
debug_data[i].integer_var = LittleLong (debug_data[i].integer_var);
debug_data[i].int_var = LittleLong (debug_data[i].int_var);
}
if (!(h = Qopen (options.debug_file, "wb")))
@ -441,9 +441,9 @@ finish_link (void)
if (options.code.progsversion != PROG_ID_VERSION) {
pr_int_t param_size = type_size (&type_param);
pr_int_t param_alignment = qfo_log2 (type_param.alignment);
linker_add_def (".param_size", &type_integer, flags,
linker_add_def (".param_size", &type_int, flags,
&param_size);
linker_add_def (".param_alignment", &type_integer, flags,
linker_add_def (".param_alignment", &type_int, flags,
&param_alignment);
linker_add_def (".xdefs", &type_xdefs, flags, 0);
}

6
tools/qfcc/source/qp-lex.l
View File

@ -113,7 +113,7 @@ FRAMEID {ID}(\.{ID})*
i = strtol (yytext + 2, 0, 2);
else
i = strtol (yytext, 0, 0);
qp_yylval.expr = new_integer_expr (i);
qp_yylval.expr = new_int_expr (i);
return VALUE;
}
@ -170,7 +170,7 @@ FRAMEID {ID}(\.{ID})*
"$"{s}*{FRAMEID} {
int ret = do_grab (yytext);
if (ret >= 0) {
qp_yylval.expr = new_integer_expr (ret);
qp_yylval.expr = new_int_expr (ret);
return VALUE;
} else {
BEGIN (-ret);
@ -209,7 +209,7 @@ static keyword_t keywords[] = {
{"vector", TYPE, &type_vector},
{"entity", TYPE, &type_entity},
{"quaternion", TYPE, &type_quaternion},
{"integer", TYPE, &type_integer},
{"integer", TYPE, &type_int},
{"program", PROGRAM, 0},
{"var", VAR, 0},

8
tools/qfcc/source/qp-parse.y
View File

@ -148,7 +148,7 @@ build_dotmain (symbol_t *program)
expr_t *exitcode;
dotmain->params = 0;
dotmain->type = parse_params (&type_integer, 0);
dotmain->type = parse_params (&type_int, 0);
dotmain->type = find_type (dotmain->type);
dotmain = function_symbol (dotmain, 0, 1);
@ -198,7 +198,7 @@ program_head
// FIXME need units and standard units
{
symbol_t *sym = new_symbol ("ExitCode");
sym->type = &type_integer;
sym->type = &type_int;
initialize_def (sym, 0, current_symtab->space, sc_global);
if (sym->s.def) {
sym->s.def->nosave = 1;
@ -245,7 +245,7 @@ type
: standard_type
| ARRAY '[' VALUE RANGE VALUE ']' OF standard_type
{
$$ = based_array_type ($8, expr_integer ($3), expr_integer ($5));
$$ = based_array_type ($8, expr_int ($3), expr_int ($5));
}
;
@ -480,7 +480,7 @@ name
{
if (!$1->table) {
error (0, "%s undefined", $1->name);
$1->type = &type_integer;
$1->type = &type_int;
symtab_addsymbol (current_symtab, $1);
}
$$ = new_symbol_expr ($1);

6
tools/qfcc/source/reloc.c
View File

@ -73,7 +73,7 @@ static const char *reloc_name[] = {
"rel_def_field_ofs",
};
#define RELOC(r) (r)->space->data[(r)->offset].integer_var
#define RELOC(r) (r)->space->data[(r)->offset].int_var
void
relocate_refs (reloc_t *reloc, int offset)
@ -168,8 +168,8 @@ relocate_refs (reloc_t *reloc, int offset)
break;
case rel_def_field_ofs:
//FIXME what is correct here?
//RELOC (reloc) += pr.data->data[offset].integer_var;
RELOC (reloc) += pr.near_data->data[offset].integer_var;
//RELOC (reloc) += pr.data->data[offset].int_var;
RELOC (reloc) += pr.near_data->data[offset].int_var;
break;
}
reloc = reloc->next;

2
tools/qfcc/source/shared.c
View File

@ -72,7 +72,7 @@ check_undefined (symbol_t *sym)
if (options.code.progsversion == PROG_ID_VERSION)
sym->type = &type_float;
else
sym->type = &type_integer;
sym->type = &type_int;
}
return sym;
}

40
tools/qfcc/source/statements.c
View File

@ -155,13 +155,13 @@ operand_string (operand_t *op)
case ev_field:
return va (0, "field %d", op->value->v.pointer.val);
case ev_entity:
return va (0, "ent %d", op->value->v.integer_val);
return va (0, "ent %d", op->value->v.int_val);
case ev_func:
return va (0, "func %d", op->value->v.integer_val);
case ev_integer:
return va (0, "int %d", op->value->v.integer_val);
case ev_uinteger:
return va (0, "uint %u", op->value->v.uinteger_val);
return va (0, "func %d", op->value->v.int_val);
case ev_int:
return va (0, "int %d", op->value->v.int_val);
case ev_uint:
return va (0, "uint %u", op->value->v.uint_val);
case ev_long:
return va (0, "long %"PRIi64, op->value->v.long_val);
case ev_ulong:
@ -237,11 +237,11 @@ _print_operand (operand_t *op)
break;
case ev_entity:
case ev_func:
case ev_integer:
printf ("%d", op->value->v.integer_val);
case ev_int:
printf ("%d", op->value->v.int_val);
break;
case ev_uinteger:
printf ("%u", op->value->v.uinteger_val);
case ev_uint:
printf ("%u", op->value->v.uint_val);
break;
case ev_long:
printf ("%"PRIu64, op->value->v.long_val);
@ -804,7 +804,7 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src)
if ((src && src->op_type == op_nil) || src_expr->type == ex_nil) {
// switch to memset because nil is type agnostic 0 and structures
// can be any size
src_expr = new_integer_expr (0);
src_expr = new_int_expr (0);
sblock = statement_subexpr (sblock, src_expr, &src);
opcode_set = opcode_sets[1];
if (op) {
@ -853,7 +853,7 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src)
if (count < (1 << 16)) {
count_expr = expr_file_line (new_short_expr (count), e);
} else {
count_expr = expr_file_line (new_integer_expr (count), e);
count_expr = expr_file_line (new_int_expr (count), e);
}
sblock = statement_subexpr (sblock, count_expr, &size);
@ -1210,7 +1210,7 @@ expr_alias (sblock_t *sblock, expr_t *e, operand_t **op)
int offset = 0;
if (e->e.alias.offset) {
offset = expr_integer (e->e.alias.offset);
offset = expr_int (e->e.alias.offset);
}
type = e->e.alias.type;
sblock = statement_subexpr (sblock, e->e.alias.expr, &aop);
@ -1473,9 +1473,9 @@ expr_nil (sblock_t *sblock, expr_t *e, operand_t **op)
if (nil_size < 0x10000) {
size_expr = new_short_expr (nil_size);
} else {
size_expr = new_integer_expr (nil_size);
size_expr = new_int_expr (nil_size);
}
sblock = statement_subexpr (sblock, new_integer_expr(0), &zero);
sblock = statement_subexpr (sblock, new_int_expr(0), &zero);
sblock = statement_subexpr (sblock, size_expr, &size);
s = new_statement (st_memset, "<MEMSET>", e);
@ -1737,12 +1737,12 @@ statement_memset (sblock_t *sblock, expr_t *e)
statement_t *s;
if (is_constant (count)) {
if (is_integer (get_type (count))
&& (unsigned) expr_integer (count) < 0x10000) {
count = new_short_expr (expr_integer (count));
if (is_int (get_type (count))
&& (unsigned) expr_int (count) < 0x10000) {
count = new_short_expr (expr_int (count));
}
if (is_uinteger (get_type (count)) && expr_integer (count) < 0x10000) {
count = new_short_expr (expr_uinteger (count));
if (is_uint (get_type (count)) && expr_int (count) < 0x10000) {
count = new_short_expr (expr_uint (count));
}
}
s = new_statement (st_move, opcode, e);

12
tools/qfcc/source/struct.c
View File

@ -235,17 +235,17 @@ add_enum (symbol_t *enm, symbol_t *name, expr_t *val)
name->type = enum_type;
value = 0;
if (enum_tab->symbols)
value = ((symbol_t *)(enum_tab->symtail))->s.value->v.integer_val + 1;
value = ((symbol_t *)(enum_tab->symtail))->s.value->v.int_val + 1;
if (val) {
convert_name (val);
if (!is_constant (val))
error (val, "non-constant initializer");
else if (!is_integer_val (val))
else if (!is_int_val (val))
error (val, "invalid initializer type");
else
value = expr_integer (val);
value = expr_int (val);
}
name->s.value = new_integer_val (value);
name->s.value = new_int_val (value);
symtab_addsymbol (enum_tab, name);
}
@ -263,12 +263,12 @@ enum_as_bool (type_t *enm, expr_t **zero, expr_t **one)
for (sym = symtab->symbols; sym; sym = sym->next) {
if (sym->sy_type != sy_const)
continue;
val = sym->s.value->v.integer_val;
val = sym->s.value->v.int_val;
if (!val) {
zero_sym = sym;
} else {
if (one_sym) {
v = one_sym->s.value->v.integer_val;
v = one_sym->s.value->v.int_val;
if (val * val > v * v)
continue;
}

42
tools/qfcc/source/switch.c
View File

@ -136,14 +136,14 @@ case_label_expr (switch_block_t *switch_block, expr_t *value)
if (!type_assignable (type, get_type (value)))
return error (value, "type mismatch in case label");
if (is_integral (type) && is_integral (val_type)) {
value = new_integer_expr (expr_integer (value));
value = new_int_expr (expr_int (value));
debug (value, "integeral label used in integral switch");
} else if (is_integral (type) && is_float (val_type)) {
warning (value, "float label used in integral switch");
value = new_integer_expr (expr_float (value));
value = new_int_expr (expr_float (value));
} else if (is_float (type) && is_integral (val_type)) {
debug (value, "integeral label used in float switch");
value = new_float_expr (expr_integer (value));
value = new_float_expr (expr_int (value));
} else if (is_float (type) && is_float (val_type)) {
value = new_float_expr (expr_float (value));
debug (value, "float label used in float switch");
@ -189,8 +189,8 @@ label_compare (const void *_a, const void *_b)
return strcmp (s1, s2);
} else if (is_float_val ((*a)->value)) {
return expr_float ((*a)->value) - expr_float ((*b)->value);
} else if (is_integer_val ((*a)->value)) {
return expr_integer ((*a)->value) - expr_integer ((*b)->value);
} else if (is_int_val ((*a)->value)) {
return expr_int ((*a)->value) - expr_int ((*b)->value);
}
internal_error (0, "in switch");
}
@ -210,9 +210,9 @@ new_case_node (expr_t *low, expr_t *high)
} else {
int size;
if (!is_integer_val (low))
if (!is_int_val (low))
internal_error (low, "switch");
size = expr_integer (high) - expr_integer (low) + 1;
size = expr_int (high) - expr_int (low) + 1;
node->labels = calloc (size, sizeof (expr_t *));
}
node->left = node->right = 0;
@ -253,18 +253,18 @@ build_case_tree (case_label_t **labels, int count, int range)
if (!nodes)
Sys_Error ("out of memory");
if (range && is_integer_val (labels[0]->value)) {
if (range && is_int_val (labels[0]->value)) {
for (i = 0; i < count - 1; i = j, num_nodes++) {
for (j = i + 1; j < count; j++) {
if (expr_integer (labels[j]->value)
- expr_integer (labels[j - 1]->value) > 1)
if (expr_int (labels[j]->value)
- expr_int (labels[j - 1]->value) > 1)
break;
}
nodes[num_nodes] = new_case_node (labels[i]->value,
labels[j - 1]->value);
for (k = i; k < j; k++)
nodes[num_nodes]->labels[expr_integer (labels[k]->value)
- expr_integer (labels[i]->value)]
nodes[num_nodes]->labels[expr_int (labels[k]->value)
- expr_int (labels[i]->value)]
= labels[k]->label;
}
if (i < count) {
@ -311,12 +311,12 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val,
append_expr (sw, test);
if (tree->low == tree->high) {
branch = branch_expr (EQ, new_alias_expr (&type_integer, temp),
branch = branch_expr (EQ, new_alias_expr (&type_int, temp),
tree->labels[0]);
append_expr (sw, branch);
if (tree->left) {
branch = branch_expr (GT, new_alias_expr (&type_integer, temp),
branch = branch_expr (GT, new_alias_expr (&type_int, temp),
high_label);
append_expr (sw, branch);
@ -329,8 +329,8 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val,
build_switch (sw, tree->right, op, sw_val, temp, default_label);
}
} else {
int low = expr_integer (tree->low);
int high = expr_integer (tree->high);
int low = expr_int (tree->low);
int high = expr_int (tree->high);
symbol_t *table_sym;
expr_t *table_expr;
expr_t *table_init;
@ -346,7 +346,7 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val,
append_element (table_init, new_element (label, 0));
}
table_sym = new_symbol_type (table_name,
array_type (&type_integer,
array_type (&type_int,
high - low + 1));
initialize_def (table_sym, table_init, pr.near_data, sc_static);
table_expr = new_symbol_expr (table_sym);
@ -355,8 +355,8 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val,
branch = branch_expr (LT, temp, low_label);
append_expr (sw, branch);
}
test = binary_expr (GT, cast_expr (&type_uinteger, temp),
cast_expr (&type_uinteger, range));
test = binary_expr (GT, cast_expr (&type_uint, temp),
cast_expr (&type_uint, range));
branch = branch_expr (NE, test, high_label);
append_expr (sw, branch);
branch = jump_table_expr (table_expr, temp);
@ -382,7 +382,7 @@ check_enum_switch (switch_block_t *switch_block)
for (enum_val = type->t.symtab->symbols; enum_val;
enum_val = enum_val->next) {
cl.value = new_integer_expr (enum_val->s.value->v.integer_val);
cl.value = new_int_expr (enum_val->s.value->v.int_val);
if (!Hash_FindElement (switch_block->labels, &cl)) {
warning (switch_block->test,
"enumeration value `%s' not handled in switch",
@ -446,7 +446,7 @@ switch_expr (switch_block_t *switch_block, expr_t *break_label,
case_node_t *case_tree;
if (is_string(type))
temp = new_temp_def_expr (&type_integer);
temp = new_temp_def_expr (&type_int);
else
temp = new_temp_def_expr (type);
case_tree = build_case_tree (labels, num_labels, is_integral (type));

64
tools/qfcc/source/type.c
View File

@ -75,8 +75,8 @@ type_t type_function = { ev_func, "function", 1, ty_basic,
type_t type_pointer = { ev_pointer, "pointer", 1, ty_basic,
{{&type_void}} };
type_t type_quaternion = { ev_quat, "quaternion", 4 };
type_t type_integer = { ev_integer, "int", 1 };
type_t type_uinteger = { ev_uinteger, "uint", 1 };
type_t type_int = { ev_int, "int", 1 };
type_t type_uint = { ev_uint, "uint", 1 };
type_t type_short = { ev_short, "short", 1 };
type_t type_double = { ev_double, "double", 2 };
@ -106,8 +106,8 @@ type_t *ev_types[ev_type_count] = {
&type_function,
&type_pointer,
&type_quaternion,
&type_integer,
&type_uinteger,
&type_int,
&type_uint,
&type_short,
&type_double,
&type_invalid,
@ -186,8 +186,8 @@ free_type (type_t *type)
case ev_entity:
case ev_type_count:
case ev_quat:
case ev_integer:
case ev_uinteger:
case ev_int:
case ev_uint:
case ev_long:
case ev_ulong:
case ev_short:
@ -228,8 +228,8 @@ copy_chain (type_t *type, type_t *append)
case ev_entity:
case ev_type_count:
case ev_quat:
case ev_integer:
case ev_uinteger:
case ev_int:
case ev_uint:
case ev_long:
case ev_ulong:
case ev_short:
@ -281,8 +281,8 @@ append_type (type_t *type, type_t *new)
case ev_entity:
case ev_type_count:
case ev_quat:
case ev_integer:
case ev_uinteger:
case ev_int:
case ev_uint:
case ev_long:
case ev_ulong:
case ev_short:
@ -660,8 +660,8 @@ print_type_str (dstring_t *str, const type_t *type)
case ev_vector:
case ev_entity:
case ev_quat:
case ev_integer:
case ev_uinteger:
case ev_int:
case ev_uint:
case ev_long:
case ev_ulong:
case ev_short:
@ -822,10 +822,10 @@ encode_type (dstring_t *encoding, const type_t *type)
case ev_quat:
dasprintf (encoding, "Q");
return;
case ev_integer:
case ev_int:
dasprintf (encoding, "i");
return;
case ev_uinteger:
case ev_uint:
dasprintf (encoding, "I");
return;
case ev_long:
@ -863,23 +863,23 @@ is_enum (const type_t *type)
}
int
is_integer (const type_t *type)
is_int (const type_t *type)
{
type = unalias_type (type);
etype_t t = type->type;
if (t == ev_integer)
if (t == ev_int)
return 1;
return is_enum (type);
}
int
is_uinteger (const type_t *type)
is_uint (const type_t *type)
{
type = unalias_type (type);
etype_t t = type->type;
if (t == ev_uinteger)
if (t == ev_uint)
return 1;
return is_enum (type);
}
@ -899,7 +899,7 @@ int
is_integral (const type_t *type)
{
type = unalias_type (type);
if (is_integer (type) || is_uinteger (type) || is_short (type))
if (is_int (type) || is_uint (type) || is_short (type))
return 1;
return is_enum (type);
}
@ -1103,7 +1103,7 @@ type_size (const type_t *type)
case ty_enum:
if (!type->t.symtab)
return 0;
return type_size (&type_integer);
return type_size (&type_int);
case ty_array:
return type->t.array.size * type_size (type->t.array.type);
case ty_class:
@ -1138,8 +1138,8 @@ chain_basic_types (void)
chain_type (&type_floatfield);
if (!options.traditional) {
chain_type (&type_quaternion);
chain_type (&type_integer);
chain_type (&type_uinteger);
chain_type (&type_int);
chain_type (&type_uint);
chain_type (&type_short);
chain_type (&type_double);
}
@ -1175,10 +1175,10 @@ init_types (void)
{"func_val", &type_function},
{"pointer_val", &type_pointer},
{"vector_val", &type_vector},
{"int_val", &type_integer},
{"uint_val", &type_uinteger},
{"integer_val", &type_integer},
{"uinteger_val", &type_uinteger},
{"int_val", &type_int},
{"uint_val", &type_uint},
{"int_val", &type_int},
{"uint_val", &type_uint},
{"quaternion_val", &type_quaternion},
{"double_val", &type_double},
{0, 0}
@ -1191,10 +1191,8 @@ init_types (void)
{"field_val", &type_field},
{"func_val", &type_function},
{"pointer_val", &type_pointer},
{"int_val", &type_integer},
{"uint_val", &type_uinteger},
{"integer_val", &type_integer},
{"uinteger_val", &type_uinteger},
{"int_val", &type_int},
{"uint_val", &type_uint},
{"quaternion_val", &type_quaternion},
{"double_val", &type_double},
{0, 0}
@ -1212,7 +1210,7 @@ init_types (void)
};
static struct_def_t type_encoding_struct[] = {
{"types", &type_pointer},
{"size", &type_integer},
{"size", &type_int},
{0, 0}
};
static struct_def_t xdef_struct[] = {
@ -1226,7 +1224,7 @@ init_types (void)
{0, 0}
};
static struct_def_t va_list_struct[] = {
{"count", &type_integer},
{"count", &type_int},
{"list", 0}, // type will be filled in at runtime
{0, 0}
};
@ -1234,7 +1232,7 @@ init_types (void)
chain_basic_types ();
type_nil = &type_quaternion;
type_default = &type_integer;
type_default = &type_int;
if (options.code.progsversion == PROG_ID_VERSION) {
// vector can't be part of .zero for v6 progs because for v6 progs,
// .zero is only one word wide.

90
tools/qfcc/source/value.c
View File

@ -68,7 +68,7 @@ typedef struct {
int func_val;
ex_pointer_t pointer;
float quaternion_val[4];
int integer_val;
int int_val;
double double_val;
} i;
} immediate_t;
@ -224,22 +224,22 @@ new_quaternion_val (const float *quaternion_val)
}
ex_value_t *
new_integer_val (int integer_val)
new_int_val (int int_val)
{
ex_value_t val;
memset (&val, 0, sizeof (val));
set_val_type (&val, &type_integer);
val.v.integer_val = integer_val;
set_val_type (&val, &type_int);
val.v.int_val = int_val;
return find_value (&val);
}
ex_value_t *
new_uinteger_val (int uinteger_val)
new_uint_val (int uint_val)
{
ex_value_t val;
memset (&val, 0, sizeof (val));
set_val_type (&val, &type_uinteger);
val.v.uinteger_val = uinteger_val;
set_val_type (&val, &type_uint);
val.v.uint_val = uint_val;
return find_value (&val);
}
@ -277,7 +277,7 @@ 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 *int_imm_defs;
static hashtab_t *double_imm_defs;
static void
@ -296,15 +296,15 @@ imm_get_hash (const void *_imm, void *_tab)
const char *str = pr.strings->strings + imm->i.string_val;
return str ? Hash_String (str) : 0;
} else if (tab == &float_imm_defs) {
return imm->i.integer_val;
return imm->i.int_val;
} else if (tab == &vector_imm_defs) {
return Hash_Buffer (&imm->i.vector_val, sizeof (&imm->i.vector_val));
} else if (tab == &entity_imm_defs) {
return imm->i.integer_val;
return imm->i.int_val;
} else if (tab == &field_imm_defs) {
return Hash_Buffer (&imm->i.pointer, sizeof (&imm->i.pointer));
} else if (tab == &func_imm_defs) {
return imm->i.integer_val;
return imm->i.int_val;
} else if (tab == &pointer_imm_defs) {
return Hash_Buffer (&imm->i.pointer, sizeof (&imm->i.pointer));
} else if (tab == &quaternion_imm_defs) {
@ -312,8 +312,8 @@ imm_get_hash (const void *_imm, void *_tab)
sizeof (&imm->i.quaternion_val));
} else if (tab == &double_imm_defs) {
return Hash_Buffer (&imm->i.double_val, sizeof (&imm->i.double_val));
} else if (tab == &integer_imm_defs) {
return imm->i.integer_val;
} else if (tab == &int_imm_defs) {
return imm->i.int_val;
} else {
internal_error (0, 0);
}
@ -348,8 +348,8 @@ imm_compare (const void *_imm1, const void *_imm2, void *_tab)
return QuatCompare (imm1->i.quaternion_val, imm2->i.quaternion_val);
} else if (tab == &double_imm_defs) {
return imm1->i.double_val == imm2->i.double_val;
} else if (tab == &integer_imm_defs) {
return imm1->i.integer_val == imm2->i.integer_val;
} else if (tab == &int_imm_defs) {
return imm1->i.int_val == imm2->i.int_val;
} else {
internal_error (0, 0);
}
@ -364,10 +364,10 @@ ReuseString (const char *str)
static float
value_as_float (ex_value_t *value)
{
if (value->lltype == ev_uinteger)
return value->v.uinteger_val;
if (value->lltype == ev_integer)
return value->v.integer_val;
if (value->lltype == ev_uint)
return value->v.uint_val;
if (value->lltype == ev_int)
return value->v.int_val;
if (value->lltype == ev_short)
return value->v.short_val;
if (value->lltype == ev_double)
@ -380,10 +380,10 @@ value_as_float (ex_value_t *value)
static double
value_as_double (ex_value_t *value)
{
if (value->lltype == ev_uinteger)
return value->v.uinteger_val;
if (value->lltype == ev_integer)
return value->v.integer_val;
if (value->lltype == ev_uint)
return value->v.uint_val;
if (value->lltype == ev_int)
return value->v.int_val;
if (value->lltype == ev_short)
return value->v.short_val;
if (value->lltype == ev_double)
@ -396,10 +396,10 @@ value_as_double (ex_value_t *value)
static int
value_as_int (ex_value_t *value)
{
if (value->lltype == ev_uinteger)
return value->v.uinteger_val;
if (value->lltype == ev_integer)
return value->v.integer_val;
if (value->lltype == ev_uint)
return value->v.uint_val;
if (value->lltype == ev_int)
return value->v.int_val;
if (value->lltype == ev_short)
return value->v.short_val;
if (value->lltype == ev_double)
@ -412,10 +412,10 @@ value_as_int (ex_value_t *value)
static unsigned
value_as_uint (ex_value_t *value)
{
if (value->lltype == ev_uinteger)
return value->v.uinteger_val;
if (value->lltype == ev_integer)
return value->v.integer_val;
if (value->lltype == ev_uint)
return value->v.uint_val;
if (value->lltype == ev_int)
return value->v.int_val;
if (value->lltype == ev_short)
return value->v.short_val;
if (value->lltype == ev_double)
@ -441,13 +441,13 @@ convert_value (ex_value_t *value, type_t *type)
} else if (type->type == ev_short) {
int val = value_as_int (value);
return new_short_val (val);
} else if (type->type == ev_uinteger) {
} else if (type->type == ev_uint) {
unsigned val = value_as_uint (value);
return new_uinteger_val (val);
return new_uint_val (val);
} else {
//FIXME handle enums separately?
int val = value_as_int (value);
return new_integer_val (val);
return new_int_val (val);
}
}
@ -511,21 +511,21 @@ emit_value (ex_value_t *value, def_t *def)
tab = pointer_imm_defs;
type = &type_pointer;
break;
case ev_integer:
case ev_uinteger:
case ev_int:
case ev_uint:
if (!def || !is_float(def->type)) {
tab = integer_imm_defs;
type = &type_integer;
tab = int_imm_defs;
type = &type_int;
break;
}
val.v.float_val = val.v.integer_val;
val.v.float_val = val.v.int_val;
val.lltype = ev_float;
case ev_float:
tab = float_imm_defs;
type = &type_float;
break;
case ev_string:
val.v.integer_val = ReuseString (val.v.string_val);
val.v.int_val = ReuseString (val.v.string_val);
tab = string_imm_defs;
type = &type_string;
break;
@ -637,7 +637,7 @@ clear_immediates (void)
Hash_FlushTable (func_imm_defs);
Hash_FlushTable (pointer_imm_defs);
Hash_FlushTable (quaternion_imm_defs);
Hash_FlushTable (integer_imm_defs);
Hash_FlushTable (int_imm_defs);
Hash_FlushTable (double_imm_defs);
} else {
value_table = Hash_NewTable (16381, 0, 0, 0, 0);
@ -675,9 +675,9 @@ clear_immediates (void)
&quaternion_imm_defs, 0);
Hash_SetHashCompare (quaternion_imm_defs, imm_get_hash, imm_compare);
integer_imm_defs = Hash_NewTable (16381, 0, imm_free,
&integer_imm_defs, 0);
Hash_SetHashCompare (integer_imm_defs, imm_get_hash, imm_compare);
int_imm_defs = Hash_NewTable (16381, 0, imm_free,
&int_imm_defs, 0);
Hash_SetHashCompare (int_imm_defs, imm_get_hash, imm_compare);
double_imm_defs = Hash_NewTable (16381, 0, imm_free,
&double_imm_defs, 0);
@ -691,5 +691,5 @@ clear_immediates (void)
make_def_imm (def, float_imm_defs, &zero_val);
make_def_imm (def, entity_imm_defs, &zero_val);
make_def_imm (def, pointer_imm_defs, &zero_val);
make_def_imm (def, integer_imm_defs, &zero_val);
make_def_imm (def, int_imm_defs, &zero_val);
}

10
tools/qfcc/test/double-alias.r
View File

@ -23,12 +23,12 @@ alias_printf (string fmt, ...)
{
int fail = 0;
// this will fail on big-endian systems
fail = (@args.list[2].integer_val != 0x54442d18
|| @args.list[1].integer_val != 0x400921fb);
fail = (@args.list[2].int_val != 0x54442d18
|| @args.list[1].int_val != 0x400921fb);
printf ("%g %08x%08x\n",
@args.list[0].integer_val,
@args.list[2].integer_val,
@args.list[1].integer_val);
@args.list[0].int_val,
@args.list[2].int_val,
@args.list[1].int_val);
return fail;
}

2
tools/qfcc/test/typedef.r
View File

@ -26,7 +26,7 @@ check_alias (string name, qfot_type_t *alias)
{
if (alias.meta != ty_basic || alias.type != ev_pointer
|| alias.fldptr.aux_type.meta != ty_basic
|| alias.fldptr.aux_type.type != ev_integer) {
|| alias.fldptr.aux_type.type != ev_int) {
printf ("%s is not a *int alias\n", name);
return 0;
}