mirror of
https://github.com/libretro/scummvm.git
synced 2025-01-10 03:40:25 +00:00
371 lines
12 KiB
C++
371 lines
12 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*
|
|
* Based on the original sources
|
|
* Faery Tale II -- The Halls of the Dead
|
|
* (c) 1993-1996 The Wyrmkeep Entertainment Co.
|
|
*/
|
|
|
|
#ifndef SAGA2_CODE_H
|
|
#define SAGA2_CODE_H
|
|
|
|
namespace Saga2 {
|
|
|
|
// types of operations for code generation
|
|
// note that the macros listed below depend on the ordering of this
|
|
// table to determine things like unary-op, binary-op, etc.
|
|
|
|
enum op_types {
|
|
kOpUndefined = 0,
|
|
|
|
// internal operations
|
|
|
|
kOpNextblock, // continue execution at next block
|
|
kOpDup, // duplicate 16-bit value on stack
|
|
kOpDrop, // drop 16-bit value on stack
|
|
|
|
// primary values
|
|
|
|
kOpZero, // push a zero on the stack
|
|
kOpOne, // push a one on the stack
|
|
kOpConstint, // constant integer
|
|
kOpConstid, // constant id reference
|
|
kOpStrlit, // string literal
|
|
kOpSym, // symbol address
|
|
kOpSymref, // symbol contents
|
|
kOpClassref, // reference to "this"
|
|
kOpDeref, // dereference of an ID
|
|
|
|
// references within this module
|
|
|
|
kOpGetflag, // read from flag bit (mode)
|
|
kOpGetbyte, // read from byte field (mode)
|
|
kOpGetint, // read from integer field (mode)
|
|
kOpGetstr, // read from string field (mode)
|
|
kOpGetid, // read from id field (mode)
|
|
|
|
kOpPutflag, // put to flag bit (mode)
|
|
kOpPutbyte, // put to byte field (mode)
|
|
kOpPutint, // put to integer field (mode)
|
|
kOpPutstr, // put to string field (mode)
|
|
kOpPutid, // put to id field (mode)
|
|
|
|
kOpPea, // push effective address onto stack
|
|
|
|
// 'void' versions consume their arguments
|
|
|
|
kOpPutflagV, // put to flag bit (mode)
|
|
kOpPutbyteV, // put to byte field (mode)
|
|
kOpPutintV, // put to integer field (mode)
|
|
kOpPutstrV, // put to string field (mode)
|
|
kOpPutidV, // put to id field (mode)
|
|
|
|
// function call
|
|
|
|
kOpCallNear, // call function in same segment
|
|
kOpCallFar, // call function in other segment
|
|
kOpCcall, // call C function
|
|
kOpCcallV, // call C function ()
|
|
kOpCallMember, // call member function
|
|
kOpCallMemberV, // call member function ()
|
|
|
|
kOpEnter, // enter a function
|
|
kOpReturn, // return from function
|
|
kOpReturn_v, // return nothing from function
|
|
|
|
// branches
|
|
|
|
kOpJmp,
|
|
kOpJmpTrueV, // test arg and consume
|
|
kOpJmpFalseV, // test arg and consume
|
|
kOpJmpTrue, // test arg and don't consume
|
|
kOpJmpDalse, // test arg and don't consume
|
|
kOpJmpSwitch, // switch statement (integer)
|
|
kOpJmpStrswitch, // switch statement (string)
|
|
kOpJmpRandom, // random jump
|
|
|
|
// unary operators
|
|
|
|
kOpNegate,
|
|
kOpNot,
|
|
kOpCompl,
|
|
|
|
kOpIncV, // increment, don't push
|
|
kOpDecV, // decrement, don't push
|
|
kOpPostinc,
|
|
kOpPostdec,
|
|
|
|
// arithmetic
|
|
|
|
kOpAdd,
|
|
kOpSub,
|
|
kOpMul,
|
|
kOpDiv,
|
|
kOpMod,
|
|
|
|
// conditional
|
|
|
|
kOpConditional,
|
|
kOpComma,
|
|
|
|
// comparison
|
|
|
|
kOpEq,
|
|
kOpNe,
|
|
kOpGt,
|
|
kOpLt,
|
|
kOpGe,
|
|
kOpLe,
|
|
|
|
// string comparison
|
|
|
|
kOpStrEq,
|
|
kOpStrNe,
|
|
kOpStrGt,
|
|
kOpStrLt,
|
|
kOpStrGe,
|
|
kOpStrLe,
|
|
|
|
// shift
|
|
|
|
kOpRsh,
|
|
kOpLsh,
|
|
|
|
// bitwise
|
|
|
|
kOpAnd,
|
|
kOpOr,
|
|
kOpXor,
|
|
|
|
// logical
|
|
|
|
kOpLand,
|
|
kOpLor,
|
|
kOpLxor,
|
|
|
|
// string functions
|
|
|
|
kOpStrcat, // string concatenation
|
|
kOpStrformat, // string formatting
|
|
|
|
// assignment operators -- none of these are actually compiled into
|
|
// code (they become get/put type operations)
|
|
|
|
kOpAssign,
|
|
// none of these are even used currently...
|
|
kOpAsplus,
|
|
kOpAsminus,
|
|
kOpAstimes,
|
|
kOpAsdiv,
|
|
kOpAsmod,
|
|
kOpAsrshift,
|
|
kOpAslshift,
|
|
kOpAsand,
|
|
kOpAsor,
|
|
|
|
// Special ops
|
|
|
|
kOpSpeak,
|
|
kOpDialogBegin,
|
|
kOpDialogEnd,
|
|
kOpReply,
|
|
kOpAnimate,
|
|
|
|
// New opcodes
|
|
|
|
kOpJmp_seedrandom, // seeded random jump
|
|
kOpSymrefX, // get the export number of the symbol
|
|
|
|
kOpLast /* about 90 so far */
|
|
};
|
|
|
|
// addressing modes for get and put
|
|
|
|
enum addr_types {
|
|
|
|
// Offset reference to the thread structure
|
|
|
|
skAddrThread = 0,
|
|
|
|
// Offset reference to the stack
|
|
|
|
skAddrStack,
|
|
|
|
// Implicit reference to the currently executing segment
|
|
|
|
skAddrNear,
|
|
|
|
// Implicit reference to data segment
|
|
|
|
skAddrData,
|
|
|
|
// This addressing mode references any external segment
|
|
// using a 16-bit segment number and a 16-bit segment offset
|
|
// which immediately follow the instruction.
|
|
|
|
skAddrFar,
|
|
|
|
// This addressing mode is used for segment-array addressing
|
|
// it's a 16-bit segment followed by a 16-bit object number,
|
|
// followed by a (byte or bit) offset within the object
|
|
|
|
skAddrArray,
|
|
|
|
// This addressing mode uses a 16-bit segment number
|
|
// and a 16-bit offset which have been put on the stack.
|
|
|
|
// skAddrIndirect, // use SEG:offset on stack
|
|
// skAddrIndirectIndex, // use SEG:index:offset on stack
|
|
|
|
// This addressing mode is used for dereferencing objects.
|
|
// It consists of an _embedded_ address for retrieving the
|
|
// object number, followed by a 16-bit segment number for
|
|
// the dereferenced objects, followed by a 16-bit index
|
|
// into the dereferenced object.
|
|
|
|
// REM: We also need a "far deref" for computing the
|
|
// dereferenced object's segment number.
|
|
|
|
skAddrDeref,
|
|
|
|
// Addressing mode used for class member functions. It
|
|
// specified that the address is relative to whatever
|
|
// object the 1st argument is referrring to.
|
|
|
|
skAddrThis // relative to arg 1
|
|
};
|
|
|
|
#define IS_CONST(x) ((x) >= kOpConstint && (x) <= kOpConststr)
|
|
#define IS_ADDRESS(x) ((x) == kOpSym)
|
|
#define IS_UNOP(x) ((x) >= kOpNegate && (x) <= kOpPostdec)
|
|
|
|
#define IS_BINOP(x) ((x) >= kOpAdd && (x) <= kOpStrcat)
|
|
#define IS_ASOP(x) ((x) >= kOpAssign && (x) <= kOpAsor)
|
|
|
|
// #define IS_UNOP2(x) ((x) == kOpGetarray || (x) == kOpPutarray)
|
|
// #define CONST(op) ((op) >= kOpConstflag && (op) <= kOpConststr)
|
|
|
|
// Flags for special statements
|
|
|
|
#define SPEAKF_NOANIMATE (1<<0) // speaker should animate
|
|
#define SPEAKF_ASYNC (1<<1) // async speech.
|
|
|
|
#define REPLYF_ONCE (1<<0) // 'once' flag
|
|
#define REPLYF_SUMMARY (1<<1) // response is only a summary
|
|
#define REPLYF_CONDITION (1<<2) // response has a condition
|
|
|
|
#define ANIMATEF_REPEAT (1<<0)
|
|
|
|
// BasicBlock describes a block of generated code
|
|
|
|
#ifdef COMPILE_H
|
|
|
|
typedef struct _BasicBlock {
|
|
struct _BasicBlock *next; // pointer to next block
|
|
|
|
short label; // label for this block
|
|
|
|
struct _BasicBlock *from[2], // where we could have come from
|
|
*jumpto, // where to go if jump
|
|
*fallto; // where to go if fall through
|
|
|
|
struct _Statement *first_st, // statement list for this bblock
|
|
*last_st; // it's a circular list
|
|
|
|
ENode *test_expr; // test expression for jump
|
|
char in_flags, // flags for entering this block
|
|
jump_type; // where to go after this block
|
|
|
|
uint16 start_offset, // offset in module of this block
|
|
jump_offset; // offset of module of jump at end
|
|
|
|
int16 source_file, // source line of statement
|
|
source_line; // source file of statement
|
|
} BasicBlock;
|
|
|
|
// Various flags for the block
|
|
|
|
#define BBLOCK_CLABEL (1<<0) /* bblock begins with a 'C' label */
|
|
#define BBLOCK_INTLABEL (1<<1) /* bblock begins with internal label */
|
|
#define BBLOCK_FIRST (1<<2) /* first bblock in the function */
|
|
#define BBLOCK_MANY (1<<3) /* many guys jump to here */
|
|
#define BBLOCK_CASE (1<<4) /* case stmts might not have 'from' ptr */
|
|
|
|
// Jump types
|
|
|
|
enum jump_types {
|
|
kJumpNever = 0, /* never jump */
|
|
kJumpFalse, /* jump on expression if false */
|
|
kJumpTrue, /* jump on expression if true */
|
|
kJumpAlways, /* jump always */
|
|
kJumpCjump, /* 'c' goto stm, jumpto is a label # */
|
|
kJumpReturn, /* block ends with a 'return' statement */
|
|
kJumpSwitch, /* jumps to lots of places */
|
|
};
|
|
#endif
|
|
/*
|
|
// Module describes all the code associated with a particular
|
|
// compilation unit.
|
|
|
|
struct Module {
|
|
uint16 exportCount, // number of symbols exported
|
|
importCount; // number of symbols imported
|
|
uint16 exportOffset, // start of export table
|
|
importOffset; // start of import table
|
|
|
|
// Q: Should ModuleName be somewhere else, like in the main program?
|
|
|
|
uint16 staticSize; // size of static data
|
|
uint16 stringOffset; // unused in this version
|
|
// int16 moduleName; // offset to name of module
|
|
|
|
// Followed by list of exports
|
|
// Followed by list of imports
|
|
// Followed by symbol names, each NULL-terminated
|
|
// Followed by actual code blocks
|
|
|
|
};
|
|
|
|
// Exports: Each Export contains the offset to find the name of
|
|
// the object. After that is the offset to find the object itself.
|
|
|
|
// The first Export is always the module entry point
|
|
|
|
struct ModuleExport { // an exported symbol
|
|
uint16 symbolOffset, // offset in module of symbol name
|
|
objectOffset; // where to find object
|
|
};
|
|
|
|
// Imports: Each Import contains the offset to find the name of
|
|
// the object. After that is a blank pointer, which will be filled
|
|
// in with the real address of the object. When addressing the
|
|
// imported object, the code in this module will refer to this
|
|
// ModuleImport entry, and indirectly locate the referenced object.
|
|
|
|
struct ModuleImport { // a module xref
|
|
uint16 symbolOffset; // where, from here, to find name
|
|
void *objectPointer; // NULL pointer, filled in on load
|
|
};
|
|
*/
|
|
|
|
} // end of namespace Saga2
|
|
|
|
#endif
|