qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-30 16:10:53 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/gamecode/pr_v6p_opcode.c

1773 lines
41 KiB
C
Raw Normal View History

the rcsid commit from hell }:>
2001-09-28 06:26:31 +00:00
/*
[gamecode] Rename pr_opcode.c Just to make way for new tables :)
2022-01-04 11:45:45 +00:00
pr_v6p_opcodes.c
move the full info opcocde table from qfcc to gamecode (<KURGON>There can be only one!</KURGON>:) and use the table in PR_PrintStatement. This means that qfcc now links against libQFgamecode as well as libQFutil
2001-07-14 02:34:16 +00:00
[gamecode] Rename pr_opcode.c Just to make way for new tables :)
2022-01-04 11:45:45 +00:00
Opcode table and checking for v6+ progs.
move the full info opcocde table from qfcc to gamecode (<KURGON>There can be only one!</KURGON>:) and use the table in PR_PrintStatement. This means that qfcc now links against libQFgamecode as well as libQFutil
2001-07-14 02:34:16 +00:00
[gamecode] Rename pr_opcode.c Just to make way for new tables :)
2022-01-04 11:45:45 +00:00
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 2001 Bill Currie <bill@taniwha.org>
the rcsid commit from hell }:>
2001-09-28 06:26:31 +00:00
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
move the full info opcocde table from qfcc to gamecode (<KURGON>There can be only one!</KURGON>:) and use the table in PR_PrintStatement. This means that qfcc now links against libQFgamecode as well as libQFutil
2001-07-14 02:34:16 +00:00
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
re-arrange things so __attribute__ and __builtin_expect are properly autoconfiscated so rcsid will continue to work with gcc 3.3
2003-01-15 15:31:36 +00:00
I've really got to start testing with gcc 3.0
2001-07-14 04:12:48 +00:00
#ifdef HAVE_STRING_H
# include "string.h"
#endif
#ifdef HAVE_STRINGS_H
# include "strings.h"
#endif
lots of work on better array/pointer/struct handline. doesn't quite work yet
2001-12-12 08:39:47 +00:00
#include "QF/cvar.h"
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
#include "QF/progs.h"
qccx (etc) "integer" autodetection. Check for usage of denormal floats and if found, either bail with a descriptive error message or give a mild warning that things will probably break. This avoids the possibility of things like RuneQuake getting "lucky" and doing real harm, and certainly avoids the segfaults.
2010-01-13 06:36:54 +00:00
#include "QF/sys.h"
move the full info opcocde table from qfcc to gamecode (<KURGON>There can be only one!</KURGON>:) and use the table in PR_PrintStatement. This means that qfcc now links against libQFgamecode as well as libQFutil
2001-07-14 02:34:16 +00:00
[gamecode] Move progs auxiliary headers into a subdirectory Just another step along the road of tidying up the QF include directory (and desirable for generated data).
2022-01-08 15:26:52 +00:00
#include "QF/progs/pr_comp.h"
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
#include "compat.h"
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
// default format is "%Ga, %Gb, %gc"
minor cleanups and use escapes when printing strings
2004-01-31 08:34:01 +00:00
// V global_string, contents, void
// G global_string, contents
// g global_string, no contents
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
// s as short
// O address + short
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
// P function parameter
// F function (must come before any P)
"print" command for dumping values in the progs and add return type info to the debugging information
2007-09-15 07:47:31 +00:00
// R return value
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
// E entity + field (%Eab)
[gamecode] Add format for addressing modes and use in return This fixes Ruamoko's return format string. It looks like it's producing the correct address (but doesn't show all the information it should), but the rest of the debug code needs work locals.
2022-01-27 04:29:38 +00:00
// M addressing mode, contents
// m addressing mode, no contents
// takes operand (a,b,c,o (opcode)) and right shift(hex). always masked
// by 3
// %Mc5 -> contents, operand c, shift right 5 bits
// %mo2 -> no contents, opcode, shift right 2 bits
// %mo0 -> no contents, opcode, no shift
// always uses a and b for the address calculation (Ruamoko convention))
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
//
// a operand a
// b operand b
// c operand c
[gamecode] Add format for addressing modes and use in return This fixes Ruamoko's return format string. It looks like it's producing the correct address (but doesn't show all the information it should), but the rest of the debug code needs work locals.
2022-01-27 04:29:38 +00:00
// o opcode
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
// x place holder for P (padding)
// 0-7 parameter index (for P)
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = {
// OP_DONE_v6p is actually the same as OP_RETURN_v6p, the types are bogus
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_DONE_v6p] = {"done", "done",
[gamecode] Remove the right_associative field It has been useless pretty much since I switched to using bison for the parser.
2022-01-02 10:02:48 +00:00
ev_entity, ev_field, ev_void,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Va",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_D_v6p] = {"mul", "mul.d",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_double, ev_double, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_F_v6p] = {"mul", "mul.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_V_v6p] = {"mul", "mul.v",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_vector, ev_vector, ev_float,
PROG_ID_VERSION,
},
[gamecode] Rename v6 vector-scalar multiply to scale Makes it easier to get Ruamoko scaling implemented if they both use the same opname.
2022-01-30 05:47:26 +00:00
[OP_MUL_FV_v6p] = {"scale", "mul.fv",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_vector, ev_vector,
PROG_ID_VERSION,
},
[gamecode] Rename v6 vector-scalar multiply to scale Makes it easier to get Ruamoko scaling implemented if they both use the same opname.
2022-01-30 05:47:26 +00:00
[OP_MUL_VF_v6p] = {"scale", "mul.vf",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_vector, ev_float, ev_vector,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_DV_v6p] = {"mul", "mul.dv",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_double, ev_vector, ev_vector,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_VD_v6p] = {"mul", "mul.vd",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_vector, ev_double, ev_vector,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_Q_v6p] = {"mul", "mul.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_quaternion, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_FQ_v6p] = {"mul", "mul.fq",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_float, ev_quaternion, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_QF_v6p] = {"mul", "mul.qf",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_float, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_DQ_v6p] = {"mul", "mul.dq",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_double, ev_quaternion, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_QD_v6p] = {"mul", "mul.qd",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_double, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_QV_v6p] = {"mul", "mul.qv",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_vector, ev_vector,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add vec = quat * vec to the progs engine.
2012-04-26 01:29:21 +00:00
},
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CONJ_Q_v6p] = {"conj", "conj.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_invalid, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Correct the dump format for conj.q.
2012-07-19 00:57:03 +00:00
"%Ga, %gc",
quaternion conjugate support (engine side)
2004-04-08 04:57:17 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_DIV_F_v6p] = {"div", "div.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_DIV_D_v6p] = {"div", "div.d",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_double, ev_double, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_REM_D_v6p] = {"rem", "rem.d",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_double, ev_double, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MOD_D_v6p] = {"mod", "mod.d",
Implement true modulo in the engine
2020-02-16 02:53:56 +00:00
ev_double, ev_double, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Implement true modulo in the engine
2020-02-16 02:53:56 +00:00
},
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADD_D_v6p] = {"add", "add.d",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_double, ev_double, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADD_F_v6p] = {"add", "add.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADD_V_v6p] = {"add", "add.v",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_vector, ev_vector, ev_vector,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADD_Q_v6p] = {"add", "add.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_quaternion, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADD_S_v6p] = {"add", "add.s",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_string, ev_string, ev_string,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SUB_D_v6p] = {"sub", "sub.d",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_double, ev_double, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SUB_F_v6p] = {"sub", "sub.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SUB_V_v6p] = {"sub", "sub.v",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_vector, ev_vector, ev_vector,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SUB_Q_v6p] = {"sub", "sub.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_quaternion, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
},
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_D_v6p] = {"eq", "eq.d",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_double, ev_double, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_F_v6p] = {"eq", "eq.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_float, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_V_v6p] = {"eq", "eq.v",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_vector, ev_vector, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_Q_v6p] = {"eq", "eq.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_quaternion, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_S_v6p] = {"eq", "eq.s",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_string, ev_string, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_E_v6p] = {"eq", "eq.e",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_entity, ev_entity, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_FN_v6p] = {"eq", "eq.fn",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_func, ev_func, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NE_D_v6p] = {"ne", "ne.d",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_double, ev_double, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NE_F_v6p] = {"ne", "ne.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_float, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NE_V_v6p] = {"ne", "ne.v",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_vector, ev_vector, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NE_Q_v6p] = {"ne", "ne.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_quaternion, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
},
[qfcc] Change ne to cmp for v6 string inequality check Since it's really strcmp in disguise (makes the instruction consistent across all targets).
2022-01-29 09:18:33 +00:00
[OP_NE_S_v6p] = {"cmp", "ne.s",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_string, ev_string, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NE_E_v6p] = {"ne", "ne.e",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_entity, ev_entity, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NE_FN_v6p] = {"ne", "ne.fn",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_func, ev_func, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LE_D_v6p] = {"le", "le.d",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_double, ev_double, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LE_F_v6p] = {"le", "le.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_float, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GE_D_v6p] = {"ge", "ge.d",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_double, ev_double, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GE_F_v6p] = {"ge", "ge.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_float, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LE_S_v6p] = {"le", "le.s",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_string, ev_string, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GE_S_v6p] = {"ge", "ge.s",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_string, ev_string, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LT_D_v6p] = {"lt", "lt.d",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_double, ev_double, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LT_F_v6p] = {"lt", "lt.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_float, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GT_D_v6p] = {"gt", "gt.d",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_double, ev_double, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GT_F_v6p] = {"gt", "gt.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_float, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LT_S_v6p] = {"lt", "lt.s",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_string, ev_string, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GT_S_v6p] = {"gt", "gt.s",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_string, ev_string, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_F_v6p] = {"load", "load.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_entity, ev_field, ev_float,
PROG_ID_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",//FIXME %E more flexible?
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_D_v6p] = {"load", "load.d",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_entity, ev_field, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga.%Gb(%Ec), %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_V_v6p] = {"load", "load.v",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_entity, ev_field, ev_vector,
PROG_ID_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_Q_v6p] = {"load", "load.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_entity, ev_field, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",
engine side quaternion support
2004-04-08 00:56:30 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_S_v6p] = {"load", "load.s",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_entity, ev_field, ev_string,
PROG_ID_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_ENT_v6p] = {"load", "load.ent",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_entity, ev_field, ev_entity,
PROG_ID_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_FLD_v6p] = {"load", "load.fld",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_entity, ev_field, ev_field,
PROG_ID_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_FN_v6p] = {"load", "load.fn",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_entity, ev_field, ev_func,
PROG_ID_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_I_v6p] = {"load", "load.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_entity, ev_field, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOAD_P_v6p] = {"load", "load.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_entity, ev_field, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Print data being loaded from an entity.
2010-11-19 15:31:34 +00:00
"%Ga.%Gb(%Ec), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_D_v6p] = {"load", "loadb.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"*(%Ga + %Gb), %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_F_v6p] = {"load", "loadb.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_V_v6p] = {"load", "loadb.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_vector,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_Q_v6p] = {"load", "loadb.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_ptr, ev_int, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
"*(%Ga + %Gb), %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_S_v6p] = {"load", "loadb.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_string,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_ENT_v6p] = {"load", "loadb.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_entity,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_FLD_v6p] = {"load", "loadb.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_field,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_FN_v6p] = {"load", "loadb.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_func,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_I_v6p] = {"load", "loadb.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADB_P_v6p] = {"load", "loadb.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_D_v6p] = {"load", "loadbi.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"*(%Ga + %sb), %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_F_v6p] = {"load", "loadbi.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_V_v6p] = {"load", "loadbi.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_vector,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_Q_v6p] = {"load", "loadbi.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_ptr, ev_short, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
"*(%Ga + %sb), %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_S_v6p] = {"load", "loadbi.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_string,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_ENT_v6p] = {"load", "loadbi.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_entity,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_FLD_v6p] = {"load", "loadbi.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_field,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_FN_v6p] = {"load", "loadbi.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_func,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_I_v6p] = {"load", "loadbi.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LOADBI_P_v6p] = {"load", "loadbi.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"*(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_v6p] = {"lea", "address",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_entity, ev_field, ev_ptr,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
Add (%Ec) to OP_ADDRESS's format specifier. This makes OP_ADDRESS and OP_LOAD_* consistent.
2013-01-17 07:43:54 +00:00
"%Ga.%Gb(%Ec), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_VOID_v6p] = {"lea", "address",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_void, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a void address instruction.
2011-03-10 10:28:03 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_D_v6p] = {"lea", "address.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_double, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_F_v6p] = {"lea", "address.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_float, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_V_v6p] = {"lea", "address.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_vector, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_Q_v6p] = {"lea", "address.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_S_v6p] = {"lea", "address.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_string, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_ENT_v6p] = {"lea", "address.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_entity, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_FLD_v6p] = {"lea", "address.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_field, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_FN_v6p] = {"lea", "address.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_func, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_I_v6p] = {"lea", "address.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_int, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADDRESS_P_v6p] = {"lea", "address.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_invalid, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LEA_v6p] = {"lea", "lea",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Tweak output for lea
2020-03-15 01:06:37 +00:00
"(%Ga + %Gb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LEAI_v6p] = {"lea", "leai",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Tweak output for lea
2020-03-15 01:06:37 +00:00
"(%Ga + %sb), %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CONV_IF_v6p] = {"conv", "conv.if",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_invalid, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CONV_FI_v6p] = {"conv", "conv.fi",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_invalid, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CONV_ID_v6p] = {"conv", "conv.id",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_invalid, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CONV_DI_v6p] = {"conv", "conv.di",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_double, ev_invalid, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CONV_FD_v6p] = {"conv", "conv.fd",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_float, ev_invalid, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CONV_DF_v6p] = {"conv", "conv.df",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_double, ev_invalid, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, %gc",
},
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_D_v6p] = {"assign", "store.d",
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
ev_double, ev_double, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_F_v6p] = {"assign", "store.f",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_float, ev_float, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_V_v6p] = {"assign", "store.v",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_vector, ev_vector, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_Q_v6p] = {"assign", "store.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_quaternion, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_S_v6p] = {"assign", "store.s",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_string, ev_string, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_ENT_v6p] = {"assign", "store.ent",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_entity, ev_entity, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_FLD_v6p] = {"assign", "store.fld",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_field, ev_field, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_FN_v6p] = {"assign", "store.fn",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_func, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_I_v6p] = {"assign", "store.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STORE_P_v6p] = {"assign", "store.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_D_v6p] = {"store", "storep.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_double, ev_ptr, ev_invalid,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
PROG_ID_VERSION,
"%Ga, *%Gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_F_v6p] = {"store", "storep.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_float, ev_ptr, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *%Gb",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_V_v6p] = {"store", "storep.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_vector, ev_ptr, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *%Gb",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_Q_v6p] = {"store", "storep.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_ptr, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
"%Ga, *%Gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_S_v6p] = {"store", "storep.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_string, ev_ptr, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *%Gb",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_ENT_v6p] = {"store", "storep.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_entity, ev_ptr, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *%Gb",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_FLD_v6p] = {"store", "storep.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_field, ev_ptr, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *%Gb",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_FN_v6p] = {"store", "storep.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_func, ev_ptr, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *%Gb",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_I_v6p] = {"store", "storep.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_int, ev_ptr, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *%Gb",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREP_P_v6p] = {"store", "storep.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *%Gb",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_D_v6p] = {"store", "storeb.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_double, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, *(%Gb + %Gc)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_F_v6p] = {"store", "storeb.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_float, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %Gc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_V_v6p] = {"store", "storeb.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_vector, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %Gc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_Q_v6p] = {"store", "storeb.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
"%Ga, *(%Gb + %Gc)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_S_v6p] = {"store", "storeb.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_string, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %Gc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_ENT_v6p] = {"store", "storeb.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_entity, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %Gc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_FLD_v6p] = {"store", "storeb.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_field, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %Gc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_FN_v6p] = {"store", "storeb.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_func, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %Gc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_I_v6p] = {"store", "storeb.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_int, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %Gc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREB_P_v6p] = {"store", "storeb.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %Gc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_D_v6p] = {"store", "storebi.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_double, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, *(%Gb + %sc)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_F_v6p] = {"store", "storebi.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_float, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %sc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_V_v6p] = {"store", "storebi.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_vector, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %sc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_Q_v6p] = {"store", "storebi.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
"%Ga, *(%Gb + %sc)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_S_v6p] = {"store", "storebi.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_string, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %sc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_ENT_v6p] = {"store", "storebi.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_entity, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %sc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_FLD_v6p] = {"store", "storebi.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_field, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %sc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_FN_v6p] = {"store", "storebi.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_func, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %sc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_I_v6p] = {"store", "storebi.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_int, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %sc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STOREBI_P_v6p] = {"store", "storebi.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_short,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
better formats for load* and store[bp]*
2003-09-04 05:30:55 +00:00
"%Ga, *(%Gb + %sc)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RETURN_v6p] = {"return", "return",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_void, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"print" command for dumping values in the progs and add return type info to the debugging information
2007-09-15 07:47:31 +00:00
"%Ra",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Fix a few missed opcode renames if and ifnot became ifnz and ifz, and return_v lost its tail (it was always redundant, except in dags, and that's fixed with a pointer check).
2022-01-20 03:41:01 +00:00
[OP_RETURN_V_v6p] = {"return", "return",
Add a "void return" instruction. I got fed up with always having to explicty return something.
2011-01-12 15:29:56 +00:00
ev_invalid, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a "void return" instruction. I got fed up with always having to explicty return something.
2011-01-12 15:29:56 +00:00
"",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_D_v6p] = {"not", "not.d",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_double, ev_invalid, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add support for doubles to Ruamoko Only as scalars, I still need to think about what to do for vectors and quaternions due to param size issues. Also, doubles are not yet guaranteed to be correctly aligned.
2020-02-14 07:38:37 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_F_v6p] = {"not", "not.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_invalid, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_V_v6p] = {"not", "not.v",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_vector, ev_invalid, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_Q_v6p] = {"not", "not.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_invalid, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
engine side quaternion support
2004-04-08 00:56:30 +00:00
"%Ga, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_S_v6p] = {"not", "not.s",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_string, ev_invalid, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_ENT_v6p] = {"not", "not.ent",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_entity, ev_invalid, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_FN_v6p] = {"not", "not.fn",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_func, ev_invalid, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_P_v6p] = {"not", "not.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_invalid, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Fix a few missed opcode renames if and ifnot became ifnz and ifz, and return_v lost its tail (it was always redundant, except in dags, and that's fixed with a pointer check).
2022-01-20 03:41:01 +00:00
[OP_IF_v6p] = {"ifnz", "if",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_short, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga branch %sb (%Ob)",
},
[gamecode] Fix a few missed opcode renames if and ifnot became ifnz and ifz, and return_v lost its tail (it was always redundant, except in dags, and that's fixed with a pointer check).
2022-01-20 03:41:01 +00:00
[OP_IFNOT_v6p] = {"ifz", "ifnot",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_short, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga branch %sb (%Ob)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_IFBE_v6p] = {"ifbe", "ifbe",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_short, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga branch %sb (%Ob)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_IFB_v6p] = {"ifb", "ifb",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_short, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga branch %sb (%Ob)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_IFAE_v6p] = {"ifae", "ifae",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_short, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga branch %sb (%Ob)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_IFA_v6p] = {"ifa", "ifa",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_short, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga branch %sb (%Ob)",
},
move the full info opcocde table from qfcc to gamecode (<KURGON>There can be only one!</KURGON>:) and use the table in PR_PrintStatement. This means that qfcc now links against libQFgamecode as well as libQFutil
2001-07-14 02:34:16 +00:00
// calls returns REG_RETURN
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL0_v6p] = {"call0", "call0",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa ()",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL1_v6p] = {"call1", "call1",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0x)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL2_v6p] = {"call2", "call2",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0x, %P1x)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL3_v6p] = {"call3", "call3",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0x, %P1x, %P2x)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL4_v6p] = {"call4", "call4",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0x, %P1x, %P2x, %P3x)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL5_v6p] = {"call5", "call5",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0x, %P1x, %P2x, %P3x, %P4x)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL6_v6p] = {"call6", "call6",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL7_v6p] = {"call7", "call7",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_CALL8_v6p] = {"call8", "call8",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL0_v6p] = {"rcall0", 0,
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
ev_invalid, ev_invalid, ev_invalid,
~0, // not a valid instruction
0,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL1_v6p] = {"rcall1", "rcall1",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_func, ev_void, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0b)",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL2_v6p] = {"rcall2", "rcall2",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
ev_func, ev_void, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0b, %P1c)",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL3_v6p] = {"rcall3", "rcall3",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
ev_func, ev_void, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0b, %P1c, %P2x)",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL4_v6p] = {"rcall4", "rcall4",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
ev_func, ev_void, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0b, %P1c, %P2x, %P3x)",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL5_v6p] = {"rcall5", "rcall5",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
ev_func, ev_void, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0b, %P1c, %P2x, %P3x, %P4x)",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL6_v6p] = {"rcall6", "rcall6",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
ev_func, ev_void, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x)",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL7_v6p] = {"rcall7", "rcall7",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
ev_func, ev_void, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x)",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_RCALL8_v6p] = {"rcall8", "rcall8",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
ev_func, ev_void, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
for pr_debug 1, don't dump disassembly when tracing, just source lines. pr_debug >= 2 forces disassembly. detailed disassembly now on pr_debug >= 3 figure out the types of arguments in a function call
2007-04-09 06:16:03 +00:00
"%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)",
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
},
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STATE_v6p] = {"state", "state",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_float, ev_func, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"%Ga, %Gb",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_STATE_F_v6p] = {"state", "state.f",
new opcode: state.f. same as state, but takes a 3rd float operand to specify the step for calculating nextthink. accessed using [frame, think, step] (state is [frame, think])
2004-02-11 01:43:33 +00:00
ev_float, ev_func, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
new opcode: state.f. same as state, but takes a 3rd float operand to specify the step for calculating nextthink. accessed using [frame, think, step] (state is [frame, think])
2004-02-11 01:43:33 +00:00
"%Ga, %Gb, %Gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GOTO_v6p] = {"jump", "goto",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_short, ev_invalid, ev_invalid,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
"branch %sa (%Oa)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_JUMP_v6p] = {"jump", "jump",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga",
},
[qfcc] Change v6p's jumpb opname to jump More ease of searching, since the operand types help greatly.
2022-01-30 13:39:21 +00:00
[OP_JUMPB_v6p] = {"jump", "jump",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_void, ev_int, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
"%Ga[%Gb]",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_AND_v6p] = {"and", "and.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_float, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_OR_v6p] = {"or", "or.f",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_float, ev_float, ev_int,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SHL_F_v6p] = {"shl", "shl.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SHR_F_v6p] = {"shr", "shr.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SHL_I_v6p] = {"shl", "shl.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SHR_I_v6p] = {"shr", "shr.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SHR_U_v6p] = {"shr", "shr.u",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_uint, ev_int, ev_uint,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_BITAND_v6p] = {"bitand", "bitand.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_BITOR_v6p] = {"bitor", "bitor.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
PROG_ID_VERSION,
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_ADD_I_v6p] = {"add", "add.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_SUB_I_v6p] = {"sub", "sub.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MUL_I_v6p] = {"mul", "mul.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_DIV_I_v6p] = {"div", "div.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_REM_I_v6p] = {"rem", "rem.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MOD_I_v6p] = {"mod", "mod.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Implement true modulo in the engine
2020-02-16 02:53:56 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_BITAND_I_v6p] = {"bitand", "bitand.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_BITOR_I_v6p] = {"bitor", "bitor.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_REM_F_v6p] = {"rem", "rem.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MOD_F_v6p] = {"mod", "mod.f",
Implement true modulo in the engine
2020-02-16 02:53:56 +00:00
ev_float, ev_float, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Implement true modulo in the engine
2020-02-16 02:53:56 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GE_I_v6p] = {"ge", "ge.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LE_I_v6p] = {"le", "le.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GT_I_v6p] = {"gt", "gt.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LT_I_v6p] = {"lt", "lt.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_AND_I_v6p] = {"and", "and.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_OR_I_v6p] = {"or", "or.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NOT_I_v6p] = {"not", "not.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_invalid, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_I_v6p] = {"eq", "eq.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NE_I_v6p] = {"ne", "ne.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GE_U_v6p] = {"ge", "ge.u",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_uint, ev_uint, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Bring back the unsigned type (PROGS version bump) This is only low-level support (the unsigned keyword still does not work), but sufficient to make switch statements using jump tables work.
2011-04-09 01:07:47 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LE_U_v6p] = {"le", "le.u",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_uint, ev_uint, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Bring back the unsigned type (PROGS version bump) This is only low-level support (the unsigned keyword still does not work), but sufficient to make switch statements using jump tables work.
2011-04-09 01:07:47 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GT_U_v6p] = {"gt", "gt.u",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_uint, ev_uint, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Bring back the unsigned type (PROGS version bump) This is only low-level support (the unsigned keyword still does not work), but sufficient to make switch statements using jump tables work.
2011-04-09 01:07:47 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LT_U_v6p] = {"lt", "lt.u",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_uint, ev_uint, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Bring back the unsigned type (PROGS version bump) This is only low-level support (the unsigned keyword still does not work), but sufficient to make switch statements using jump tables work.
2011-04-09 01:07:47 +00:00
},
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_BITXOR_F_v6p] = {"bitxor", "bitxor.f",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
ev_float, ev_float, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_BITNOT_F_v6p] = {"bitnot", "bitnot.f",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_float, ev_invalid, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_BITXOR_I_v6p] = {"bitxor", "bitxor.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_BITNOT_I_v6p] = {"bitnot", "bitnot.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_invalid, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
get some single source instruction formats right and handle empty paths properly
2003-08-05 17:27:47 +00:00
"%Ga, %gc",
get unsigned mostly working
2003-08-01 21:20:04 +00:00
},
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GE_P_v6p] = {"ge", "ge.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LE_P_v6p] = {"le", "le.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_GT_P_v6p] = {"gt", "gt.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_LT_P_v6p] = {"lt", "lt.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_EQ_P_v6p] = {"eq", "eq.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_NE_P_v6p] = {"ne", "ne.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_ptr, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MOVEI_v6p] = {"move", "movei",
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
ev_void, ev_short, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %sb, %gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MOVEP_v6p] = {"movep", "movep",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
debugging improvements. opcodes now sport an optional format specifier for printing their args (default is "%Ga, %Gb, %gc") and PR_ValueString will try to print what a pointer points to
2003-07-30 22:24:16 +00:00
"%Ga, %Gb, %Gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MOVEPI_v6p] = {"movep", "movepi",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Rework implementation of memset* The memset instructions now match the move* instructions other than the first operand (always int). Probably breaks much, but fixed in next few commits.
2020-03-13 08:50:57 +00:00
"%Ga, %sb, %Gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MEMSETI_v6p] = {"memset", "memseti",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_short, ev_void,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Rework implementation of memset* The memset instructions now match the move* instructions other than the first operand (always int). Probably breaks much, but fixed in next few commits.
2020-03-13 08:50:57 +00:00
"%Ga, %sb, %gc",
Add a movepi instruction to support indirect moves of fixed size.
2011-03-09 01:29:24 +00:00
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MEMSETP_v6p] = {"memsetp", "memsetp",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_int, ev_int, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Add memset instructions
2020-03-11 13:48:55 +00:00
"%Ga, %Gb, %Gc",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_MEMSETPI_v6p] = {"memsetp", "memsetpi",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_int, ev_short, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Rework implementation of memset* The memset instructions now match the move* instructions other than the first operand (always int). Probably breaks much, but fixed in next few commits.
2020-03-13 08:50:57 +00:00
"%Ga, %sb, %Gc",
[gamecode] Add memset instructions
2020-03-11 13:48:55 +00:00
},
two new instructions: move and movep: basicly memmove. qfcc support coming as soon as I get it working :)
2002-10-16 06:44:41 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_S_v6p] = {"push", "push.s",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_string, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_F_v6p] = {"push", "push.f",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_float, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_V_v6p] = {"push", "push.v",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_vector, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_ENT_v6p] = {"push", "push.ent",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_entity, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_FLD_v6p] = {"push", "push.fld",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_field, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_FN_v6p] = {"push", "push.fn",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_func, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_P_v6p] = {"push", "push.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_Q_v6p] = {"push", "push.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_I_v6p] = {"push", "push.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%Ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSH_D_v6p] = {"push", "push.d",
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
ev_double, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
"%Ga",
},
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_S_v6p] = {"push", "pushb.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_string,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_F_v6p] = {"push", "pushb.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_V_v6p] = {"push", "pushb.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_vector,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_ENT_v6p] = {"push", "pushb.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_entity,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_FLD_v6p] = {"push", "pushb.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_field,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_FN_v6p] = {"push", "pushb.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_func,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_P_v6p] = {"push", "pushb.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_Q_v6p] = {"push", "pushb.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_ptr, ev_int, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_I_v6p] = {"push", "pushb.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHB_D_v6p] = {"push", "pushb.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
"*(%Ga + %Gb)",
},
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_S_v6p] = {"push", "pushbi.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_string,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_F_v6p] = {"push", "pushbi.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_V_v6p] = {"push", "pushbi.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_vector,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_ENT_v6p] = {"push", "pushbi.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_entity,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_FLD_v6p] = {"push", "pushbi.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_field,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_FN_v6p] = {"push", "pushbi.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_func,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_P_v6p] = {"push", "pushbi.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_Q_v6p] = {"push", "pushbi.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_ptr, ev_short, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_I_v6p] = {"push", "pushbi.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_PUSHBI_D_v6p] = {"push", "pushbi.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
"*(%Ga + %sb)",
},
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_S_v6p] = {"pop", "pop.s",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_string, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_F_v6p] = {"pop", "pop.f",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_float, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_V_v6p] = {"pop", "pop.v",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_vector, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_ENT_v6p] = {"pop", "pop.ent",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_entity, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_FLD_v6p] = {"pop", "pop.fld",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_field, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_FN_v6p] = {"pop", "pop.fn",
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
ev_func, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_P_v6p] = {"pop", "pop.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_Q_v6p] = {"pop", "pop.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_quaternion, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_I_v6p] = {"pop", "pop.i",
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
ev_int, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"%ga",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POP_D_v6p] = {"pop", "pop.d",
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
ev_double, ev_invalid, ev_invalid,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
"%ga",
},
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_S_v6p] = {"pop", "popb.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_string,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_F_v6p] = {"pop", "popb.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_V_v6p] = {"pop", "popb.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_vector,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_ENT_v6p] = {"pop", "popb.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_entity,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_FLD_v6p] = {"pop", "popb.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_field,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_FN_v6p] = {"pop", "popb.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_func,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_P_v6p] = {"pop", "popb.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_Q_v6p] = {"pop", "popb.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_ptr, ev_int, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_I_v6p] = {"pop", "popb.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %Gb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPB_D_v6p] = {"pop", "popb.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_int, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
"*(%Ga + %Gb)",
},
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_S_v6p] = {"pop", "popbi.s",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_string,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_F_v6p] = {"pop", "popbi.f",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_float,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_V_v6p] = {"pop", "popbi.v",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_vector,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_ENT_v6p] = {"pop", "popbi.ent",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_entity,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_FLD_v6p] = {"pop", "popbi.fld",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_field,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_FN_v6p] = {"pop", "popbi.fn",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_func,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_P_v6p] = {"pop", "popbi.p",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_ptr,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_Q_v6p] = {"pop", "popbi.q",
[gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type.
2022-01-18 06:48:43 +00:00
ev_ptr, ev_short, ev_quaternion,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_I_v6p] = {"pop", "popbi.i",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_int,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
"*(%Ga + %sb)",
},
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
[OP_POPBI_D_v6p] = {"pop", "popbi.d",
[gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing.
2022-01-18 05:36:06 +00:00
ev_ptr, ev_short, ev_double,
[gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet)
2022-01-03 04:56:43 +00:00
PROG_V6P_VERSION,
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
"*(%Ga + %sb)",
},
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
implement comparisons and not for pointers
2002-01-30 21:20:12 +00:00
// end of table
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
[OP_MEMSETPI_v6p+1] = {0}, //XXX FIXME relies on OP_MEMSETPI_v6p being last
move the full info opcocde table from qfcc to gamecode (<KURGON>There can be only one!</KURGON>:) and use the table in PR_PrintStatement. This means that qfcc now links against libQFgamecode as well as libQFutil
2001-07-14 02:34:16 +00:00
};
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
const v6p_opcode_t *
PR_v6p_Opcode (pr_ushort_t opcode)
move the full info opcocde table from qfcc to gamecode (<KURGON>There can be only one!</KURGON>:) and use the table in PR_PrintStatement. This means that qfcc now links against libQFgamecode as well as libQFutil
2001-07-14 02:34:16 +00:00
{
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
size_t opcode_count = sizeof (pr_v6p_opcodes) / sizeof (pr_v6p_opcodes[0]);
if (opcode >= opcode_count - 1) {
[gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table.
2021-12-31 10:16:02 +00:00
return 0;
}
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
return &pr_v6p_opcodes[opcode];
move the full info opcocde table from qfcc to gamecode (<KURGON>There can be only one!</KURGON>:) and use the table in PR_PrintStatement. This means that qfcc now links against libQFgamecode as well as libQFutil
2001-07-14 02:34:16 +00:00
}
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
static inline void
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
check_branch (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, short offset)
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
{
make progs related code a little more consistent with its int type usage
2007-04-06 00:47:41 +00:00
pr_int_t address = st - pr->pr_statements;
Massive whitespace cleanup. Lots of trailing whitespace and otherwise blank lines.
2012-05-21 23:23:22 +00:00
fix a couple of branch offset bugs
2001-11-13 19:52:03 +00:00
address += offset;
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
if (address < 0 || (pr_uint_t) address >= pr->progs->statements.count)
search for `.self' before `self'
2002-05-18 00:49:16 +00:00
PR_Error (pr, "PR_Check_Opcodes: invalid branch (statement %ld: %s)",
various portability improvements
2001-11-18 23:40:01 +00:00
(long)(st - pr->pr_statements), op->opname);
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
}
Be a little leniant with vector param stores. qcc always used vector stores to load values into the function parameters, but if the location of the value is too close to the end of the global data block (the vector spans the end of the block), it would trigger the bounds check code. Thus, allow such instructions without a murmer, so long as it actually is a parameter write.
2011-08-16 03:10:05 +00:00
static int
is_vector_parameter_store (progs_t *pr, dstatement_t *st,
unsigned short operand)
{
int i;
[gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago).
2022-01-02 14:15:15 +00:00
if ((pr_opcode_v6p_e) st->op != OP_STORE_V_v6p)
Be a little leniant with vector param stores. qcc always used vector stores to load values into the function parameters, but if the location of the value is too close to the end of the global data block (the vector spans the end of the block), it would trigger the bounds check code. Thus, allow such instructions without a murmer, so long as it actually is a parameter write.
2011-08-16 03:10:05 +00:00
return 0;
if (operand != st->a)
return 0;
[gamecode] Rename MAX_PARMS to PR_MAXPARAMS
2022-01-23 05:17:25 +00:00
for (i = 0; i < PR_MAX_PARAMS; i++)
Be a little leniant with vector param stores. qcc always used vector stores to load values into the function parameters, but if the location of the value is too close to the end of the global data block (the vector spans the end of the block), it would trigger the bounds check code. Thus, allow such instructions without a murmer, so long as it actually is a parameter write.
2011-08-16 03:10:05 +00:00
if (st->b == pr->pr_params[i] - pr->pr_globals)
return 1;
return 0;
}
qccx (etc) "integer" autodetection. Check for usage of denormal floats and if found, either bail with a descriptive error message or give a mild warning that things will probably break. This avoids the possibility of things like RuneQuake getting "lucky" and doing real harm, and certainly avoids the segfaults.
2010-01-13 06:36:54 +00:00
#define ISDENORM(x) ((x) && !((x) & 0x7f800000))
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
static inline void
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
check_global (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, etype_t type,
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
unsigned short operand, int check_denorm)
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
{
clean up a fixme. this doesn't fix serplord's out-of-bounds problem, but that's because his qc compiler is doing weird stuff.
2002-02-11 19:36:36 +00:00
const char *msg;
Move to using an in-memory form of ddef_t This allows the VM to work with extended ddefs transparently. It seems to have uncovered a typedef alias relocation bug, though.
2020-02-22 13:33:44 +00:00
pr_def_t *def;
clean up a fixme. this doesn't fix serplord's out-of-bounds problem, but that's because his qc compiler is doing weird stuff.
2002-02-11 19:36:36 +00:00
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
switch (type) {
case ev_short:
break;
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
case ev_invalid:
clean up a fixme. this doesn't fix serplord's out-of-bounds problem, but that's because his qc compiler is doing weird stuff.
2002-02-11 19:36:36 +00:00
if (operand) {
Clean out some unnecessary types from the progs engine and clean up the mess. This is a nasty commit, sorry, but 99% of the commit is interdependent.
2011-01-09 10:41:24 +00:00
msg = "non-zero global index in invalid operand";
clean up a fixme. this doesn't fix serplord's out-of-bounds problem, but that's because his qc compiler is doing weird stuff.
2002-02-11 19:36:36 +00:00
goto error;
}
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
break;
default:
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
if (operand + (unsigned) pr_type_size[type]
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
> pr->progs->globals.count) {
if (operand >= pr->progs->globals.count
Be a little leniant with vector param stores. qcc always used vector stores to load values into the function parameters, but if the location of the value is too close to the end of the global data block (the vector spans the end of the block), it would trigger the bounds check code. Thus, allow such instructions without a murmer, so long as it actually is a parameter write.
2011-08-16 03:10:05 +00:00
|| !is_vector_parameter_store (pr, st, operand)) {
msg = "out of bounds global index";
goto error;
}
clean up a fixme. this doesn't fix serplord's out-of-bounds problem, but that's because his qc compiler is doing weird stuff.
2002-02-11 19:36:36 +00:00
}
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
if (type != ev_float || !check_denorm)
break;
if (!ISDENORM (G_INT (pr, operand))
|| G_UINT(pr, operand) == 0x80000000)
break;
if ((def = PR_GlobalAtOfs (pr, operand))
&& (def->type & ~DEF_SAVEGLOBAL) != ev_float) {
// FTEqcc uses store.f parameters of most types :/
break;
}
if (!pr->denorm_found) {
qccx (etc) "integer" autodetection. Check for usage of denormal floats and if found, either bail with a descriptive error message or give a mild warning that things will probably break. This avoids the possibility of things like RuneQuake getting "lucky" and doing real harm, and certainly avoids the segfaults.
2010-01-13 06:36:54 +00:00
pr->denorm_found = 1;
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
if (pr_boundscheck->int_val) {
qccx (etc) "integer" autodetection. Check for usage of denormal floats and if found, either bail with a descriptive error message or give a mild warning that things will probably break. This avoids the possibility of things like RuneQuake getting "lucky" and doing real harm, and certainly avoids the segfaults.
2010-01-13 06:36:54 +00:00
Sys_Printf ("DENORMAL floats detected, these progs might "
"not work. Good luck.\n");
return;
}
msg = "DENORMAL float detected. These progs are probably "
"using qccx arrays and integers. If just simple arrays "
"are being used, then they should work, but if "
[gamecode] Be more forgiving of unresolved builtins If the progs code never calls the functions, then there is no problem. Thus unresolved builtin references get pointed to the bad function builtin.
2021-07-26 04:35:35 +00:00
"internal.qc is used, they most definitely will NOT. To "
qccx (etc) "integer" autodetection. Check for usage of denormal floats and if found, either bail with a descriptive error message or give a mild warning that things will probably break. This avoids the possibility of things like RuneQuake getting "lucky" and doing real harm, and certainly avoids the segfaults.
2010-01-13 06:36:54 +00:00
"allow these progs to be used, set pr_boundscheck to 1.";
goto error;
}
immidiate indexed pointer access and some whitespace + reorg
2001-12-07 20:07:38 +00:00
break;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
}
clean up a fixme. this doesn't fix serplord's out-of-bounds problem, but that's because his qc compiler is doing weird stuff.
2002-02-11 19:36:36 +00:00
return;
error:
make printing of global contents in PR_PrintStatement optional so disassembly output is cleaner
2004-01-31 04:26:01 +00:00
PR_PrintStatement (pr, st, 0);
search for `.self' before `self'
2002-05-18 00:49:16 +00:00
PR_Error (pr, "PR_Check_Opcodes: %s (statement %ld: %s)", msg,
clean up a fixme. this doesn't fix serplord's out-of-bounds problem, but that's because his qc compiler is doing weird stuff.
2002-02-11 19:36:36 +00:00
(long)(st - pr->pr_statements), op->opname);
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
}
Resolve some inlining issues in recent gcc.
2011-05-04 00:31:18 +00:00
static void
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
check_global_size (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op,
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
unsigned short size, unsigned short operand)
{
const char *msg;
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
if (operand + size > pr->progs->globals.count) {
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
msg = "out of bounds global index";
goto error;
}
return;
error:
PR_PrintStatement (pr, st, 0);
PR_Error (pr, "PR_Check_Opcodes: %s (statement %ld: %s)", msg,
(long)(st - pr->pr_statements), op->opname);
}
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
int
[gamecode] Don't check v6p progs for Ruamoko progs It doesn't end well. For now, the Ruamoko check is just a stub, but I do plan on doing similar checks.
2022-01-21 11:31:49 +00:00
PR_Check_v6p_Opcodes (progs_t *pr)
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
{
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
const v6p_opcode_t *op;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
dstatement_t *st;
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
int state_ok = 0;
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
int pushpop_ok = 0;
make progs related code a little more consistent with its int type usage
2007-04-06 00:47:41 +00:00
pr_uint_t i;
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
[gamecode] Add double time state instructions This has been a long-held wishlist item, really, and I thought I might as well take the opportunity to add the instructions. The double versions of STATE require both the nextthink field and time global to be double (but they're not resolved properly yet: marked with "FIXME double time" comments). Also, the frame number for double time state is integer rather than float.
2022-01-16 10:32:47 +00:00
if (pr->globals.ftime && pr->globals.self && pr->fields.nextthink != -1
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
&& pr->fields.think != -1 && pr->fields.frame != -1) {
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
state_ok = 1;
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
}
if (pr->globals.stack) {
pushpop_ok = 1;
}
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
qccx (etc) "integer" autodetection. Check for usage of denormal floats and if found, either bail with a descriptive error message or give a mild warning that things will probably break. This avoids the possibility of things like RuneQuake getting "lucky" and doing real harm, and certainly avoids the segfaults.
2010-01-13 06:36:54 +00:00
//FIXME need to decide if I really want to always do static bounds checking
// the only problem is that it slows progs load a little, but it's the only
// way to check for qccx' evil
if (0 && !pr_boundscheck->int_val) {
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
for (i = 0, st = pr->pr_statements; i < pr->progs->statements.count;
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
st++, i++) {
[gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago).
2022-01-02 14:15:15 +00:00
pr_opcode_v6p_e st_op = st->op;
op = PR_v6p_Opcode (st_op);
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
if (!op) {
PR_Error (pr, "PR_Check_Opcodes: unknown opcode %d at "
[gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago).
2022-01-02 14:15:15 +00:00
"statement %ld", st_op,
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
(long)(st - pr->pr_statements));
}
[gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago).
2022-01-02 14:15:15 +00:00
if ((st_op == OP_STATE_v6p || st_op == OP_STATE_F_v6p)
&& !state_ok) {
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
PR_Error (pr, "PR_Check_Opcodes: %s used with missing fields "
"or globals", op->opname);
}
[gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
2022-01-20 00:26:01 +00:00
if ((strequal(op->name, "push") || strequal(op->name, "pop"))
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
&& !pushpop_ok) {
PR_Error (pr, "PR_Check_Opcodes: %s used with missing .stack "
"globals", op->opname);
}
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
}
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
} else {
[gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more).
2022-01-26 10:30:25 +00:00
for (i = 0, st = pr->pr_statements; i < pr->progs->statements.count;
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
st++, i++) {
[gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago).
2022-01-02 14:15:15 +00:00
pr_opcode_v6p_e st_op = st->op;
op = PR_v6p_Opcode (st_op);
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
if (!op) {
PR_Error (pr, "PR_Check_Opcodes: unknown opcode %d at "
[gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago).
2022-01-02 14:15:15 +00:00
"statement %ld", st_op,
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
(long)(st - pr->pr_statements));
}
[gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago).
2022-01-02 14:15:15 +00:00
switch (st_op) {
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_IF_v6p:
case OP_IFNOT_v6p:
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
check_global (pr, st, op, op->type_a, st->a, 1);
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
check_branch (pr, st, op, st->b);
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_GOTO_v6p:
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
check_branch (pr, st, op, st->a);
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_DONE_v6p:
case OP_RETURN_v6p:
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
check_global (pr, st, op, ev_int, st->a, 1);
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
check_global (pr, st, op, ev_void, st->b, 0);
check_global (pr, st, op, ev_void, st->c, 0);
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_RCALL1_v6p:
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
check_global (pr, st, op, ev_void, st->c, 1);
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_RCALL2_v6p:
case OP_RCALL3_v6p:
case OP_RCALL4_v6p:
case OP_RCALL5_v6p:
case OP_RCALL6_v6p:
case OP_RCALL7_v6p:
case OP_RCALL8_v6p:
[gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago).
2022-01-02 14:15:15 +00:00
if (st_op > OP_RCALL1_v6p)
[gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types.
2022-01-18 04:21:06 +00:00
check_global (pr, st, op, ev_int, st->c, 1);
check_global (pr, st, op, ev_int, st->b, 1);
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
check_global (pr, st, op, ev_func, st->a, 1);
implement Raven's calling convention (rcall: first 2 params in opb and opc). should give a general speedup to most progs.
2005-06-12 09:54:01 +00:00
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_STATE_v6p:
case OP_STATE_F_v6p:
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
if (!state_ok) {
PR_Error (pr, "PR_Check_Opcodes: %s used with missing "
"fields or globals", op->opname);
}
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
check_global (pr, st, op, op->type_a, st->a, 1);
check_global (pr, st, op, op->type_b, st->b, 1);
check_global (pr, st, op, op->type_c, st->c, 1);
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_MOVEI_v6p:
implement bounds checking on all opcodes
2010-01-13 06:19:50 +00:00
check_global_size (pr, st, op, st->b, st->a);
check_global_size (pr, st, op, st->b, st->c);
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_MEMSETI_v6p:
[gamecode] Rework implementation of memset* The memset instructions now match the move* instructions other than the first operand (always int). Probably breaks much, but fixed in next few commits.
2020-03-13 08:50:57 +00:00
check_global_size (pr, st, op, st->b, st->c);
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_PUSHB_F_v6p:
case OP_PUSHB_S_v6p:
case OP_PUSHB_ENT_v6p:
case OP_PUSHB_FLD_v6p:
case OP_PUSHB_FN_v6p:
case OP_PUSHB_I_v6p:
case OP_PUSHB_P_v6p:
case OP_PUSHB_V_v6p:
case OP_PUSHB_Q_v6p:
case OP_PUSHBI_F_v6p:
case OP_PUSHBI_S_v6p:
case OP_PUSHBI_ENT_v6p:
case OP_PUSHBI_FLD_v6p:
case OP_PUSHBI_FN_v6p:
case OP_PUSHBI_I_v6p:
case OP_PUSHBI_P_v6p:
case OP_PUSHBI_V_v6p:
case OP_PUSHBI_Q_v6p:
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
// op->type_c is used for selecting the operator during
// compilation, but is invalid when running
check_global (pr, st, op, op->type_a, st->a, 1);
check_global (pr, st, op, op->type_b, st->b, 1);
check_global (pr, st, op, ev_invalid, st->c, 1);
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_POP_F_v6p:
case OP_POP_FLD_v6p:
case OP_POP_ENT_v6p:
case OP_POP_S_v6p:
case OP_POP_FN_v6p:
case OP_POP_I_v6p:
case OP_POP_P_v6p:
case OP_POP_V_v6p:
case OP_POP_Q_v6p:
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
// don't want to check for denormal floats, otherwise
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
// OP_POP__v6p* could use the defualt rule
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
check_global (pr, st, op, op->type_a, st->a, 0);
check_global (pr, st, op, ev_invalid, st->b, 1);
check_global (pr, st, op, ev_invalid, st->c, 1);
break;
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
case OP_POPB_F_v6p:
case OP_POPB_S_v6p:
case OP_POPB_ENT_v6p:
case OP_POPB_FLD_v6p:
case OP_POPB_FN_v6p:
case OP_POPB_I_v6p:
case OP_POPB_P_v6p:
case OP_POPB_V_v6p:
case OP_POPB_Q_v6p:
case OP_POPBI_F_v6p:
case OP_POPBI_S_v6p:
case OP_POPBI_ENT_v6p:
case OP_POPBI_FLD_v6p:
case OP_POPBI_FN_v6p:
case OP_POPBI_I_v6p:
case OP_POPBI_P_v6p:
case OP_POPBI_V_v6p:
case OP_POPBI_Q_v6p:
Add a stack and push and pop instructions. The stack is for data, not return addresses.
2018-10-11 04:24:03 +00:00
// op->type_c is used for selecting the operator during
// compilation, but is invalid when running
check_global (pr, st, op, op->type_a, st->a, 1);
check_global (pr, st, op, op->type_b, st->b, 1);
check_global (pr, st, op, ev_invalid, st->c, 1);
break;
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
default:
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
check_global (pr, st, op, op->type_a, st->a, 1);
check_global (pr, st, op, op->type_b, st->b,
[gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions.
2022-01-02 12:06:14 +00:00
(op - pr_v6p_opcodes) != OP_STORE_F_v6p);
Don't require pr_boundscheck for quoth. I don't know about other FTEqcc compiled progs, but quoth doesn't try to do anything clever (all its denormals are either vars of the wrong type, or -0.0).
2010-11-20 05:12:40 +00:00
check_global (pr, st, op, op->type_c, st->c, 0);
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
break;
}
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
}
}
PF_VarString return a plain char * and make it easier to add "at load" init functions
2003-11-20 07:46:56 +00:00
return 1;
pr_comp.h: - new opcodes for pointers progs.h: - prototype PR_Check_Opcodes pr_edict.c: - move the static bounds checking to PR_Check_Opcodes in pr_opcode.c pr_exec.c: - vector instruction cleanup - temporarily nuke bounds checking from storep.* - move base of address results from pr->edicts to pr->pr_globals - implement new pointer related instructions - nuke proposed global pointer instructions (not flexible enough) pr_opcode.c: - add new pointer instuctions - re-implement static bounds/invalid opcode checking. no more multiple case statements to keep track of.
2001-11-02 22:41:11 +00:00
}
Reference in a new issue Copy permalink