[Scummvm-cvs-logs] SF.net SVN: scummvm:[55001] tools/trunk/decompiler
pidgeot at users.sourceforge.net
pidgeot at users.sourceforge.net
Wed Dec 22 13:15:34 CET 2010
Revision: 55001
http://scummvm.svn.sourceforge.net/scummvm/?rev=55001&view=rev
Author: pidgeot
Date: 2010-12-22 12:15:33 +0000 (Wed, 22 Dec 2010)
Log Message:
-----------
DECOMPILER: Code cleanup
Removes _instFactory and uses class names directly
Reclassify a few opcodes in Kyra, remove now unnecessary checks
Modified Paths:
--------------
tools/trunk/decompiler/disassembler.cpp
tools/trunk/decompiler/disassembler.h
tools/trunk/decompiler/doc/codegen.tex
tools/trunk/decompiler/doc/disassembler.tex
tools/trunk/decompiler/doc/restrictions.tex
tools/trunk/decompiler/kyra/codegen.cpp
tools/trunk/decompiler/kyra/disassembler.cpp
tools/trunk/decompiler/kyra/engine.cpp
tools/trunk/decompiler/kyra/engine.h
tools/trunk/decompiler/scummv6/disassembler.cpp
tools/trunk/decompiler/simple_disassembler.h
tools/trunk/decompiler/test/disassembler/pasc.cpp
tools/trunk/decompiler/test/disassembler/subopcode.cpp
tools/trunk/decompiler/test/disassembler/subopcode.h
Modified: tools/trunk/decompiler/disassembler.cpp
===================================================================
--- tools/trunk/decompiler/disassembler.cpp 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/disassembler.cpp 2010-12-22 12:15:33 UTC (rev 55001)
@@ -24,13 +24,6 @@
Disassembler::Disassembler(InstVec &insts) : _insts(insts) {
_addressBase = 0;
- _instFactory.addEntry<BinaryOpStackInstruction>(kBinaryOpInst);
- _instFactory.addEntry<BoolNegateStackInstruction>(kBoolNegateInst);
- _instFactory.addEntry<DupStackInstruction>(kDupInst);
- _instFactory.addEntry<KernelCallStackInstruction>(kKernelCallInst);
- _instFactory.addEntry<ReturnInstruction>(kReturnInst);
- _instFactory.addEntry<UnaryOpPrefixStackInstruction>(kUnaryOpPreInst);
- _instFactory.addEntry<UnaryOpPostfixStackInstruction>(kUnaryOpPostInst);
}
void Disassembler::open(const char *filename) {
Modified: tools/trunk/decompiler/disassembler.h
===================================================================
--- tools/trunk/decompiler/disassembler.h 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/disassembler.h 2010-12-22 12:15:33 UTC (rev 55001)
@@ -39,7 +39,6 @@
Common::File _f; ///< Used to perform file I/O.
InstVec &_insts; ///< Container for disassembled instructions.
uint32 _addressBase; ///< Base address where the script starts.
- ObjectFactory<int, Instruction> _instFactory; ///< Factory for Instruction and subclasses
/**
* Performs disassembly.
Modified: tools/trunk/decompiler/doc/codegen.tex
===================================================================
--- tools/trunk/decompiler/doc/codegen.tex 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/doc/codegen.tex 2010-12-22 12:15:33 UTC (rev 55001)
@@ -86,21 +86,21 @@
\subsection{Default instruction handling and instruction metadata}
Default handling exists for a number of instruction types, described below. See also Section~\vref{sec:instructions} which discusses instructions in more detail.
-\paragraph{kDupInst}
+\paragraph{DupStackInstruction}
The topmost stack entry is popped, and two duplicated copies are pushed to the stack. If the entry being duplicated was not already a duplicate, an assignment will be output to assign the original stack entry to a special dup variable, to show that the original entry is not being recalculated.
-\paragraph{kUnaryOpPreInst/kUnaryOpPostInst}
+\paragraph{UnaryOpPrefixStackInstruction/UnaryOpPostfixStackInstruction}
The topmost stack entry is popped, and a \code{UnaryOpEntry} is created and pushed to the stack, using the codegen metadata as the operator, and the previously popped entry as the operand. The exact type determines whether the operator is pre- or postfixed to the operand.
-\paragraph{kBinaryOpInst}
+\paragraph{BinaryOpStackInstruction}
The two topmost stack entries are popped, and a BinaryOpEntry is created and pushed to the stack, using the codegen metadata as the operator and the previously popped entries as the operands. The order of the operands is determined by the value of the field \code{\_binOrder}, as described in Section~\vref{sec:argOrder}.
-\paragraph{kReturnInst}
+\paragraph{ReturnInstruction}
This simply adds a line \code{return;} to the output.
\emph{Note:} The default handling does not currently allow specifying a return value as part of the statement, as in \code{return 0;}. You will have to handle that yourself using a subclass.
-\paragraph{kKernelCallInst}
+\paragraph{KernelCallStackInstruction}
The metadata is treated similar to parameter specifications in \code{SimpleDisassembler} (see Section~\vref{sec:simpledisasm}). If the specification string starts with the character \code{r}, this signifies that the call returns a value, and processing starts at the next character.
For each character in the metadata string, \code{processSpecialMetadata} is called with the instruction being processed, and the current metadata character to be handled. The default implementation only understands the character \code{p}, which pops an argument from the stack and adds it to the argument list.
Once the metadata string has been processed fully, then an entry representing the function call is pushed to the stack if the call returns a value. Otherwise, the call is added to the output.
@@ -109,6 +109,9 @@
Due to the conflict with the specification of a return value, it is recommended that you do not adopt \code{r} as a metadata character unless you provide your own \code{processInst} implementation for this purpose.
+\paragraph{UncondJumpInstruction}
+Nothing is output, as this should already be handled by the generic code.
+
In addition, certain instruction types trigger additional generic behavior:
\paragraph{Conditional jumps}
After processing the conditional jump, an if, while or do-while condition is output using the topmost stack entry as the condition. The condition is automatically negated for if and while conditons, so you only need to consider what the instruction itself does. If the jump is taken when the checked condition is false (e.g. a \code{jumpFalse} instruction), you must remember to negate the value representing the condition.
@@ -119,11 +122,11 @@
\paragraph{Other types}
No default handling exists for types other than those mentioned above, so you must handle them yourself by creating new Instruction subclasses.
-Note that this also includes \code{kCallInst}. Although many engines might want to handle this in a manner similar to \code{kKernelCallInst} opcodes, this is left to the engine-specific code so they can fully make sense of the metadata they choose to add to the function.
+Note that this also includes \code{CallInstruction}. Although many engines might want to handle this in a manner similar to \code{KernelCallInstruction} opcodes, this is left to the engine-specific code so they can fully make sense of the metadata they choose to add to the function.
\subsection{Order of arguments}
\label{sec:argOrder}
-The generic handling of binary operators (kBinaryOpInst) and kernel functions (kKernelCallInst) can be configured to display their arguments using FIFO or LIFO - respectively, the first and the last entry to be pushed onto the stack is used as the first (leftmost) argument. This is set as part of the constructor for the \code{CodeGenerator} class, using the enumeration values \code{kFIFOArgOrder} and \code{kLIFOArgOrder}.
+The generic handling of binary operators (\code{BinaryOpStackInstruction}) and kernel functions (\code{KernelCallStackInstruction}) can be configured to display their arguments using FIFO or LIFO - respectively, the first and the last entry to be pushed onto the stack is used as the first (leftmost) argument. This is set as part of the constructor for the \code{CodeGenerator} class, using the enumeration values \code{kFIFOArgOrder} and \code{kLIFOArgOrder}.
To provide an example, consider the following sequence of instructions:
Modified: tools/trunk/decompiler/doc/disassembler.tex
===================================================================
--- tools/trunk/decompiler/doc/disassembler.tex 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/doc/disassembler.tex 2010-12-22 12:15:33 UTC (rev 55001)
@@ -51,46 +51,40 @@
This is particularly important during code flow analysis; since this part is completely engine-independent, the analysis must have some way of distinguishing the different types of instructions. For that purpose, a number of \code{is*} methods are defined which specify whether the instruction satisfies some specific purpose.
-Each of the predefined instruction types have a class associated with it to make it simpler to add functionality to a specific type of instructions, as specified in Table~\vref{tbl:insttypes}.
+Each of the predefined instruction types have a class associated with it to make it simpler to add functionality to a specific class of instructions, as specified in Table~\vref{tbl:insttypes}.
\begin{table}
\centering
-\begin{tabular}{|m{3.2cm}|m{5cm}|p{3.2cm}|}
+\begin{tabular}{|m{5cm}|p{3.2cm}|}
\hline
-\textbf{Type} & \textbf{Base class} & \textbf{Purpose} \\
+\textbf{Base class} & \textbf{Purpose} \\
\hline
-\code{kBinaryOpInst} & \code{BinaryOpInstruction} & Binary operations (+, *, ==, etc.) \\\hline
-\code{kBoolNegateInst} & \code{BoolNegateInstruction} & Boolean negation \\\hline
-\code{kCallInst} & \code{CallInstruction} & Script function call \\\hline
-\code{kCondJumpInst} & \code{CondJumpInstruction} & Conditional jumps \\\hline
-\code{kDupInst} & \code{DupInstruction} & Duplicate stack entry \\\hline
-\code{kJumpInst} & \code{UncondJumpInstruction} & Unconditional jumps \\\hline
-\code{kKernelCallInst} & \code{KernelCallInstruction} & Kernel function call \\\hline
-\code{kLoadInst} & \code{LoadInstruction} & Load from memory \\\hline
-\code{kReturnInst} & \code{ReturnInstruction} & Function return \\\hline
-\code{kStackInst} & \code{StackInstruction} & Stack allocation or deallocation \\\hline
-\code{kStoreInst} & \code{StoreInstruction} & Store to memory \\\hline
-\code{kUnaryOpPreInst} & \code{UnaryOpPrefixInstruction} & Unary operation, prefixed operator \\\hline
-\code{kUnaryOpPostInst} & \code{UnaryOpPostfixInstruction} & Unary operation, postfixed operator \\\hline
+\code{BinaryOpInstruction} & Binary operations (+, *, ==, etc.) \\\hline
+\code{BoolNegateInstruction} & Boolean negation \\\hline
+\code{CallInstruction} & Script function call \\\hline
+\code{CondJumpInstruction} & Conditional jumps \\\hline
+\code{DupInstruction} & Duplicate stack entry \\\hline
+\code{UncondJumpInstruction} & Unconditional jumps \\\hline
+\code{KernelCallInstruction} & Kernel function call \\\hline
+\code{LoadInstruction} & Load from memory \\\hline
+\code{ReturnInstruction} & Function return \\\hline
+\code{StackInstruction} & Stack allocation or deallocation \\\hline
+\code{StoreInstruction} & Store to memory \\\hline
+\code{UnaryOpPrefixInstruction} & Unary operation, prefixed operator \\\hline
+\code{UnaryOpPostfixInstruction} & Unary operation, postfixed operator \\\hline
\end{tabular}
\caption{Predefined instruction types}
\label{tbl:insttypes}
\end{table}
-Where deemed appropriate, some of the base classes contain a default implementation of \code{processInst}. You can create a new subclass for each of these types and override this method to change their functionality.
+For some of these, an extra type exists which contains a default implementation of \code{processInst}, assuming a sensible default implementation exists. The default implementations are found in \code{BinaryOpStackInstruction}, \code{BoolNegateStackInstruction}, \code{DupStackInstruction}, \code{KernelCallStackInstruction}, \code{ReturnInstruction}, \code{UnarayOpPrefixStackInstruction}, \code{UnaryOpPostfixStackInstruction}, \code{UncondJumpInstruction}. Most of these are targeted at stack-based engines, but if your engine doesn't work with these, you can always create your own class with your own implementation of \code{processInst}.
-\code{getDestAddress} is implemented on jump instructions to allow the generic code to find the target of a jump. You must create subclassses for your jump instructions which override this method.
+\code{getDestAddress} must be implemented on jump instructions to allow the generic code to find the target of a jump. You must create subclassses for your jump instructions which override this method.
-Most of the types are self-explanatory, with the possible exception of \code{kKernelCallInst}. \code{kKernelCallInst} should be used for "magic functions"--opcodes that perform some function specific to the engine, like playing a sound, drawing a graphic, or saving the game.
+Most of the types are self-explanatory, with the possible exception of \code{KernelCallInstruction}. \code{KernelCallInstruction} should be used for "magic functions"--opcodes that perform some function specific to the engine, like playing a sound, drawing a graphic, or saving the game.
-When disassembling, you will need to create an instance of the correct instruction type for each of your instructions. For this purpose, \code{Disassembler} defines a factory \code{\_instFactory} where you can register your classes with an integer key. To do this, call \code{\_instFactory.addEntry<Type>(key)} in the constructor for your Disassemlber, where \code{Type} is the name of the type to register, and \code{key} is an integer key. To create an instance of the appropriate type, simply call \code{\_instFactory.create} with your key.
-
In a few cases, you may not know which instruction type is correct. For example, in Kyra, the same opcode is used for unconditional jumps and script function calls, but the correct type depends on other instructions. You can handle this is by creating a new Instruction type which can work as both, depending on a flag you declare in your type, and set once you can correctly determine the type. Note that since \code{InstPtr} is not a raw pointer, you must first convert it to one before you can cast it to the pointer type of your choice. This can be done by calling \code{inst.get()}, where \code{inst} is your \code{InstPtr}.
-By default, only some of the instruction types are registered automatically; for other types, you will have to register your own classes since it is not possible to fully define them in a generic fashion. The pre-registered types are \code{kBinaryOpInst}, \code{kBoolNegateInst}, \code{kDupInst}, \code{kKernelCallInst}, \code{kReturnInst}, \code{kUnaryOpPreInst} and \code{kUnaryOpPostInst}, but you can substitute any or all of these by registering your own type with the same key.
-
-For some engines, you will need to go beyond the existing types to implement very special behavior. In those cases, simply define a \code{const int} and give it a value to be able to use this as a new key. Use the value \code{kFirstCustomInst} for your first custom instruction type, and continue from there for new keys, as this will prevent conflict with future instruction types.
-
When at all possible, you should inherit from one of the more specific types, rather than inheriting directly from \code{Instruction}.
\subsection{Parameters and values}
@@ -115,7 +109,6 @@
Common::File _f;
InstVec &_insts;
uint32 _addressBase;
- ObjectFactory<int, Instruction> _instFactory;
virtual void doDisassemble() throw(std::exception) = 0;
virtual void doDumpDisassembly(std::ostream &output);
@@ -137,8 +130,6 @@
\code{\_addressBase} is provided as a convenience if your engine does not consider the first instruction to be located at address 0. Assign the expected base address to this field, and make sure that the addresses you assign to the instructions are relative to this base address. This is mainly useful if your engine supports jumps or other references to absolute addresses in the script; if only relative addresses are used, the base address will not be relevant.
-\code{\_instFactory} is the factory used to create the appropriate Instruction subclasses. For details, see Section~\vref{sec:insttype}.
-
\code{doDisassemble} is the method used to perform the actual disassembly, so this method must be implemented by all disassemblers.
\code{disassemble} simply calls the \code{doDisassemble} method to perform the disassembly. The result is cached, so if this method is called twice, it won't perform disassembly again.
@@ -183,13 +174,13 @@
\end{lstlisting}
\end{C++}
-To define an opcode, use the \code{OPCODE} macro. This macro takes 5 parameters: the opcode value, the name of the instruction, the key associated with the specific type of instruction, the net effect on the stack, and a string describing the parameters that are part of the instruction. We will start by implementing the \code{POP} and \code{POP2} opcodes:
+To define an opcode, use the \code{OPCODE} macro. This macro takes 5 parameters: the opcode value, the name of the instruction, the name of the Instruction type to use, the net effect on the stack, and a string describing the parameters that are part of the instruction. We will start by implementing the \code{POP} and \code{POP2} opcodes:
\begin{C++}
\begin{lstlisting}
START_OPCODES;
- OPCODE(0x01, "POP", kStackInst, -1, "");
- OPCODE(0x03, "POP2", kStackInst, -2, "");
+ OPCODE(0x01, "POP", MyStackInstruction, -1, "");
+ OPCODE(0x03, "POP2", MyStackInstruction, -2, "");
END_OPCODES;
\end{lstlisting}
\end{C++}
@@ -254,11 +245,11 @@
\begin{C++}
\begin{lstlisting}
START_OPCODES;
- OPCODE(0x00, "PUSH", kStackInst, 1, "B");
- OPCODE(0x01, "POP", kStackInst, -1, "");
- OPCODE(0x02, "PUSH", kStackInst, 1, "w");
- OPCODE(0x03, "POP2", kStackInst, -2, "");
- OPCODE(0x80, "PRINT", kKernelCallInst, 0, "c");
+ OPCODE(0x00, "PUSH", MyStackInstruction, 1, "B");
+ OPCODE(0x01, "POP", MyStackInstruction, -1, "");
+ OPCODE(0x02, "PUSH", MyStackInstruction, 1, "w");
+ OPCODE(0x03, "POP2", MyStackInstruction, -2, "");
+ OPCODE(0x80, "PRINT", KernelCallStackInstruction, 0, "c");
END_OPCODES;
\end{lstlisting}
\end{C++}
@@ -273,13 +264,13 @@
\begin{C++}
\begin{lstlisting}
START_OPCODES;
- OPCODE(0x00, "PUSH", kStackInst, 1, "B");
- OPCODE(0x01, "POP", kStackInst, -1, "");
- OPCODE(0x02, "PUSH", kStackInst, 1, "w");
- OPCODE(0x03, "POP2", kStackInst, -2, "");
- OPCODE(0x80, "PRINT", kKernelCallInst, 0, "c");
+ OPCODE(0x00, "PUSH", MyStackInstruction, 1, "B");
+ OPCODE(0x01, "POP", MyStackInstruction, -1, "");
+ OPCODE(0x02, "PUSH", MyStackInstruction, 1, "w");
+ OPCODE(0x03, "POP2", MyStackInstruction, -2, "");
+ OPCODE(0x80, "PRINT", KernelCallStackInstruction, 0, "c");
START_SUBOPCODE(0xFF);
- OPCODE(0x00, "HALT", kKernelCallInst, 0, "");
+ OPCODE(0x00, "HALT", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
END_OPCODES;
\end{lstlisting}
@@ -299,7 +290,7 @@
\begin{C++}
\begin{lstlisting}
START_OPCODES;
- OPCODE_MD(0x14, "add", kBinaryOpInst, -1, "", "+");
+ OPCODE_MD(0x14, "add", BinaryOpStackInstruction, -1, "", "+");
END_OPCODES;
\end{lstlisting}
\end{C++}
Modified: tools/trunk/decompiler/doc/restrictions.tex
===================================================================
--- tools/trunk/decompiler/doc/restrictions.tex 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/doc/restrictions.tex 2010-12-22 12:15:33 UTC (rev 55001)
@@ -7,4 +7,6 @@
\subsection{KYRA2}
The decompiler has only been tested with English scripts (.EMC files) from the Kyra 2 demo. It is possible that some scripts from the full version misbehave somehow; as I do not own the game, I cannot be sure of this.
+The setRetAndJmp opcode is not currently handled since I don't have any examples of it.
+
Only "regular" scripts are supported; animation scripts are not supported. It looks like the file names of animation scripts all start with either \_Z or \_IDL, but this is not necessarily an exhaustive list.
Modified: tools/trunk/decompiler/kyra/codegen.cpp
===================================================================
--- tools/trunk/decompiler/kyra/codegen.cpp 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/kyra/codegen.cpp 2010-12-22 12:15:33 UTC (rev 55001)
@@ -38,7 +38,7 @@
const InstPtr Kyra::Kyra2CodeGenerator::findFirstCall() {
ConstInstIterator it = _curGroup->_start;
do {
- if ((*it)->isFuncCall() || ((*it)->isKernelCall() && (*it)->_opcode == 14))
+ if ((*it)->isFuncCall() || (*it)->isKernelCall())
return *it;
} while (it++ != _curGroup->_end);
@@ -48,7 +48,7 @@
const InstPtr Kyra::Kyra2CodeGenerator::findLastCall() {
ConstInstIterator it = _curGroup->_end;
do {
- if ((*it)->isFuncCall() || ((*it)->isKernelCall() && (*it)->_opcode == 14))
+ if ((*it)->isFuncCall() || (*it)->isKernelCall())
return *it;
} while (it-- != _curGroup->_start);
Modified: tools/trunk/decompiler/kyra/disassembler.cpp
===================================================================
--- tools/trunk/decompiler/kyra/disassembler.cpp 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/kyra/disassembler.cpp 2010-12-22 12:15:33 UTC (rev 55001)
@@ -265,12 +265,6 @@
Kyra::Kyra2Disassembler::Kyra2Disassembler(Kyra2Engine *engine, InstVec &insts) : Disassembler(insts), _engine(engine) {
setupKyra2Funcs();
- _instFactory.addEntry<Kyra2CondJumpInstruction>(kCondJumpInst);
- _instFactory.addEntry<Kyra2UncondJumpInstruction>(kJumpInst);
- _instFactory.addEntry<Kyra2KernelCallInstruction>(kKernelCallInst);
- _instFactory.addEntry<Kyra2LoadInstruction>(kLoadInst);
- _instFactory.addEntry<Kyra2StackInstruction>(kStackInst);
- _instFactory.addEntry<Kyra2StoreInstruction>(kStoreInst);
}
Kyra::Kyra2Disassembler::~Kyra2Disassembler() {
@@ -393,10 +387,10 @@
parameter = 0;
}
-#define ADD_INST(category) _insts.push_back(_instFactory.create(category));
+#define ADD_INST(type) _insts.push_back(new type());
#define LAST_INST (_insts.back())
-#define OPCODE_MD(name, category, stackChange, hasParam, isSigned, isAddress, codeGenData) \
- ADD_INST(category); \
+#define OPCODE_MD(name, type, stackChange, hasParam, isSigned, isAddress, codeGenData) \
+ ADD_INST(type); \
LAST_INST->_opcode = opcode; \
LAST_INST->_address = address; \
LAST_INST->_stackChange = stackChange; \
@@ -413,23 +407,23 @@
} \
LAST_INST->_params.push_back(p);\
}
-#define OPCODE(name, category, stackChange, hasParam, isSigned, isAddress) OPCODE_MD(name, category, stackChange, hasParam, isSigned, isAddress, "");
+#define OPCODE(name, type, stackChange, hasParam, isSigned, isAddress) OPCODE_MD(name, type, stackChange, hasParam, isSigned, isAddress, "");
switch(opcode) {
case 0:
parameter *= 2;
if (parameter < minFuncAddr)
jumpTargets.insert(_insts.size());
- OPCODE("jumpTo", kJumpInst, 0, true, false, true);
+ OPCODE("jumpTo", Kyra2UncondJumpInstruction, 0, true, false, true);
break;
case 1:
- OPCODE("setRetValue", kStoreInst, 0, true, true, false);
+ OPCODE("setRetValue", Kyra2StoreInstruction, 0, true, true, false);
break;
case 2:
if (parameter == 0) {
- OPCODE("pushRet", kLoadInst, 1, false, false, false);
+ OPCODE("pushRet", Kyra2LoadInstruction, 1, false, false, false);
} else if (parameter == 1) {
- OPCODE("pushPos", kKernelCallInst, 0, false, false, false); // Sets up function call
+ OPCODE("pushPos", Kyra2NoOutputInstruction, 0, false, false, false); // Sets up function call
} else {
// Error: invalid parameter halts execution
throw UnknownOpcodeException(address, opcode);
@@ -437,41 +431,41 @@
break;
case 3:
case 4:
- OPCODE("push", kLoadInst, 1, true, true, false);
+ OPCODE("push", Kyra2LoadInstruction, 1, true, true, false);
break;
case 5:
- OPCODE("pushVar", kLoadInst, 1, true, true, false);
+ OPCODE("pushVar", Kyra2LoadInstruction, 1, true, true, false);
break;
case 6:
- OPCODE("pushBPNeg", kLoadInst, 1, true, true, false);
+ OPCODE("pushBPNeg", Kyra2LoadInstruction, 1, true, true, false);
break;
case 7:
- OPCODE("pushBPAdd", kLoadInst, 1, true, true, false);
+ OPCODE("pushBPAdd", Kyra2LoadInstruction, 1, true, true, false);
break;
case 8:
if (parameter == 0) {
- OPCODE("popRet", kStoreInst, -1, false, false, false);
+ OPCODE("popRet", Kyra2StoreInstruction, -1, false, false, false);
} else if (parameter == 1) {
- OPCODE("popPos", kReturnInst, 0, false, false, false); // Returns from function call
+ OPCODE("popPos", ReturnInstruction, 0, false, false, false); // Returns from function call
} else {
// Error: invalid parameter halts execution
throw UnknownOpcodeException(address, opcode);
}
break;
case 9:
- OPCODE("popVar", kStoreInst, -1, true, true, false);
+ OPCODE("popVar", Kyra2StoreInstruction, -1, true, true, false);
break;
case 10:
- OPCODE("popBPNeg", kStoreInst, -1, true, true, false);
+ OPCODE("popBPNeg", Kyra2StoreInstruction, -1, true, true, false);
break;
case 11:
- OPCODE("popBPAdd", kStoreInst, -1, true, true, false);
+ OPCODE("popBPAdd", Kyra2StoreInstruction, -1, true, true, false);
break;
case 12:
- OPCODE("addSP", kStackInst, -parameter, true, true, false);
+ OPCODE("addSP", Kyra2StackInstruction, -parameter, true, true, false);
break;
case 13:
- OPCODE("subSP", kStackInst, parameter, true, true, false);
+ OPCODE("subSP", Kyra2StackInstruction, parameter, true, true, false);
break;
case 14:
parameter = (uint8)parameter;
@@ -479,21 +473,21 @@
// Error: unknown function
throw UnknownOpcodeException(address, opcode);
}
- OPCODE_MD(_funcs[parameter]._name, kKernelCallInst, 0, false, false, false, _funcs[parameter]._metadata)
+ OPCODE_MD(_funcs[parameter]._name, Kyra2KernelCallInstruction, 0, false, false, false, _funcs[parameter]._metadata)
break;
case 15:
parameter *= 2;
if (parameter < minFuncAddr)
jumpTargets.insert(_insts.size());
- OPCODE("ifNotJmp", kCondJumpInst, -1, true, false, true);
+ OPCODE("ifNotJmp", Kyra2CondJumpInstruction, -1, true, false, true);
break;
case 16:
if (parameter == 0) {
- OPCODE("boolNegate", kBoolNegateInst, 0, false, false, false);
+ OPCODE("boolNegate", BoolNegateStackInstruction, 0, false, false, false);
} else if (parameter == 1) {
- OPCODE_MD("arithmeticNegate", kUnaryOpPreInst, 0, false, false, false,"-");
+ OPCODE_MD("arithmeticNegate", UnaryOpPrefixStackInstruction, 0, false, false, false,"-");
} else if (parameter == 2) {
- OPCODE_MD("bitwiseNegate", kUnaryOpPreInst, 0, false, false, false, "~");
+ OPCODE_MD("bitwiseNegate", UnaryOpPrefixStackInstruction, 0, false, false, false, "~");
} else {
// Error: invalid parameter halts execution
throw UnknownOpcodeException(address, opcode);
@@ -502,58 +496,58 @@
case 17:
switch (parameter) {
case 0:
- OPCODE_MD("eval_band", kBinaryOpInst, -1, false, false, false, "&&");
+ OPCODE_MD("eval_band", BinaryOpStackInstruction, -1, false, false, false, "&&");
break;
case 1:
- OPCODE_MD("eval_bor", kBinaryOpInst, -1, false, false, false, "||");
+ OPCODE_MD("eval_bor", BinaryOpStackInstruction, -1, false, false, false, "||");
break;
case 2:
- OPCODE_MD("eval_eq", kBinaryOpInst, -1, false, false, false, "==");
+ OPCODE_MD("eval_eq", BinaryOpStackInstruction, -1, false, false, false, "==");
break;
case 3:
- OPCODE_MD("eval_neq", kBinaryOpInst, -1, false, false, false, "!=");
+ OPCODE_MD("eval_neq", BinaryOpStackInstruction, -1, false, false, false, "!=");
break;
case 4:
- OPCODE_MD("eval_leq", kBinaryOpInst, -1, false, false, false, "<=");
+ OPCODE_MD("eval_leq", BinaryOpStackInstruction, -1, false, false, false, "<=");
break;
case 5:
- OPCODE_MD("eval_lt", kBinaryOpInst, -1, false, false, false, "<");
+ OPCODE_MD("eval_lt", BinaryOpStackInstruction, -1, false, false, false, "<");
break;
case 6:
- OPCODE_MD("eval_geq", kBinaryOpInst, -1, false, false, false, ">=");
+ OPCODE_MD("eval_geq", BinaryOpStackInstruction, -1, false, false, false, ">=");
break;
case 7:
- OPCODE_MD("eval_gt", kBinaryOpInst, -1, false, false, false, ">");
+ OPCODE_MD("eval_gt", BinaryOpStackInstruction, -1, false, false, false, ">");
break;
case 8:
- OPCODE_MD("eval_add", kBinaryOpInst, -1, false, false, false, "+");
+ OPCODE_MD("eval_add", BinaryOpStackInstruction, -1, false, false, false, "+");
break;
case 9:
- OPCODE_MD("eval_sub", kBinaryOpInst, -1, false, false, false, "-");
+ OPCODE_MD("eval_sub", BinaryOpStackInstruction, -1, false, false, false, "-");
break;
case 10:
- OPCODE_MD("eval_mult", kBinaryOpInst, -1, false, false, false, "*");
+ OPCODE_MD("eval_mult", BinaryOpStackInstruction, -1, false, false, false, "*");
break;
case 11:
- OPCODE_MD("eval_div", kBinaryOpInst, -1, false, false, false, "/");
+ OPCODE_MD("eval_div", BinaryOpStackInstruction, -1, false, false, false, "/");
break;
case 12:
- OPCODE_MD("eval_shr", kBinaryOpInst, -1, false, false, false, ">>");
+ OPCODE_MD("eval_shr", BinaryOpStackInstruction, -1, false, false, false, ">>");
break;
case 13:
- OPCODE_MD("eval_shl", kBinaryOpInst, -1, false, false, false, "<<");
+ OPCODE_MD("eval_shl", BinaryOpStackInstruction, -1, false, false, false, "<<");
break;
case 14:
- OPCODE_MD("eval_land", kBinaryOpInst, -1, false, false, false, "&");
+ OPCODE_MD("eval_land", BinaryOpStackInstruction, -1, false, false, false, "&");
break;
case 15:
- OPCODE_MD("eval_lor", kBinaryOpInst, -1, false, false, false, "|");
+ OPCODE_MD("eval_lor", BinaryOpStackInstruction, -1, false, false, false, "|");
break;
case 16:
- OPCODE_MD("eval_mod", kBinaryOpInst, -1, false, false, false, "%");
+ OPCODE_MD("eval_mod", BinaryOpStackInstruction, -1, false, false, false, "%");
break;
case 17:
- OPCODE_MD("eval_xor", kBinaryOpInst, -1, false, false, false, "^");
+ OPCODE_MD("eval_xor", BinaryOpStackInstruction, -1, false, false, false, "^");
break;
default:
// Error: invalid parameter halts execution
@@ -562,7 +556,8 @@
}
break;
case 18:
- OPCODE("setRetAndJmp", kKernelCallInst, -2, false, false, false);
+ //We don't have any examples of this, so this is not handled yet.
+ OPCODE("setRetAndJmp", Kyra2NoOutputInstruction, -2, false, false, false);
break;
default:
throw UnknownOpcodeException(i * 2, code);
Modified: tools/trunk/decompiler/kyra/engine.cpp
===================================================================
--- tools/trunk/decompiler/kyra/engine.cpp 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/kyra/engine.cpp 2010-12-22 12:15:33 UTC (rev 55001)
@@ -202,8 +202,6 @@
void Kyra::Kyra2KernelCallInstruction::processInst(ValueStack &stack, Engine *engine, CodeGenerator *codeGen) {
Kyra2CodeGenerator *cg = (Kyra2CodeGenerator *)codeGen;
- if (_opcode != 14)
- return;
cg->_argList.clear();
bool returnsValue = (_codeGenData.find("r") == 0);
std::string metadata = (!returnsValue ? _codeGenData : _codeGenData.substr(1));
@@ -222,3 +220,6 @@
cg->writeAssignment(p, stack.pop());
}
}
+
+void Kyra::Kyra2NoOutputInstruction::processInst(ValueStack &stack, Engine *engine, CodeGenerator *codeGen) {
+}
Modified: tools/trunk/decompiler/kyra/engine.h
===================================================================
--- tools/trunk/decompiler/kyra/engine.h 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/kyra/engine.h 2010-12-22 12:15:33 UTC (rev 55001)
@@ -102,6 +102,14 @@
virtual void processInst(ValueStack &stack, Engine *engine, CodeGenerator *codeGen);
};
+/**
+ * Kyra2 instruction with no output.
+ */
+class Kyra2NoOutputInstruction : public Instruction {
+public:
+ virtual void processInst(ValueStack &stack, Engine *engine, CodeGenerator *codeGen);
+};
+
} // End of namespace Kyra
#endif
Modified: tools/trunk/decompiler/scummv6/disassembler.cpp
===================================================================
--- tools/trunk/decompiler/scummv6/disassembler.cpp 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/scummv6/disassembler.cpp 2010-12-22 12:15:33 UTC (rev 55001)
@@ -28,13 +28,6 @@
#include "disassembler.h"
Scumm::v6::Scummv6Disassembler::Scummv6Disassembler(InstVec &insts) : SimpleDisassembler(insts) {
- _instFactory.addEntry<Scummv6CondJumpInstruction>(kCondJumpInst);
- _instFactory.addEntry<Scummv6JumpInstruction>(kJumpInst);
- _instFactory.addEntry<Scummv6LoadInstruction>(kLoadInst);
- _instFactory.addEntry<Scummv6StackInstruction>(kStackInst);
- _instFactory.addEntry<Scummv6StoreInstruction>(kStoreInst);
- _instFactory.addEntry<Scummv6ArrayOpInstruction>(kArrayOpInst);
- _instFactory.addEntry<Scummv6IncDecInstruction>(kIncDecInst);
}
void Scumm::v6::Scummv6Disassembler::doDisassemble() throw(std::exception) {
@@ -70,114 +63,114 @@
}
START_OPCODES;
- OPCODE(0x00, "pushByte", kLoadInst, 1, "B");
- OPCODE(0x01, "pushWord", kLoadInst, 1, "s");
- OPCODE(0x02, "pushByteVar", kLoadInst, 1, "B");
- OPCODE(0x03, "pushWordVar", kLoadInst, 1, "w");
- OPCODE(0x06, "byteArrayRead", kLoadInst, 0, "B");
- OPCODE(0x07, "wordArrayRead", kLoadInst, 0, "w");
- OPCODE(0x0A, "byteArrayIndexedRead", kLoadInst, -1, "B");
- OPCODE(0x0B, "wordArrayIndexedRead", kLoadInst, -1, "w");
- OPCODE(0x0C, "dup", kDupInst, 1, "");
- OPCODE(0x0D, "not", kBoolNegateInst, 0, "");
- OPCODE_MD(0x0E, "eq", kBinaryOpInst, -1, "", "==");
- OPCODE_MD(0x0F, "neq", kBinaryOpInst, -1, "", "!=");
- OPCODE_MD(0x10, "gt", kBinaryOpInst, -1, "", ">");
- OPCODE_MD(0x11, "lt", kBinaryOpInst, -1, "", "<");
- OPCODE_MD(0x12, "le", kBinaryOpInst, -1, "", "<=");
- OPCODE_MD(0x13, "ge", kBinaryOpInst, -1, "", ">=");
- OPCODE_MD(0x14, "add", kBinaryOpInst, -1, "", "+");
- OPCODE_MD(0x15, "sub", kBinaryOpInst, -1, "", "-");
- OPCODE_MD(0x16, "mul", kBinaryOpInst, -1, "", "*");
- OPCODE_MD(0x17, "div", kBinaryOpInst, -1, "", "/");
- OPCODE_MD(0x18, "land", kBinaryOpInst, -1, "", "&&");
- OPCODE_MD(0x19, "lor", kBinaryOpInst, -1, "", "||");
- OPCODE(0x1A, "pop", kStackInst, -1, "");
- OPCODE(0x42, "writeByteVar", kStoreInst, -1, "B");
- OPCODE(0x43, "writeWordVar", kStoreInst, -1, "w");
- OPCODE(0x46, "byteArrayWrite", kStoreInst, -2, "B");
- OPCODE(0x47, "wordArrayWrite", kStoreInst, -2, "w");
- OPCODE(0x4A, "byteArrayIndexedWrite", kStoreInst, -3, "B");
- OPCODE(0x4B, "wordArrayIndexedWrite", kStoreInst, -3, "w");
- OPCODE_MD(0x4E, "byteVarInc", kIncDecInst, 0, "B", "++");
- OPCODE_MD(0x4F, "wordVarInc", kIncDecInst, 0, "w", "++");
- OPCODE_MD(0x52, "byteArrayInc", kIncDecInst, -1, "B", "++");
- OPCODE_MD(0x53, "wordArrayInc", kIncDecInst, -1, "w", "++");
- OPCODE_MD(0x56, "byteVarDec", kIncDecInst, 0, "B", "--");
- OPCODE_MD(0x57, "wordVarDec", kIncDecInst, 0, "w", "--");
- OPCODE_MD(0x5A, "byteArrayDec", kIncDecInst, -1, "B", "--");
- OPCODE_MD(0x5B, "wordArrayDec", kIncDecInst, -1, "w", "--");
- OPCODE(0x5C, "jumpTrue", kCondJumpInst, -1, "a");
- OPCODE(0x5D, "jumpFalse", kCondJumpInst, -1, "a");
- OPCODE_MD(0x5E, "startScript", kKernelCallInst, 0x1020, "", "lpp"); // Variable stack arguments
- OPCODE_MD(0x5F, "startScriptQuick", kKernelCallInst, 0x1010, "", "lp"); // Variable stack arguments
- OPCODE_MD(0x60, "startObject", kKernelCallInst, 0x1030, "", "lppp"); // Variable stack arguments
- OPCODE_MD(0x61, "drawObject", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x62, "drawObjectAt", kKernelCallInst, -3, "", "ppp");
- OPCODE_MD(0x63, "drawBlastObject", kKernelCallInst, -5, "", "ppppp");
- OPCODE_MD(0x64, "setBlastObjectWindow", kKernelCallInst, -4, "", "pppp");
- OPCODE(0x65, "stopObjectCodeA", kKernelCallInst, 0, "");
- OPCODE(0x66, "stopObjectCodeB", kKernelCallInst, 0, "");
- OPCODE(0x67, "endCutscene", kKernelCallInst, 0, "");
- OPCODE_MD(0x68, "beginCutscene", kKernelCallInst, 0x1000, "", "l"); // Variable stack arguments
- OPCODE(0x69, "stopMusic", kKernelCallInst, 0, "");
- OPCODE_MD(0x6A, "freezeUnfreeze", kKernelCallInst, -1, "", "p");
+ OPCODE(0x00, "pushByte", Scummv6LoadInstruction, 1, "B");
+ OPCODE(0x01, "pushWord", Scummv6LoadInstruction, 1, "s");
+ OPCODE(0x02, "pushByteVar", Scummv6LoadInstruction, 1, "B");
+ OPCODE(0x03, "pushWordVar", Scummv6LoadInstruction, 1, "w");
+ OPCODE(0x06, "byteArrayRead", Scummv6LoadInstruction, 0, "B");
+ OPCODE(0x07, "wordArrayRead", Scummv6LoadInstruction, 0, "w");
+ OPCODE(0x0A, "byteArrayIndexedRead", Scummv6LoadInstruction, -1, "B");
+ OPCODE(0x0B, "wordArrayIndexedRead", Scummv6LoadInstruction, -1, "w");
+ OPCODE(0x0C, "dup", DupStackInstruction, 1, "");
+ OPCODE(0x0D, "not", BoolNegateStackInstruction, 0, "");
+ OPCODE_MD(0x0E, "eq", BinaryOpStackInstruction, -1, "", "==");
+ OPCODE_MD(0x0F, "neq", BinaryOpStackInstruction, -1, "", "!=");
+ OPCODE_MD(0x10, "gt", BinaryOpStackInstruction, -1, "", ">");
+ OPCODE_MD(0x11, "lt", BinaryOpStackInstruction, -1, "", "<");
+ OPCODE_MD(0x12, "le", BinaryOpStackInstruction, -1, "", "<=");
+ OPCODE_MD(0x13, "ge", BinaryOpStackInstruction, -1, "", ">=");
+ OPCODE_MD(0x14, "add", BinaryOpStackInstruction, -1, "", "+");
+ OPCODE_MD(0x15, "sub", BinaryOpStackInstruction, -1, "", "-");
+ OPCODE_MD(0x16, "mul", BinaryOpStackInstruction, -1, "", "*");
+ OPCODE_MD(0x17, "div", BinaryOpStackInstruction, -1, "", "/");
+ OPCODE_MD(0x18, "land", BinaryOpStackInstruction, -1, "", "&&");
+ OPCODE_MD(0x19, "lor", BinaryOpStackInstruction, -1, "", "||");
+ OPCODE(0x1A, "pop", Scummv6StackInstruction, -1, "");
+ OPCODE(0x42, "writeByteVar", Scummv6StoreInstruction, -1, "B");
+ OPCODE(0x43, "writeWordVar", Scummv6StoreInstruction, -1, "w");
+ OPCODE(0x46, "byteArrayWrite", Scummv6StoreInstruction, -2, "B");
+ OPCODE(0x47, "wordArrayWrite", Scummv6StoreInstruction, -2, "w");
+ OPCODE(0x4A, "byteArrayIndexedWrite", Scummv6StoreInstruction, -3, "B");
+ OPCODE(0x4B, "wordArrayIndexedWrite", Scummv6StoreInstruction, -3, "w");
+ OPCODE_MD(0x4E, "byteVarInc", Scummv6IncDecInstruction, 0, "B", "++");
+ OPCODE_MD(0x4F, "wordVarInc", Scummv6IncDecInstruction, 0, "w", "++");
+ OPCODE_MD(0x52, "byteArrayInc", Scummv6IncDecInstruction, -1, "B", "++");
+ OPCODE_MD(0x53, "wordArrayInc", Scummv6IncDecInstruction, -1, "w", "++");
+ OPCODE_MD(0x56, "byteVarDec", Scummv6IncDecInstruction, 0, "B", "--");
+ OPCODE_MD(0x57, "wordVarDec", Scummv6IncDecInstruction, 0, "w", "--");
+ OPCODE_MD(0x5A, "byteArrayDec", Scummv6IncDecInstruction, -1, "B", "--");
+ OPCODE_MD(0x5B, "wordArrayDec", Scummv6IncDecInstruction, -1, "w", "--");
+ OPCODE(0x5C, "jumpTrue", Scummv6CondJumpInstruction, -1, "a");
+ OPCODE(0x5D, "jumpFalse", Scummv6CondJumpInstruction, -1, "a");
+ OPCODE_MD(0x5E, "startScript", KernelCallStackInstruction, 0x1020, "", "lpp"); // Variable stack arguments
+ OPCODE_MD(0x5F, "startScriptQuick", KernelCallStackInstruction, 0x1010, "", "lp"); // Variable stack arguments
+ OPCODE_MD(0x60, "startObject", KernelCallStackInstruction, 0x1030, "", "lppp"); // Variable stack arguments
+ OPCODE_MD(0x61, "drawObject", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x62, "drawObjectAt", KernelCallStackInstruction, -3, "", "ppp");
+ OPCODE_MD(0x63, "drawBlastObject", KernelCallStackInstruction, -5, "", "ppppp");
+ OPCODE_MD(0x64, "setBlastObjectWindow", KernelCallStackInstruction, -4, "", "pppp");
+ OPCODE(0x65, "stopObjectCodeA", KernelCallStackInstruction, 0, "");
+ OPCODE(0x66, "stopObjectCodeB", KernelCallStackInstruction, 0, "");
+ OPCODE(0x67, "endCutscene", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x68, "beginCutscene", KernelCallStackInstruction, 0x1000, "", "l"); // Variable stack arguments
+ OPCODE(0x69, "stopMusic", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x6A, "freezeUnfreeze", KernelCallStackInstruction, -1, "", "p");
START_SUBOPCODE_WITH_PREFIX(0x6B, "cursorCommand");
- OPCODE(0x90, "cursorOn", kKernelCallInst, 0, "");
- OPCODE(0x91, "cursorOff", kKernelCallInst, 0, "");
- OPCODE(0x92, "userputOn", kKernelCallInst, 0, "");
- OPCODE(0x93, "userputOff", kKernelCallInst, 0, "");
- OPCODE(0x94, "softCursorOn", kKernelCallInst, 0, "");
- OPCODE(0x95, "softCursorOff", kKernelCallInst, 0, "");
- OPCODE(0x96, "softUserputOn", kKernelCallInst, 0, "");
- OPCODE(0x97, "softUserputOff", kKernelCallInst, 0, "");
- OPCODE_MD(0x99, "setCursorImg", kKernelCallInst, -2, "", "z");
- OPCODE_MD(0x9A, "setCursorHotspot", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x9C, "initCharset", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x9D, "charsetColors", kKernelCallInst, 0x1000, "", "l"); // Variable stack arguments
- OPCODE_MD(0xD6, "setCursorTransparency", kKernelCallInst, -1, "", "p");
+ OPCODE(0x90, "cursorOn", KernelCallStackInstruction, 0, "");
+ OPCODE(0x91, "cursorOff", KernelCallStackInstruction, 0, "");
+ OPCODE(0x92, "userputOn", KernelCallStackInstruction, 0, "");
+ OPCODE(0x93, "userputOff", KernelCallStackInstruction, 0, "");
+ OPCODE(0x94, "softCursorOn", KernelCallStackInstruction, 0, "");
+ OPCODE(0x95, "softCursorOff", KernelCallStackInstruction, 0, "");
+ OPCODE(0x96, "softUserputOn", KernelCallStackInstruction, 0, "");
+ OPCODE(0x97, "softUserputOff", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x99, "setCursorImg", KernelCallStackInstruction, -2, "", "z");
+ OPCODE_MD(0x9A, "setCursorHotspot", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x9C, "initCharset", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x9D, "charsetColors", KernelCallStackInstruction, 0x1000, "", "l"); // Variable stack arguments
+ OPCODE_MD(0xD6, "setCursorTransparency", KernelCallStackInstruction, -1, "", "p");
END_SUBOPCODE;
- OPCODE(0x6C, "breakHere", kKernelCallInst, 0, "");
- OPCODE_MD(0x6D, "ifClassOfIs", kKernelCallInst, 0x1011, "", "rlp"); // Variable stack arguments
- OPCODE_MD(0x6E, "setClass", kKernelCallInst, 0x1010, "", "lp"); // Variable stack arguments
- OPCODE_MD(0x6F, "getState", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x70, "setState", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x71, "setOwner", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x72, "getOwner", kKernelCallInst, 0, "", "rp");
- OPCODE(0x73, "jump", kJumpInst, 0, "a");
- OPCODE_MD(0x74, "startSound", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x75, "stopSound", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x76, "startMusic", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x77, "stopObjectScript", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x78, "panCameraTo", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x79, "actorFollowCamera", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x7A, "setCameraAt", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x7B, "loadRoom", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x7C, "stopScript", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x7D, "walkActorToObj", kKernelCallInst, -3, "", "ppp");
- OPCODE_MD(0x7E, "walkActorTo", kKernelCallInst, -3, "", "ppp");
- OPCODE_MD(0x7F, "putActorAtXY", kKernelCallInst, -4, "", "pppp");
- OPCODE_MD(0x80, "putActorAtObject", kKernelCallInst, -3, "", "zp");
- OPCODE_MD(0x81, "faceActor", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x82, "animateActor", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x83, "doSentence", kKernelCallInst, -4, "", "pppp");
- OPCODE_MD(0x84, "pickupObject", kKernelCallInst, -2, "", "z");
- OPCODE_MD(0x85, "loadRoomWithEgo", kKernelCallInst, -4, "", "ppz");
- OPCODE_MD(0x87, "getRandomNumber", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x88, "getRandomNumberRange", kKernelCallInst, -1, "", "rpp");
- OPCODE_MD(0x8A, "getActorMoving", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x8B, "isScriptRunning", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x8C, "getActorRoom", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x8D, "getObjectX", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x8E, "getObjectY", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x8F, "getObjectDir", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x90, "getActorWalkBox", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x91, "getActorCostume", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x92, "findInventory", kKernelCallInst, -1, "", "rpp");
- OPCODE_MD(0x93, "getInventoryCount", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x94, "getVerbFromXY", kKernelCallInst, -1, "", "rpp");
+ OPCODE(0x6C, "breakHere", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x6D, "ifClassOfIs", KernelCallStackInstruction, 0x1011, "", "rlp"); // Variable stack arguments
+ OPCODE_MD(0x6E, "setClass", KernelCallStackInstruction, 0x1010, "", "lp"); // Variable stack arguments
+ OPCODE_MD(0x6F, "getState", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x70, "setState", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x71, "setOwner", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x72, "getOwner", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE(0x73, "jump", Scummv6JumpInstruction, 0, "a");
+ OPCODE_MD(0x74, "startSound", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x75, "stopSound", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x76, "startMusic", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x77, "stopObjectScript", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x78, "panCameraTo", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x79, "actorFollowCamera", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x7A, "setCameraAt", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x7B, "loadRoom", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x7C, "stopScript", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x7D, "walkActorToObj", KernelCallStackInstruction, -3, "", "ppp");
+ OPCODE_MD(0x7E, "walkActorTo", KernelCallStackInstruction, -3, "", "ppp");
+ OPCODE_MD(0x7F, "putActorAtXY", KernelCallStackInstruction, -4, "", "pppp");
+ OPCODE_MD(0x80, "putActorAtObject", KernelCallStackInstruction, -3, "", "zp");
+ OPCODE_MD(0x81, "faceActor", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x82, "animateActor", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x83, "doSentence", KernelCallStackInstruction, -4, "", "pppp");
+ OPCODE_MD(0x84, "pickupObject", KernelCallStackInstruction, -2, "", "z");
+ OPCODE_MD(0x85, "loadRoomWithEgo", KernelCallStackInstruction, -4, "", "ppz");
+ OPCODE_MD(0x87, "getRandomNumber", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x88, "getRandomNumberRange", KernelCallStackInstruction, -1, "", "rpp");
+ OPCODE_MD(0x8A, "getActorMoving", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x8B, "isScriptRunning", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x8C, "getActorRoom", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x8D, "getObjectX", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x8E, "getObjectY", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x8F, "getObjectDir", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x90, "getActorWalkBox", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x91, "getActorCostume", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x92, "findInventory", KernelCallStackInstruction, -1, "", "rpp");
+ OPCODE_MD(0x93, "getInventoryCount", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x94, "getVerbFromXY", KernelCallStackInstruction, -1, "", "rpp");
OPCODE_BASE(0x95)
- OPCODE_BODY("beginOverride", kKernelCallInst, 0, "", "");
+ OPCODE_BODY("beginOverride", KernelCallStackInstruction, 0, "", "");
// FIXME/TODO: beginOverride skips the following jump - that jump is instead to a "finally" handler
// To simulate this, we simply skip the jump instruction, so the sequential order appears the same.
// Semantically, it would probably be more correct to model this as a conditional jump,
@@ -186,262 +179,262 @@
_f.seek(3, SEEK_CUR);
_address += 3;
OPCODE_END;
- OPCODE(0x96, "endOverride", kKernelCallInst, 0, "");
- OPCODE_MD(0x97, "setObjectName", kKernelCallInst, -1, "c", "ps");
- OPCODE_MD(0x98, "isSoundRunning", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0x99, "setBoxFlags", kKernelCallInst, 0x1100, "", "pl"); // Variable stack arguments
- OPCODE(0x9A, "createBoxMatrix", kKernelCallInst, 0, "");
+ OPCODE(0x96, "endOverride", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x97, "setObjectName", KernelCallStackInstruction, -1, "c", "ps");
+ OPCODE_MD(0x98, "isSoundRunning", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0x99, "setBoxFlags", KernelCallStackInstruction, 0x1100, "", "pl"); // Variable stack arguments
+ OPCODE(0x9A, "createBoxMatrix", KernelCallStackInstruction, 0, "");
START_SUBOPCODE_WITH_PREFIX(0x9B, "resourceRoutines");
- OPCODE_MD(0x64, "loadScript", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x65, "loadSound", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x66, "loadCostume", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x67, "loadRoom", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x68, "nukeScript", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x69, "nukeSound", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x6A, "nukeCostume", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x6B, "nukeRoom", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x6C, "lockScript", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x6D, "lockSound", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x6E, "lockCostume", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x6F, "lockRoom", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x70, "unlockScript", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x71, "unlockSound", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x72, "unlockCostume", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x73, "unlockRoom", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x75, "loadCharset", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x76, "nukeCharset", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x77, "loadFlObject", kKernelCallInst, -2, "", "pp");
+ OPCODE_MD(0x64, "loadScript", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x65, "loadSound", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x66, "loadCostume", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x67, "loadRoom", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x68, "nukeScript", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x69, "nukeSound", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x6A, "nukeCostume", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x6B, "nukeRoom", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x6C, "lockScript", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x6D, "lockSound", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x6E, "lockCostume", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x6F, "lockRoom", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x70, "unlockScript", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x71, "unlockSound", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x72, "unlockCostume", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x73, "unlockRoom", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x75, "loadCharset", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x76, "nukeCharset", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x77, "loadFlObject", KernelCallStackInstruction, -2, "", "pp");
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0x9C, "roomOps");
- OPCODE_MD(0xAC, "roomScroll", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0xAE, "setScreen", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0xAF, "setPalColor", kKernelCallInst, -4, "", "pppp");
- OPCODE(0xB0, "shakeOn", kKernelCallInst, 0, "");
- OPCODE(0xB1, "shakeOff", kKernelCallInst, 0, "");
- OPCODE_MD(0xB3, "darkenPalette", kKernelCallInst, -3, "", "ppp");
- OPCODE_MD(0xB4, "saveLoadRoom", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0xB5, "screenEffect", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xB6, "darkenPaletteRGB", kKernelCallInst, -5, "", "ppppp");
- OPCODE_MD(0xB7, "setupShadowPalette", kKernelCallInst, -5, "", "ppppp");
- OPCODE_MD(0xBA, "palManipulate", kKernelCallInst, -4, "", "pppp");
- OPCODE_MD(0xBB, "colorCycleDelay", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0xD5, "setPalette", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xDC, "copyPalColor", kKernelCallInst, -2, "", "pp");
+ OPCODE_MD(0xAC, "roomScroll", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0xAE, "setScreen", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0xAF, "setPalColor", KernelCallStackInstruction, -4, "", "pppp");
+ OPCODE(0xB0, "shakeOn", KernelCallStackInstruction, 0, "");
+ OPCODE(0xB1, "shakeOff", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0xB3, "darkenPalette", KernelCallStackInstruction, -3, "", "ppp");
+ OPCODE_MD(0xB4, "saveLoadRoom", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0xB5, "screenEffect", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xB6, "darkenPaletteRGB", KernelCallStackInstruction, -5, "", "ppppp");
+ OPCODE_MD(0xB7, "setupShadowPalette", KernelCallStackInstruction, -5, "", "ppppp");
+ OPCODE_MD(0xBA, "palManipulate", KernelCallStackInstruction, -4, "", "pppp");
+ OPCODE_MD(0xBB, "colorCycleDelay", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0xD5, "setPalette", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xDC, "copyPalColor", KernelCallStackInstruction, -2, "", "pp");
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0x9D, "actorOps");
- OPCODE_MD(0x4C, "setCostume", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x4D, "setWalkSpeed", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x4E, "setSound", kKernelCallInst, 0x1000, "", "l"); // Variable stack arguments
- OPCODE_MD(0x4F, "setWalkFrame", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x50, "setTalkFrame", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x51, "setStandFrame", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x52, "82?", kKernelCallInst, -3, "", "ppp");
- OPCODE(0x53, "init", kKernelCallInst, 0, "");
- OPCODE_MD(0x54, "setElevation", kKernelCallInst, -1, "", "p");
- OPCODE(0x55, "setDefAnim", kKernelCallInst, 0, "");
- OPCODE_MD(0x56, "setPalette", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x57, "setTalkColor", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x58, "setName", kKernelCallInst, 0, "c", "s");
- OPCODE_MD(0x59, "setInitFrame", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x5B, "setWidth", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x5C, "setScale", kKernelCallInst, -1, "", "p");
- OPCODE(0x5D, "setNeverZClip", kKernelCallInst, 0, "");
- OPCODE_MD(0x5E, "setAlwaysZClip", kKernelCallInst, -1, "", "p");
- OPCODE(0x5F, "setIgnoreBoxes", kKernelCallInst, 0, "");
- OPCODE(0x60, "setFollowBoxes", kKernelCallInst, 0, "");
- OPCODE_MD(0x61, "setAnimSpeed", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x62, "setShadowMode", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x63, "setTalkPos", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0xC5, "setCurActor", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xC6, "setAnimVar", kKernelCallInst, -2, "", "pp");
- OPCODE(0xD7, "setIgnoreTurnsOn", kKernelCallInst, 0, "");
- OPCODE(0xD8, "setIgnoreTurnsOff", kKernelCallInst, 0, "");
- OPCODE(0xD9, "initLittle", kKernelCallInst, 0, "");
- OPCODE_MD(0xE1, "setAlwaysZClip?", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xE3, "setLayer", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xE4, "setWalkScript", kKernelCallInst, -1, "", "p");
- OPCODE(0xE5, "setStanding", kKernelCallInst, 0, "");
- OPCODE_MD(0xE6, "setDirection", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xE7, "turnToDirection", kKernelCallInst, -1, "", "p");
- OPCODE(0xE9, "freeze", kKernelCallInst, 0, "");
- OPCODE(0xEA, "unfreeze", kKernelCallInst, 0, "");
- OPCODE_MD(0xEB, "setTalkScript", kKernelCallInst, -1, "", "p");
+ OPCODE_MD(0x4C, "setCostume", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x4D, "setWalkSpeed", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x4E, "setSound", KernelCallStackInstruction, 0x1000, "", "l"); // Variable stack arguments
+ OPCODE_MD(0x4F, "setWalkFrame", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x50, "setTalkFrame", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x51, "setStandFrame", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x52, "82?", KernelCallStackInstruction, -3, "", "ppp");
+ OPCODE(0x53, "init", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x54, "setElevation", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x55, "setDefAnim", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x56, "setPalette", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x57, "setTalkColor", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x58, "setName", KernelCallStackInstruction, 0, "c", "s");
+ OPCODE_MD(0x59, "setInitFrame", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x5B, "setWidth", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x5C, "setScale", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x5D, "setNeverZClip", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x5E, "setAlwaysZClip", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x5F, "setIgnoreBoxes", KernelCallStackInstruction, 0, "");
+ OPCODE(0x60, "setFollowBoxes", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x61, "setAnimSpeed", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x62, "setShadowMode", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x63, "setTalkPos", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0xC5, "setCurActor", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xC6, "setAnimVar", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE(0xD7, "setIgnoreTurnsOn", KernelCallStackInstruction, 0, "");
+ OPCODE(0xD8, "setIgnoreTurnsOff", KernelCallStackInstruction, 0, "");
+ OPCODE(0xD9, "initLittle", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0xE1, "setAlwaysZClip?", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xE3, "setLayer", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xE4, "setWalkScript", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0xE5, "setStanding", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0xE6, "setDirection", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xE7, "turnToDirection", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0xE9, "freeze", KernelCallStackInstruction, 0, "");
+ OPCODE(0xEA, "unfreeze", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0xEB, "setTalkScript", KernelCallStackInstruction, -1, "", "p");
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0x9E, "verbOps");
- OPCODE_MD(0x7C, "loadImg", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x7D, "loadString", kKernelCallInst, 0, "c", "s");
- OPCODE_MD(0x7E, "setColor", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x7F, "setHiColor", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x80, "setXY", kKernelCallInst, -2, "", "pp");
- OPCODE(0x81, "setOn", kKernelCallInst, 0, "");
- OPCODE(0x82, "setOff", kKernelCallInst, 0, "");
- OPCODE(0x83, "kill", kKernelCallInst, 0, "");
- OPCODE(0x84, "init", kKernelCallInst, 0, "");
- OPCODE_MD(0x85, "setDimColor", kKernelCallInst, -1, "", "p");
- OPCODE(0x86, "setDimmed", kKernelCallInst, 0, "");
- OPCODE_MD(0x87, "setKey", kKernelCallInst, -1, "", "p");
- OPCODE(0x88, "setCenter", kKernelCallInst, 0, "");
- OPCODE_MD(0x89, "setToString", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x8B, "setToObject", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x8C, "setBkColor", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xC4, "setCurVerb", kKernelCallInst, -1, "", "p");
- OPCODE(0xFF, "redraw", kKernelCallInst, 0, "");
+ OPCODE_MD(0x7C, "loadImg", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x7D, "loadString", KernelCallStackInstruction, 0, "c", "s");
+ OPCODE_MD(0x7E, "setColor", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x7F, "setHiColor", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x80, "setXY", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE(0x81, "setOn", KernelCallStackInstruction, 0, "");
+ OPCODE(0x82, "setOff", KernelCallStackInstruction, 0, "");
+ OPCODE(0x83, "kill", KernelCallStackInstruction, 0, "");
+ OPCODE(0x84, "init", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x85, "setDimColor", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x86, "setDimmed", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x87, "setKey", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x88, "setCenter", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x89, "setToString", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x8B, "setToObject", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x8C, "setBkColor", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xC4, "setCurVerb", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0xFF, "redraw", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
- OPCODE_MD(0x9F, "getActorFromXY", kKernelCallInst, -1, "", "rpp");
- OPCODE_MD(0xA0, "findObject", kKernelCallInst, -1, "", "rpp");
- OPCODE_MD(0xA1, "pseudoRoom", kKernelCallInst, 0x1010, "", "lp"); // Variable stack arguments
- OPCODE_MD(0xA2, "getActorElevation", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0xA3, "getVerbEntrypoint", kKernelCallInst, -1, "", "rpp");
+ OPCODE_MD(0x9F, "getActorFromXY", KernelCallStackInstruction, -1, "", "rpp");
+ OPCODE_MD(0xA0, "findObject", KernelCallStackInstruction, -1, "", "rpp");
+ OPCODE_MD(0xA1, "pseudoRoom", KernelCallStackInstruction, 0x1010, "", "lp"); // Variable stack arguments
+ OPCODE_MD(0xA2, "getActorElevation", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0xA3, "getVerbEntrypoint", KernelCallStackInstruction, -1, "", "rpp");
START_SUBOPCODE_WITH_PREFIX(0xA4, "arrayOps");
- OPCODE_MD(0xCD, "assignString", kArrayOpInst, -1, "wc", "");
- OPCODE_MD(0xD0, "assignIntList", kArrayOpInst, 0x1100, "w", ""); // Variable stack arguments
- OPCODE_MD(0xD4, "assign2DimList", kArrayOpInst, 0x1100, "w", ""); // Variable stack arguments
+ OPCODE_MD(0xCD, "assignString", Scummv6ArrayOpInstruction, -1, "wc", "");
+ OPCODE_MD(0xD0, "assignIntList", Scummv6ArrayOpInstruction, 0x1100, "w", ""); // Variable stack arguments
+ OPCODE_MD(0xD4, "assign2DimList", Scummv6ArrayOpInstruction, 0x1100, "w", ""); // Variable stack arguments
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0xA5, "saveRestoreVerbs");
- OPCODE_MD(0x8D, "saveVerbs", kKernelCallInst, -3, "", "ppp");
- OPCODE_MD(0x8E, "restoreVerbs", kKernelCallInst, -3, "", "ppp");
- OPCODE_MD(0x8F, "deleteVerbs", kKernelCallInst, -3, "", "ppp");
+ OPCODE_MD(0x8D, "saveVerbs", KernelCallStackInstruction, -3, "", "ppp");
+ OPCODE_MD(0x8E, "restoreVerbs", KernelCallStackInstruction, -3, "", "ppp");
+ OPCODE_MD(0x8F, "deleteVerbs", KernelCallStackInstruction, -3, "", "ppp");
END_SUBOPCODE;
- OPCODE_MD(0xA6, "drawBox", kKernelCallInst, -5, "", "ppppp");
- OPCODE(0xA7, "pop", kStackInst, -1, "");
- OPCODE_MD(0xA8, "getActorWidth", kKernelCallInst, 0, "", "rp");
+ OPCODE_MD(0xA6, "drawBox", KernelCallStackInstruction, -5, "", "ppppp");
+ OPCODE(0xA7, "pop", Scummv6StackInstruction, -1, "");
+ OPCODE_MD(0xA8, "getActorWidth", KernelCallStackInstruction, 0, "", "rp");
START_SUBOPCODE(0xA9); // wait
- OPCODE_MD(0xA8, "waitForActor", kKernelCallInst, -1, "s", "pj");
- OPCODE(0xA9, "waitForMessage", kKernelCallInst, 0, "");
- OPCODE(0xAA, "waitForCamera", kKernelCallInst, 0, "");
- OPCODE(0xAB, "waitForSentence", kKernelCallInst, 0, "");
- OPCODE_MD(0xE2, "waitUntilActorDrawn", kKernelCallInst, -1, "s", "pj");
- OPCODE_MD(0xE8, "waitUntilActorTurned", kKernelCallInst, -1, "s", "pj");
+ OPCODE_MD(0xA8, "waitForActor", KernelCallStackInstruction, -1, "s", "pj");
+ OPCODE(0xA9, "waitForMessage", KernelCallStackInstruction, 0, "");
+ OPCODE(0xAA, "waitForCamera", KernelCallStackInstruction, 0, "");
+ OPCODE(0xAB, "waitForSentence", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0xE2, "waitUntilActorDrawn", KernelCallStackInstruction, -1, "s", "pj");
+ OPCODE_MD(0xE8, "waitUntilActorTurned", KernelCallStackInstruction, -1, "s", "pj");
END_SUBOPCODE;
- OPCODE_MD(0xAA, "getActorScaleX", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0xAB, "getActorAnimCounter", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0xAC, "soundKludge", kKernelCallInst, 0x1000, "", "l"); // Variable stack arguments
- OPCODE_MD(0xAD, "isAnyOf", kKernelCallInst, 0x1011, "", "rlp"); // Variable stack arguments
+ OPCODE_MD(0xAA, "getActorScaleX", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0xAB, "getActorAnimCounter", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0xAC, "soundKludge", KernelCallStackInstruction, 0x1000, "", "l"); // Variable stack arguments
+ OPCODE_MD(0xAD, "isAnyOf", KernelCallStackInstruction, 0x1011, "", "rlp"); // Variable stack arguments
START_SUBOPCODE_WITH_PREFIX(0xAE, "systemOps");
- OPCODE(0x9E, "restartGame", kKernelCallInst, 0, "");
- OPCODE(0x9F, "pauseGame", kKernelCallInst, 0, "");
- OPCODE(0xA0, "shutDown", kKernelCallInst, 0, "");
+ OPCODE(0x9E, "restartGame", KernelCallStackInstruction, 0, "");
+ OPCODE(0x9F, "pauseGame", KernelCallStackInstruction, 0, "");
+ OPCODE(0xA0, "shutDown", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
- OPCODE_MD(0xAF, "isActorInBox", kKernelCallInst, -1, "", "rpp");
- OPCODE_MD(0xB0, "delay", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xB1, "delaySeconds", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xB2, "delayMinutes", kKernelCallInst, -1, "", "p");
- OPCODE(0xB3, "stopSentence", kKernelCallInst, 0, "");
+ OPCODE_MD(0xAF, "isActorInBox", KernelCallStackInstruction, -1, "", "rpp");
+ OPCODE_MD(0xB0, "delay", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xB1, "delaySeconds", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xB2, "delayMinutes", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0xB3, "stopSentence", KernelCallStackInstruction, 0, "");
START_SUBOPCODE_WITH_PREFIX(0xB4, "printLine");
- OPCODE_MD(0x41, "XY", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x42, "color", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x43, "right", kKernelCallInst, -1, "", "p");
- OPCODE(0x45, "center", kKernelCallInst, 0, "");
- OPCODE(0x47, "left", kKernelCallInst, 0, "");
- OPCODE(0x48, "overhead", kKernelCallInst, 0, "");
- OPCODE(0x4A, "mumble", kKernelCallInst, 0, "");
- OPCODE_MD(0x4B, "msg", kKernelCallInst, 0, "c", "s");
- OPCODE(0xFE, "begin", kKernelCallInst, 0, "");
- OPCODE(0xFF, "end", kKernelCallInst, 0, "");
+ OPCODE_MD(0x41, "XY", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x42, "color", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x43, "right", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x45, "center", KernelCallStackInstruction, 0, "");
+ OPCODE(0x47, "left", KernelCallStackInstruction, 0, "");
+ OPCODE(0x48, "overhead", KernelCallStackInstruction, 0, "");
+ OPCODE(0x4A, "mumble", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x4B, "msg", KernelCallStackInstruction, 0, "c", "s");
+ OPCODE(0xFE, "begin", KernelCallStackInstruction, 0, "");
+ OPCODE(0xFF, "end", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0xB5, "printText");
- OPCODE_MD(0x41, "XY", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x42, "color", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x43, "right", kKernelCallInst, -1, "", "p");
- OPCODE(0x45, "center", kKernelCallInst, 0, "");
- OPCODE(0x47, "left", kKernelCallInst, 0, "");
- OPCODE(0x48, "overhead", kKernelCallInst, 0, "");
- OPCODE(0x4A, "mumble", kKernelCallInst, 0, "");
- OPCODE_MD(0x4B, "msg", kKernelCallInst, 0, "c", "s");
- OPCODE(0xFE, "begin", kKernelCallInst, 0, "");
- OPCODE(0xFF, "end", kKernelCallInst, 0, "");
+ OPCODE_MD(0x41, "XY", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x42, "color", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x43, "right", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x45, "center", KernelCallStackInstruction, 0, "");
+ OPCODE(0x47, "left", KernelCallStackInstruction, 0, "");
+ OPCODE(0x48, "overhead", KernelCallStackInstruction, 0, "");
+ OPCODE(0x4A, "mumble", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x4B, "msg", KernelCallStackInstruction, 0, "c", "s");
+ OPCODE(0xFE, "begin", KernelCallStackInstruction, 0, "");
+ OPCODE(0xFF, "end", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0xB6, "printDebug");
- OPCODE_MD(0x41, "XY", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x42, "color", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x43, "right", kKernelCallInst, -1, "", "p");
- OPCODE(0x45, "center", kKernelCallInst, 0, "");
- OPCODE(0x47, "left", kKernelCallInst, 0, "");
- OPCODE(0x48, "overhead", kKernelCallInst, 0, "");
- OPCODE(0x4A, "mumble", kKernelCallInst, 0, "");
- OPCODE_MD(0x4B, "msg", kKernelCallInst, 0, "c", "s");
- OPCODE(0xFE, "begin", kKernelCallInst, 0, "");
- OPCODE(0xFF, "end", kKernelCallInst, 0, "");
+ OPCODE_MD(0x41, "XY", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x42, "color", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x43, "right", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x45, "center", KernelCallStackInstruction, 0, "");
+ OPCODE(0x47, "left", KernelCallStackInstruction, 0, "");
+ OPCODE(0x48, "overhead", KernelCallStackInstruction, 0, "");
+ OPCODE(0x4A, "mumble", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x4B, "msg", KernelCallStackInstruction, 0, "c", "s");
+ OPCODE(0xFE, "begin", KernelCallStackInstruction, 0, "");
+ OPCODE(0xFF, "end", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0xB7, "printSystem");
- OPCODE_MD(0x41, "XY", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x42, "color", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x43, "right", kKernelCallInst, -1, "", "p");
- OPCODE(0x45, "center", kKernelCallInst, 0, "");
- OPCODE(0x47, "left", kKernelCallInst, 0, "");
- OPCODE(0x48, "overhead", kKernelCallInst, 0, "");
- OPCODE(0x4A, "mumble", kKernelCallInst, 0, "");
- OPCODE_MD(0x4B, "msg", kKernelCallInst, 0, "c", "s");
- OPCODE(0xFE, "begin", kKernelCallInst, 0, "");
- OPCODE(0xFF, "end", kKernelCallInst, 0, "");
+ OPCODE_MD(0x41, "XY", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x42, "color", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x43, "right", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x45, "center", KernelCallStackInstruction, 0, "");
+ OPCODE(0x47, "left", KernelCallStackInstruction, 0, "");
+ OPCODE(0x48, "overhead", KernelCallStackInstruction, 0, "");
+ OPCODE(0x4A, "mumble", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x4B, "msg", KernelCallStackInstruction, 0, "c", "s");
+ OPCODE(0xFE, "begin", KernelCallStackInstruction, 0, "");
+ OPCODE(0xFF, "end", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0xB8, "printActor");
- OPCODE_MD(0x41, "XY", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x42, "color", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x43, "right", kKernelCallInst, -1, "", "p");
- OPCODE(0x45, "center", kKernelCallInst, 0, "");
- OPCODE(0x47, "left", kKernelCallInst, 0, "");
- OPCODE(0x48, "overhead", kKernelCallInst, 0, "");
- OPCODE(0x4A, "mumble", kKernelCallInst, 0, "");
- OPCODE_MD(0x4B, "msg", kKernelCallInst, 0, "c", "s");
- OPCODE_MD(0xFE, "begin", kKernelCallInst, -1, "", "p");
- OPCODE(0xFF, "end", kKernelCallInst, 0, "");
+ OPCODE_MD(0x41, "XY", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x42, "color", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x43, "right", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x45, "center", KernelCallStackInstruction, 0, "");
+ OPCODE(0x47, "left", KernelCallStackInstruction, 0, "");
+ OPCODE(0x48, "overhead", KernelCallStackInstruction, 0, "");
+ OPCODE(0x4A, "mumble", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x4B, "msg", KernelCallStackInstruction, 0, "c", "s");
+ OPCODE_MD(0xFE, "begin", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0xFF, "end", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
START_SUBOPCODE_WITH_PREFIX(0xB9, "printEgo");
- OPCODE_MD(0x41, "XY", kKernelCallInst, -2, "", "pp");
- OPCODE_MD(0x42, "color", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0x43, "right", kKernelCallInst, -1, "", "p");
- OPCODE(0x45, "center", kKernelCallInst, 0, "");
- OPCODE(0x47, "left", kKernelCallInst, 0, "");
- OPCODE(0x48, "overhead", kKernelCallInst, 0, "");
- OPCODE(0x4A, "mumble", kKernelCallInst, 0, "");
- OPCODE_MD(0x4B, "msg", kKernelCallInst, 0, "c", "s");
- OPCODE(0xFE, "begin", kKernelCallInst, 0, "");
- OPCODE(0xFF, "end", kKernelCallInst, 0, "");
+ OPCODE_MD(0x41, "XY", KernelCallStackInstruction, -2, "", "pp");
+ OPCODE_MD(0x42, "color", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0x43, "right", KernelCallStackInstruction, -1, "", "p");
+ OPCODE(0x45, "center", KernelCallStackInstruction, 0, "");
+ OPCODE(0x47, "left", KernelCallStackInstruction, 0, "");
+ OPCODE(0x48, "overhead", KernelCallStackInstruction, 0, "");
+ OPCODE(0x4A, "mumble", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0x4B, "msg", KernelCallStackInstruction, 0, "c", "s");
+ OPCODE(0xFE, "begin", KernelCallStackInstruction, 0, "");
+ OPCODE(0xFF, "end", KernelCallStackInstruction, 0, "");
END_SUBOPCODE;
- OPCODE_MD(0xBA, "talkActor", kKernelCallInst, -1, "c", "ps");
- OPCODE_MD(0xBB, "talkEgo", kKernelCallInst, 0, "c", "s");
+ OPCODE_MD(0xBA, "talkActor", KernelCallStackInstruction, -1, "c", "ps");
+ OPCODE_MD(0xBB, "talkEgo", KernelCallStackInstruction, 0, "c", "s");
START_SUBOPCODE(0xBC); // dimArray
- OPCODE_MD(0xC7, "dimArrayInt", kKernelCallInst, -1, "w", "pv");
- OPCODE_MD(0xC8, "dimArrayBit", kKernelCallInst, -1, "w", "pv");
- OPCODE_MD(0xC9, "dimArrayNibble", kKernelCallInst, -1, "w", "pv");
- OPCODE_MD(0xCA, "dimArrayByte", kKernelCallInst, -1, "w", "pv");
- OPCODE_MD(0xCB, "dimArrayString", kKernelCallInst, -1, "w", "pv");
- OPCODE_MD(0xCC, "dimArray_nukeArray", kKernelCallInst, 0, "w", "v");
+ OPCODE_MD(0xC7, "dimArrayInt", KernelCallStackInstruction, -1, "w", "pv");
+ OPCODE_MD(0xC8, "dimArrayBit", KernelCallStackInstruction, -1, "w", "pv");
+ OPCODE_MD(0xC9, "dimArrayNibble", KernelCallStackInstruction, -1, "w", "pv");
+ OPCODE_MD(0xCA, "dimArrayByte", KernelCallStackInstruction, -1, "w", "pv");
+ OPCODE_MD(0xCB, "dimArrayString", KernelCallStackInstruction, -1, "w", "pv");
+ OPCODE_MD(0xCC, "dimArray_nukeArray", KernelCallStackInstruction, 0, "w", "v");
END_SUBOPCODE;
- OPCODE_MD(0xBE, "startObjectQuick", kKernelCallInst, 0x1020, "", "lpp"); // Variable stack arguments
- OPCODE_MD(0xBF, "startScriptQuick2", kKernelCallInst, 0x1010, "", "lp"); // Variable stack arguments
+ OPCODE_MD(0xBE, "startObjectQuick", KernelCallStackInstruction, 0x1020, "", "lpp"); // Variable stack arguments
+ OPCODE_MD(0xBF, "startScriptQuick2", KernelCallStackInstruction, 0x1010, "", "lp"); // Variable stack arguments
START_SUBOPCODE(0xC0); // dim2DimArray
- OPCODE_MD(0xC7, "dim2DimArrayInt", kKernelCallInst, -2, "w", "ppv");
- OPCODE_MD(0xC8, "dim2DimArrayBit", kKernelCallInst, -2, "w", "ppv");
- OPCODE_MD(0xC9, "dim2DimArrayNibble", kKernelCallInst, -2, "w", "ppv");
- OPCODE_MD(0xCA, "dim2DimArrayByte", kKernelCallInst, -2, "w", "ppv");
- OPCODE_MD(0xCB, "dim2DimArrayString", kKernelCallInst, -2, "w", "ppv");
+ OPCODE_MD(0xC7, "dim2DimArrayInt", KernelCallStackInstruction, -2, "w", "ppv");
+ OPCODE_MD(0xC8, "dim2DimArrayBit", KernelCallStackInstruction, -2, "w", "ppv");
+ OPCODE_MD(0xC9, "dim2DimArrayNibble", KernelCallStackInstruction, -2, "w", "ppv");
+ OPCODE_MD(0xCA, "dim2DimArrayByte", KernelCallStackInstruction, -2, "w", "ppv");
+ OPCODE_MD(0xCB, "dim2DimArrayString", KernelCallStackInstruction, -2, "w", "ppv");
END_SUBOPCODE;
- OPCODE_MD(0xC4, "abs", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0xC5, "getDistObjObj", kKernelCallInst, -1, "", "rpp");
- OPCODE_MD(0xC6, "getDistObjPt", kKernelCallInst, -2, "", "rppp");
- OPCODE_MD(0xC7, "getDistPtPt", kKernelCallInst, -3, "", "rpppp");
- OPCODE_MD(0xC8, "kernelGetFunctions", kKernelCallInst, 0x1000, "", "l"); // Variable stack arguments
- OPCODE_MD(0xC9, "kernelSetFunctions", kKernelCallInst, 0x1000, "", "l"); // Variable stack arguments
- OPCODE_MD(0xCA, "delayFrames", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xCB, "pickOneOf", kKernelCallInst, 0x1011, "", "rlp"); // Variable stack arguments
- OPCODE_MD(0xCC, "pickOneOfDefault", kKernelCallInst, 0x111, "", "rplp"); // Variable stack arguments
- OPCODE_MD(0xCD, "stampObject", kKernelCallInst, -4, "", "pppp");
- OPCODE(0xD0, "getDateTime", kKernelCallInst, 0, "");
- OPCODE(0xD1, "stopTalking", kKernelCallInst, 0, "");
- OPCODE_MD(0xD2, "getAnimateVariable", kKernelCallInst, -1, "", "rpp");
- OPCODE_MD(0xD4, "shuffle", kKernelCallInst, -2, "w", "vpp");
- OPCODE_MD(0xD5, "jumpToScript", kKernelCallInst, 0x1020, "", "lpp"); // Variable stack arguments
- OPCODE_MD(0xD6, "band", kBinaryOpInst, -1, "", "&");
- OPCODE_MD(0xD7, "bor", kBinaryOpInst, -1, "", "|");
- OPCODE_MD(0xD8, "isRoomScriptRunning", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0xDD, "findAllObjects", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0xE1, "getPixel", kKernelCallInst, -1, "", "rpp");
- OPCODE_MD(0xE3, "pickVarRandom", kKernelCallInst, 0x1001, "w", "rlw"); // Variable stack arguments
- OPCODE_MD(0xE4, "setBoxSet", kKernelCallInst, -1, "", "p");
- OPCODE_MD(0xEC, "getActorLayer", kKernelCallInst, 0, "", "rp");
- OPCODE_MD(0xED, "getObjectNewDir", kKernelCallInst, 0, "", "rp");
+ OPCODE_MD(0xC4, "abs", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0xC5, "getDistObjObj", KernelCallStackInstruction, -1, "", "rpp");
+ OPCODE_MD(0xC6, "getDistObjPt", KernelCallStackInstruction, -2, "", "rppp");
+ OPCODE_MD(0xC7, "getDistPtPt", KernelCallStackInstruction, -3, "", "rpppp");
+ OPCODE_MD(0xC8, "kernelGetFunctions", KernelCallStackInstruction, 0x1000, "", "l"); // Variable stack arguments
+ OPCODE_MD(0xC9, "kernelSetFunctions", KernelCallStackInstruction, 0x1000, "", "l"); // Variable stack arguments
+ OPCODE_MD(0xCA, "delayFrames", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xCB, "pickOneOf", KernelCallStackInstruction, 0x1011, "", "rlp"); // Variable stack arguments
+ OPCODE_MD(0xCC, "pickOneOfDefault", KernelCallStackInstruction, 0x111, "", "rplp"); // Variable stack arguments
+ OPCODE_MD(0xCD, "stampObject", KernelCallStackInstruction, -4, "", "pppp");
+ OPCODE(0xD0, "getDateTime", KernelCallStackInstruction, 0, "");
+ OPCODE(0xD1, "stopTalking", KernelCallStackInstruction, 0, "");
+ OPCODE_MD(0xD2, "getAnimateVariable", KernelCallStackInstruction, -1, "", "rpp");
+ OPCODE_MD(0xD4, "shuffle", KernelCallStackInstruction, -2, "w", "vpp");
+ OPCODE_MD(0xD5, "jumpToScript", KernelCallStackInstruction, 0x1020, "", "lpp"); // Variable stack arguments
+ OPCODE_MD(0xD6, "band", BinaryOpStackInstruction, -1, "", "&");
+ OPCODE_MD(0xD7, "bor", BinaryOpStackInstruction, -1, "", "|");
+ OPCODE_MD(0xD8, "isRoomScriptRunning", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0xDD, "findAllObjects", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0xE1, "getPixel", KernelCallStackInstruction, -1, "", "rpp");
+ OPCODE_MD(0xE3, "pickVarRandom", KernelCallStackInstruction, 0x1001, "w", "rlw"); // Variable stack arguments
+ OPCODE_MD(0xE4, "setBoxSet", KernelCallStackInstruction, -1, "", "p");
+ OPCODE_MD(0xEC, "getActorLayer", KernelCallStackInstruction, 0, "", "rp");
+ OPCODE_MD(0xED, "getObjectNewDir", KernelCallStackInstruction, 0, "", "rp");
END_OPCODES;
InstIterator it;
Modified: tools/trunk/decompiler/simple_disassembler.h
===================================================================
--- tools/trunk/decompiler/simple_disassembler.h 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/simple_disassembler.h 2010-12-22 12:15:33 UTC (rev 55001)
@@ -59,7 +59,7 @@
};
#define INC_ADDR _address++;
-#define ADD_INST(category) _insts.push_back(_instFactory.create(category));
+#define ADD_INST(category) _insts.push_back(new category());
#define LAST_INST (_insts.back())
#define START_OPCODES \
Modified: tools/trunk/decompiler/test/disassembler/pasc.cpp
===================================================================
--- tools/trunk/decompiler/test/disassembler/pasc.cpp 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/test/disassembler/pasc.cpp 2010-12-22 12:15:33 UTC (rev 55001)
@@ -23,117 +23,111 @@
#include "pasc.h"
PasCDisassembler::PasCDisassembler(InstVec &insts) : ::SimpleDisassembler(insts) {
- _instFactory.addEntry<PasCFakeInstruction>(kCallInst);
- _instFactory.addEntry<PasCFakeInstruction>(kCondJumpInst);
- _instFactory.addEntry<PasCFakeInstruction>(kJumpInst);
- _instFactory.addEntry<PasCFakeInstruction>(kLoadInst);
- _instFactory.addEntry<PasCFakeInstruction>(kStackInst);
- _instFactory.addEntry<PasCFakeInstruction>(kStoreInst);
}
void PasCDisassembler::doDisassemble() throw(std::exception) {
START_OPCODES;
//Basic machine operations
- OPCODE(0x00, "PUSH", kStackInst, 0, "i");
- OPCODE(0x01, "POP", kStackInst, 0, "i");
- OPCODE(0x02, "CALL", kCallInst, 0, "d");
- OPCODE(0x03, "RETURN", kReturnInst, 0, "");
- OPCODE(0x04, "HALT", kKernelCallInst, 0, "");
+ OPCODE(0x00, "PUSH", PasCFakeInstruction, 0, "i");
+ OPCODE(0x01, "POP", PasCFakeInstruction, 0, "i");
+ OPCODE(0x02, "CALL", PasCFakeInstruction, 0, "d");
+ OPCODE(0x03, "RETURN", PasCFakeInstruction, 0, "");
+ OPCODE(0x04, "HALT", PasCFakeInstruction, 0, "");
//Jumps
- OPCODE(0x10, "JUMP", kJumpInst, 0, "a");
- OPCODE(0x11, "JEQ", kCondJumpInst, 0, "a");
- OPCODE(0x12, "JAEQ", kCondJumpInst, 0, "a");
- OPCODE(0x13, "JGT", kCondJumpInst, 0, "a");
- OPCODE(0x14, "JLT", kCondJumpInst, 0, "a");
- OPCODE(0x15, "JALT", kCondJumpInst, 0, "a");
- OPCODE(0x16, "JAGT", kCondJumpInst, 0, "a");
+ OPCODE(0x10, "JUMP", PasCFakeInstruction, 0, "a");
+ OPCODE(0x11, "JEQ", PasCFakeInstruction, 0, "a");
+ OPCODE(0x12, "JAEQ", PasCFakeInstruction, 0, "a");
+ OPCODE(0x13, "JGT", PasCFakeInstruction, 0, "a");
+ OPCODE(0x14, "JLT", PasCFakeInstruction, 0, "a");
+ OPCODE(0x15, "JALT", PasCFakeInstruction, 0, "a");
+ OPCODE(0x16, "JAGT", PasCFakeInstruction, 0, "a");
//Boolean operations
- OPCODE(0x20, "OR", kBinaryOpInst, -1, "");
- OPCODE(0x21, "AND", kBinaryOpInst, -1, "");
- OPCODE(0x22, "XOR", kBinaryOpInst, -1, "");
- OPCODE(0x23, "NOT", kUnaryOpPreInst, -1, "");
+ OPCODE(0x20, "OR", PasCFakeInstruction, -1, "");
+ OPCODE(0x21, "AND", PasCFakeInstruction, -1, "");
+ OPCODE(0x22, "XOR", PasCFakeInstruction, -1, "");
+ OPCODE(0x23, "NOT", PasCFakeInstruction, -1, "");
//Padding instructions (smaller integer -> larger integer)
- OPCODE(0x30, "SPAD", kKernelCallInst, 0, "B");
- OPCODE(0x31, "UPAD", kKernelCallInst, 0, "B");
+ OPCODE(0x30, "SPAD", PasCFakeInstruction, 0, "B");
+ OPCODE(0x31, "UPAD", PasCFakeInstruction, 0, "B");
//32-bit operations
- OPCODE(0x80, "IADD", kBinaryOpInst, -4, "");
- OPCODE(0x81, "ISUB", kBinaryOpInst, -4, "");
- OPCODE(0x82, "IMULT", kBinaryOpInst, -4, "");
- OPCODE(0x83, "IDIV", kBinaryOpInst, -4, "");
- OPCODE(0x84, "IMOD", kBinaryOpInst, -4, "");
- OPCODE(0x85, "ISHL", kBinaryOpInst, -4, "");
- OPCODE(0x86, "ISHR", kBinaryOpInst, -4, "");
- OPCODE(0x87, "ISTOREA [SB]", kStoreInst, -4, "i");
- OPCODE(0x88, "ISTOREL [SB]", kStoreInst, 0, "ii");
- OPCODE(0x89, "ILOADA [SB]", kLoadInst, 4, "i");
- OPCODE(0x8A, "ISTOREA", kStoreInst, -4, "d");
- OPCODE(0x8B, "ISTOREL", kStoreInst, 0, "di");
- OPCODE(0x8C, "ILOADA", kLoadInst, 4, "d");
- OPCODE(0x8D, "ILOADL", kLoadInst, 0, "i");
- OPCODE(0x8E, "ICMP", kBinaryOpInst, -8, "");
- OPCODE(0x8F, "UICMP", kBinaryOpInst, -8, "");
- OPCODE(0x90, "IDUP", kLoadInst, 4, "");
- OPCODE(0x91, "IPRINT", kKernelCallInst, -4, "");
- OPCODE(0x92, "UIPRINT", kKernelCallInst, -4, "");
- OPCODE(0x96, "ISTORE [SB]", kStoreInst, -8, "");
- OPCODE(0x97, "ISTORE", kStoreInst, -8, "");
- OPCODE(0x98, "ILOAD [SB]", kLoadInst, -8, "");
- OPCODE(0x99, "ILOAD", kLoadInst, -8, "");
+ OPCODE(0x80, "IADD", PasCFakeInstruction, -4, "");
+ OPCODE(0x81, "ISUB", PasCFakeInstruction, -4, "");
+ OPCODE(0x82, "IMULT", PasCFakeInstruction, -4, "");
+ OPCODE(0x83, "IDIV", PasCFakeInstruction, -4, "");
+ OPCODE(0x84, "IMOD", PasCFakeInstruction, -4, "");
+ OPCODE(0x85, "ISHL", PasCFakeInstruction, -4, "");
+ OPCODE(0x86, "ISHR", PasCFakeInstruction, -4, "");
+ OPCODE(0x87, "ISTOREA [SB]", PasCFakeInstruction, -4, "i");
+ OPCODE(0x88, "ISTOREL [SB]", PasCFakeInstruction, 0, "ii");
+ OPCODE(0x89, "ILOADA [SB]", PasCFakeInstruction, 4, "i");
+ OPCODE(0x8A, "ISTOREA", PasCFakeInstruction, -4, "d");
+ OPCODE(0x8B, "ISTOREL", PasCFakeInstruction, 0, "di");
+ OPCODE(0x8C, "ILOADA", PasCFakeInstruction, 4, "d");
+ OPCODE(0x8D, "ILOADL", PasCFakeInstruction, 0, "i");
+ OPCODE(0x8E, "ICMP", PasCFakeInstruction, -8, "");
+ OPCODE(0x8F, "UICMP", PasCFakeInstruction, -8, "");
+ OPCODE(0x90, "IDUP", PasCFakeInstruction, 4, "");
+ OPCODE(0x91, "IPRINT", PasCFakeInstruction, -4, "");
+ OPCODE(0x92, "UIPRINT", PasCFakeInstruction, -4, "");
+ OPCODE(0x96, "ISTORE [SB]", PasCFakeInstruction, -8, "");
+ OPCODE(0x97, "ISTORE", PasCFakeInstruction, -8, "");
+ OPCODE(0x98, "ILOAD [SB]", PasCFakeInstruction, -8, "");
+ OPCODE(0x99, "ILOAD", PasCFakeInstruction, -8, "");
//16-bit operations
- OPCODE(0xA0, "SADD", kBinaryOpInst, -2, "");
- OPCODE(0xA1, "SSUB", kBinaryOpInst, -2, "");
- OPCODE(0xA2, "SMULT", kBinaryOpInst, -2, "");
- OPCODE(0xA3, "SDIV", kBinaryOpInst, -2, "");
- OPCODE(0xA4, "SMOD", kBinaryOpInst, -2, "");
- OPCODE(0xA5, "SSHL", kBinaryOpInst, -2, "");
- OPCODE(0xA6, "SSHR", kBinaryOpInst, -2, "");
- OPCODE(0xA7, "SSTOREA [SB]", kStoreInst, -2, "i");
- OPCODE(0xA8, "SSTOREL [SB]", kStoreInst, 0, "is");
- OPCODE(0xA9, "SLOADA [SB]", kLoadInst, 2, "i");
- OPCODE(0xAA, "SSTOREA", kStoreInst, -2, "d");
- OPCODE(0xAB, "SSTOREL", kStoreInst, 0, "ds");
- OPCODE(0xAC, "SLOADA", kLoadInst, 2, "d");
- OPCODE(0xAD, "SLOADL", kLoadInst, 0, "s");
- OPCODE(0xAE, "SCMP", kBinaryOpInst, -4, "");
- OPCODE(0xAF, "USCMP", kBinaryOpInst, -4, "");
- OPCODE(0xB0, "SDUP", kLoadInst, 2, "");
- OPCODE(0xB1, "SPRINT", kKernelCallInst, -2, "");
- OPCODE(0xB2, "USPRINT", kKernelCallInst, -2, "");
- OPCODE(0xB6, "SSTORE [SB]", kStoreInst, -6, "");
- OPCODE(0xB7, "SSTORE", kStoreInst, -6, "");
- OPCODE(0xB8, "SLOAD [SB]", kLoadInst, -6, "");
- OPCODE(0xB9, "SLOAD", kLoadInst, -6, "");
+ OPCODE(0xA0, "SADD", PasCFakeInstruction, -2, "");
+ OPCODE(0xA1, "SSUB", PasCFakeInstruction, -2, "");
+ OPCODE(0xA2, "SMULT", PasCFakeInstruction, -2, "");
+ OPCODE(0xA3, "SDIV", PasCFakeInstruction, -2, "");
+ OPCODE(0xA4, "SMOD", PasCFakeInstruction, -2, "");
+ OPCODE(0xA5, "SSHL", PasCFakeInstruction, -2, "");
+ OPCODE(0xA6, "SSHR", PasCFakeInstruction, -2, "");
+ OPCODE(0xA7, "SSTOREA [SB]", PasCFakeInstruction, -2, "i");
+ OPCODE(0xA8, "SSTOREL [SB]", PasCFakeInstruction, 0, "is");
+ OPCODE(0xA9, "SLOADA [SB]", PasCFakeInstruction, 2, "i");
+ OPCODE(0xAA, "SSTOREA", PasCFakeInstruction, -2, "d");
+ OPCODE(0xAB, "SSTOREL", PasCFakeInstruction, 0, "ds");
+ OPCODE(0xAC, "SLOADA", PasCFakeInstruction, 2, "d");
+ OPCODE(0xAD, "SLOADL", PasCFakeInstruction, 0, "s");
+ OPCODE(0xAE, "SCMP", PasCFakeInstruction, -4, "");
+ OPCODE(0xAF, "USCMP", PasCFakeInstruction, -4, "");
+ OPCODE(0xB0, "SDUP", PasCFakeInstruction, 2, "");
+ OPCODE(0xB1, "SPRINT", PasCFakeInstruction, -2, "");
+ OPCODE(0xB2, "USPRINT", PasCFakeInstruction, -2, "");
+ OPCODE(0xB6, "SSTORE [SB]", PasCFakeInstruction, -6, "");
+ OPCODE(0xB7, "SSTORE", PasCFakeInstruction, -6, "");
+ OPCODE(0xB8, "SLOAD [SB]", PasCFakeInstruction, -6, "");
+ OPCODE(0xB9, "SLOAD", PasCFakeInstruction, -6, "");
//8-bit operations
- OPCODE(0xC0, "BADD", kBinaryOpInst, -1, "");
- OPCODE(0xC1, "BSUB", kBinaryOpInst, -1, "");
- OPCODE(0xC2, "BMULT", kBinaryOpInst, -1, "");
- OPCODE(0xC3, "BDIV", kBinaryOpInst, -1, "");
- OPCODE(0xC4, "BMOD", kBinaryOpInst, -1, "");
- OPCODE(0xC5, "BSHL", kBinaryOpInst, -1, "");
- OPCODE(0xC6, "BSHR", kBinaryOpInst, -1, "");
- OPCODE(0xC7, "BSTOREA [SB]", kStoreInst, -1, "i");
- OPCODE(0xC8, "BSTOREL [SB]", kStoreInst, 0, "iB");
- OPCODE(0xC9, "BLOADA [SB]", kLoadInst, 1, "i");
- OPCODE(0xCA, "BSTOREA", kStoreInst, -1, "d");
- OPCODE(0xCB, "BSTOREL", kStoreInst, 0, "dB");
- OPCODE(0xCC, "BLOADA", kLoadInst, 1, "d");
- OPCODE(0xCD, "BLOADL", kLoadInst, 0, "B");
- OPCODE(0xCE, "SBCMP", kBinaryOpInst, -2, "");
- OPCODE(0xCF, "BCMP", kBinaryOpInst, -2, "");
- OPCODE(0xD0, "BDUP", kLoadInst, 1, "");
- OPCODE(0xD1, "SBPRINT", kKernelCallInst, -1, "");
- OPCODE(0xD2, "BPRINT", kKernelCallInst, -1, "");
- OPCODE(0xD3, "CPRINT", kKernelCallInst, -1, "");
- OPCODE(0xD6, "BSTORE [SB]", kStoreInst, -5, "");
- OPCODE(0xD7, "BSTORE", kStoreInst, -5, "");
- OPCODE(0xD8, "BLOAD [SB]", kLoadInst, -5, "");
- OPCODE(0xD9, "BLOAD", kLoadInst, -5, "");
+ OPCODE(0xC0, "BADD", PasCFakeInstruction, -1, "");
+ OPCODE(0xC1, "BSUB", PasCFakeInstruction, -1, "");
+ OPCODE(0xC2, "BMULT", PasCFakeInstruction, -1, "");
+ OPCODE(0xC3, "BDIV", PasCFakeInstruction, -1, "");
+ OPCODE(0xC4, "BMOD", PasCFakeInstruction, -1, "");
+ OPCODE(0xC5, "BSHL", PasCFakeInstruction, -1, "");
+ OPCODE(0xC6, "BSHR", PasCFakeInstruction, -1, "");
+ OPCODE(0xC7, "BSTOREA [SB]", PasCFakeInstruction, -1, "i");
+ OPCODE(0xC8, "BSTOREL [SB]", PasCFakeInstruction, 0, "iB");
+ OPCODE(0xC9, "BLOADA [SB]", PasCFakeInstruction, 1, "i");
+ OPCODE(0xCA, "BSTOREA", PasCFakeInstruction, -1, "d");
+ OPCODE(0xCB, "BSTOREL", PasCFakeInstruction, 0, "dB");
+ OPCODE(0xCC, "BLOADA", PasCFakeInstruction, 1, "d");
+ OPCODE(0xCD, "BLOADL", PasCFakeInstruction, 0, "B");
+ OPCODE(0xCE, "SBCMP", PasCFakeInstruction, -2, "");
+ OPCODE(0xCF, "BCMP", PasCFakeInstruction, -2, "");
+ OPCODE(0xD0, "BDUP", PasCFakeInstruction, 1, "");
+ OPCODE(0xD1, "SBPRINT", PasCFakeInstruction, -1, "");
+ OPCODE(0xD2, "BPRINT", PasCFakeInstruction, -1, "");
+ OPCODE(0xD3, "CPRINT", PasCFakeInstruction, -1, "");
+ OPCODE(0xD6, "BSTORE [SB]", PasCFakeInstruction, -5, "");
+ OPCODE(0xD7, "BSTORE", PasCFakeInstruction, -5, "");
+ OPCODE(0xD8, "BLOAD [SB]", PasCFakeInstruction, -5, "");
+ OPCODE(0xD9, "BLOAD", PasCFakeInstruction, -5, "");
END_OPCODES;
}
Modified: tools/trunk/decompiler/test/disassembler/subopcode.cpp
===================================================================
--- tools/trunk/decompiler/test/disassembler/subopcode.cpp 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/test/disassembler/subopcode.cpp 2010-12-22 12:15:33 UTC (rev 55001)
@@ -28,7 +28,7 @@
void SubOpcodeDisassembler::doDisassemble() throw(std::exception) {
START_OPCODES;
START_SUBOPCODE(0xFF)
- OPCODE(0xFF, "FOO", kKernelCallInst, 0, "");
+ OPCODE(0xFF, "FOO", SubOpcodeFakeInstruction, 0, "");
END_SUBOPCODE
END_OPCODES;
}
Modified: tools/trunk/decompiler/test/disassembler/subopcode.h
===================================================================
--- tools/trunk/decompiler/test/disassembler/subopcode.h 2010-12-22 09:22:14 UTC (rev 55000)
+++ tools/trunk/decompiler/test/disassembler/subopcode.h 2010-12-22 12:15:33 UTC (rev 55001)
@@ -30,4 +30,10 @@
SubOpcodeDisassembler(InstVec &insts);
void doDisassemble() throw(std::exception);
};
+
+class SubOpcodeFakeInstruction : public Instruction {
+public:
+ virtual void processInst(ValueStack &stack, Engine *engine, CodeGenerator *codeGen) {}
+};
+
#endif
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list