diff --git a/include/QF/progs.h b/include/QF/progs.h index f8c8d42b0..f9ae57c63 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -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); @@ -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; diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 4fffa8792..9dbaea8db 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -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 { diff --git a/include/QF/progs/pr_type_names.h b/include/QF/progs/pr_type_names.h index 2e0ae9576..ff190f2cd 100644 --- a/include/QF/progs/pr_type_names.h +++ b/include/QF/progs/pr_type_names.h @@ -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) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 4b123ce19..8734bb03c 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -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", ], }, } diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 4b4b23d05..9e0b1b363 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -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) { diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 53964982f..d0f94d8fb 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -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: diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 1d725d21c..0f1cb1258 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -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 diff --git a/libs/gamecode/pr_parse.c b/libs/gamecode/pr_parse.c index 8b4c2d728..33ab39d3c 100644 --- a/libs/gamecode/pr_parse.c +++ b/libs/gamecode/pr_parse.c @@ -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: diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 560d14668..c61821852 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -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.if", - ev_integer, ev_invalid, ev_float, + ev_int, ev_invalid, ev_float, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_FI_v6p] = {"", "conv.fi", - ev_float, ev_invalid, ev_integer, + ev_float, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_ID_v6p] = {"", "conv.id", - ev_integer, ev_invalid, ev_double, + ev_int, ev_invalid, ev_double, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_DI_v6p] = {"", "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", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFNOT_v6p] = {"", "ifnot", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFBE_v6p] = {"", "ifbe", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFB_v6p] = {"", "ifb", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFAE_v6p] = {"", "ifae", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFA_v6p] = {"", "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", - ev_integer, ev_invalid, ev_invalid, + ev_int, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, [OP_JUMPB_v6p] = {"", "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", - 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] = {"", "memseti", - ev_integer, ev_short, ev_void, + ev_int, ev_short, ev_void, PROG_V6P_VERSION, "%Ga, %sb, %gc", }, [OP_MEMSETP_v6p] = {"", "memsetp", - ev_integer, ev_integer, ev_pointer, + ev_int, ev_int, ev_pointer, PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, [OP_MEMSETPI_v6p] = {"", "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.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] = {"", "pushb.s", - ev_pointer, ev_integer, ev_string, + ev_pointer, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_F_v6p] = {"", "pushb.f", - ev_pointer, ev_integer, ev_float, + ev_pointer, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_V_v6p] = {"", "pushb.v", - ev_pointer, ev_integer, ev_vector, + ev_pointer, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_ENT_v6p] = {"", "pushb.ent", - ev_pointer, ev_integer, ev_entity, + ev_pointer, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_FLD_v6p] = {"", "pushb.fld", - ev_pointer, ev_integer, ev_field, + ev_pointer, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_FN_v6p] = {"", "pushb.fn", - ev_pointer, ev_integer, ev_func, + ev_pointer, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_P_v6p] = {"", "pushb.p", - ev_pointer, ev_integer, ev_pointer, + ev_pointer, ev_int, ev_pointer, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_Q_v6p] = {"", "pushb.q", - ev_pointer, ev_integer, ev_quat, + ev_pointer, ev_int, ev_quat, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_I_v6p] = {"", "pushb.i", - ev_pointer, ev_integer, ev_integer, + ev_pointer, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_D_v6p] = {"", "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] = {"", "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.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] = {"", "popb.s", - ev_pointer, ev_integer, ev_string, + ev_pointer, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_F_v6p] = {"", "popb.f", - ev_pointer, ev_integer, ev_float, + ev_pointer, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_V_v6p] = {"", "popb.v", - ev_pointer, ev_integer, ev_vector, + ev_pointer, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_ENT_v6p] = {"", "popb.ent", - ev_pointer, ev_integer, ev_entity, + ev_pointer, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_FLD_v6p] = {"", "popb.fld", - ev_pointer, ev_integer, ev_field, + ev_pointer, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_FN_v6p] = {"", "popb.fn", - ev_pointer, ev_integer, ev_func, + ev_pointer, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_P_v6p] = {"", "popb.p", - ev_pointer, ev_integer, ev_pointer, + ev_pointer, ev_int, ev_pointer, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_Q_v6p] = {"", "popb.q", - ev_pointer, ev_integer, ev_quat, + ev_pointer, ev_int, ev_quat, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_I_v6p] = {"", "popb.i", - ev_pointer, ev_integer, ev_integer, + ev_pointer, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_D_v6p] = {"", "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] = {"", "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: diff --git a/libs/gib/bi_gib.c b/libs/gib/bi_gib.c index 2b1c6c5b4..726e18d8b 100644 --- a/libs/gib/bi_gib.c +++ b/libs/gib/bi_gib.c @@ -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(); diff --git a/libs/ruamoko/pr_cmds.c b/libs/ruamoko/pr_cmds.c index 36827ad4e..5aed0b2a4 100644 --- a/libs/ruamoko/pr_cmds.c +++ b/libs/ruamoko/pr_cmds.c @@ -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) diff --git a/libs/ruamoko/rua_hash.c b/libs/ruamoko/rua_hash.c index 4c8b86049..27a40d3d5 100644 --- a/libs/ruamoko/rua_hash.c +++ b/libs/ruamoko/rua_hash.c @@ -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); } diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index fafc4fe85..66994f65c 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -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 diff --git a/libs/video/renderer/vulkan/vkgen/vktype.r b/libs/video/renderer/vulkan/vkgen/vktype.r index f9776dcd4..aa32f3a41 100644 --- a/libs/video/renderer/vulkan/vkgen/vktype.r +++ b/libs/video/renderer/vulkan/vkgen/vktype.r @@ -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]; diff --git a/nq/include/sv_progs.h b/nq/include/sv_progs.h index 975515eb0..a660b4e77 100644 --- a/nq/include/sv_progs.h +++ b/nq/include/sv_progs.h @@ -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 diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index 3a8c44dd2..5c94f8080 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -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: diff --git a/nq/source/world.c b/nq/source/world.c index a73e7c498..b8b423d83 100644 --- a/nq/source/world.c +++ b/nq/source/world.c @@ -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 diff --git a/qw/include/sv_progs.h b/qw/include/sv_progs.h index c3391e2fb..b4d931c35 100644 --- a/qw/include/sv_progs.h +++ b/qw/include/sv_progs.h @@ -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 diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index 87b871ec9..8937e7fc8 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -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: diff --git a/qw/source/sv_user.c b/qw/source/sv_user.c index 490127b33..2f37404b6 100644 --- a/qw/source/sv_user.c +++ b/qw/source/sv_user.c @@ -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 { diff --git a/qw/source/world.c b/qw/source/world.c index 877db0f38..7024bca6c 100644 --- a/qw/source/world.c +++ b/qw/source/world.c @@ -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 diff --git a/ruamoko/cl_menu/plistmenu.r b/ruamoko/cl_menu/plistmenu.r index f94e6bdfc..2694e48b5 100644 --- a/ruamoko/cl_menu/plistmenu.r +++ b/ruamoko/cl_menu/plistmenu.r @@ -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; } } diff --git a/ruamoko/include/types.h b/ruamoko/include/types.h index 19ec0c736..7054eeead 100644 --- a/ruamoko/include/types.h +++ b/ruamoko/include/types.h @@ -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, diff --git a/ruamoko/qwaq/debugger/typeencodings.r b/ruamoko/qwaq/debugger/typeencodings.r index d6246e2ef..64429b273 100644 --- a/ruamoko/qwaq/debugger/typeencodings.r +++ b/ruamoko/qwaq/debugger/typeencodings.r @@ -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 diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 61ff0b7ca..f75fd79ba 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -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)); diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index 2aec16095..aecd3801a 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -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. diff --git a/tools/qfcc/include/qfcc.h b/tools/qfcc/include/qfcc.h index c129e8271..b678cc5a4 100644 --- a/tools/qfcc/include/qfcc.h +++ b/tools/qfcc/include/qfcc.h @@ -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) diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index f985ea826..87ca80966 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -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)); diff --git a/tools/qfcc/include/value.h b/tools/qfcc/include/value.h index a2f13dd67..21e10f43d 100644 --- a/tools/qfcc/include/value.h +++ b/tools/qfcc/include/value.h @@ -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); diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index 99d6fbcb2..de0d473e6 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -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}, }; diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 6ee98f70e..20a9c5716 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -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 diff --git a/tools/qfcc/source/debug.c b/tools/qfcc/source/debug.c index 644ee31d9..4afff69ee 100644 --- a/tools/qfcc/source/debug.c +++ b/tools/qfcc/source/debug.c @@ -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} }; diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 94cc49ce1..cf854a1b4 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -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; } diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index a66009bd5..d1cbfee26 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -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); diff --git a/tools/qfcc/source/dot_type.c b/tools/qfcc/source/dot_type.c index 522fa91fb..fa77bbf3d 100644 --- a/tools/qfcc/source/dot_type.c +++ b/tools/qfcc/source/dot_type.c @@ -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; diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index f27f33d4b..e55c10104 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -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 (""); } } diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 0b70c6ae4..47daa1348 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -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; } diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index df304f119..885f87ef1 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -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; } diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index 9f7b0e1e4..df8e25180 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -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; } diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index e448990b2..08a397651 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -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) { diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c index 9c82f89d5..67df1d3fb 100644 --- a/tools/qfcc/source/method.c +++ b/tools/qfcc/source/method.c @@ -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"); } } } diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index eed5de4ce..a9f562984 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -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: diff --git a/tools/qfcc/source/obj_type.c b/tools/qfcc/source/obj_type.c index 09927ecd3..d806e6c9b 100644 --- a/tools/qfcc/source/obj_type.c +++ b/tools/qfcc/source/obj_type.c @@ -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]); diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index ee9722a2a..47accd2c3 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -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); diff --git a/tools/qfcc/source/pragma.c b/tools/qfcc/source/pragma.c index 60448815e..616198ab2 100644 --- a/tools/qfcc/source/pragma.c +++ b/tools/qfcc/source/pragma.c @@ -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; diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index 1a3cb9d99..c53965993 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -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 }, diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 9c56a5790..454c8fcfc 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -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 { diff --git a/tools/qfcc/source/qfcc.c b/tools/qfcc/source/qfcc.c index 2e656a21e..25c1a89c6 100644 --- a/tools/qfcc/source/qfcc.c +++ b/tools/qfcc/source/qfcc.c @@ -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, ¶m_size); - linker_add_def (".param_alignment", &type_integer, flags, + linker_add_def (".param_alignment", &type_int, flags, ¶m_alignment); linker_add_def (".xdefs", &type_xdefs, flags, 0); } diff --git a/tools/qfcc/source/qp-lex.l b/tools/qfcc/source/qp-lex.l index a57185209..7bb6d160b 100644 --- a/tools/qfcc/source/qp-lex.l +++ b/tools/qfcc/source/qp-lex.l @@ -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}, diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y index b45e6d0ee..e7bb66647 100644 --- a/tools/qfcc/source/qp-parse.y +++ b/tools/qfcc/source/qp-parse.y @@ -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); diff --git a/tools/qfcc/source/reloc.c b/tools/qfcc/source/reloc.c index c1d471d0a..d235008d0 100644 --- a/tools/qfcc/source/reloc.c +++ b/tools/qfcc/source/reloc.c @@ -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; diff --git a/tools/qfcc/source/shared.c b/tools/qfcc/source/shared.c index cee0d06c1..acdbf149f 100644 --- a/tools/qfcc/source/shared.c +++ b/tools/qfcc/source/shared.c @@ -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; } diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 1c2cbc965..0d52f7c4e 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -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, "", 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); diff --git a/tools/qfcc/source/struct.c b/tools/qfcc/source/struct.c index 164a491a2..798696ac3 100644 --- a/tools/qfcc/source/struct.c +++ b/tools/qfcc/source/struct.c @@ -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; } diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c index f40d48d6d..9f245807a 100644 --- a/tools/qfcc/source/switch.c +++ b/tools/qfcc/source/switch.c @@ -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)); diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 17dd74571..81583de9c 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -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. diff --git a/tools/qfcc/source/value.c b/tools/qfcc/source/value.c index cd0af3d54..786a3d2fb 100644 --- a/tools/qfcc/source/value.c +++ b/tools/qfcc/source/value.c @@ -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); } diff --git a/tools/qfcc/test/double-alias.r b/tools/qfcc/test/double-alias.r index 6050d2f6d..92eecd9c3 100644 --- a/tools/qfcc/test/double-alias.r +++ b/tools/qfcc/test/double-alias.r @@ -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; } diff --git a/tools/qfcc/test/typedef.r b/tools/qfcc/test/typedef.r index 9dbd7f40b..3755f63eb 100644 --- a/tools/qfcc/test/typedef.r +++ b/tools/qfcc/test/typedef.r @@ -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; }