code.h

/* 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