UCMachine.cpp

Go to the documentation of this file.

/*
Copyright (C) 2002-2006 The Pentagram team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "pent_include.h"

#include "UCMachine.h"
#include "UCProcess.h"
#include "Usecode.h"
#include "Kernel.h"
#include "DelayProcess.h"
#include "CoreApp.h"
#include "GameInfo.h"
#include "IDataSource.h"
#include "ODataSource.h"
#include "CurrentMap.h"
#include "World.h"
#include "BitSet.h"
#include "UCList.h"
#include "idMan.h"
#include "ConsoleGump.h"
#include "getObject.h"

#define INCLUDE_CONVERTUSECODEU8_WITHOUT_BRINGING_IN_FOLD
#include "u8/ConvertUsecodeU8.h"

#include "MainActor.h"

#ifdef DEBUG
#define LOGPF(X) do { if (trace_show(trace_pid, trace_objid, trace_classid)) pout.printf X; } while (0)
#else
#define LOGPF(X)
#endif

#ifdef DEBUG
static const char *print_bp(const sint16 offset)
{
        static char str[32];
        snprintf(str, 32, "[BP%c%02Xh]", offset<0?'-':'+', 
                                  offset<0?-offset:offset);
        return str;
}

static const char *print_sp(const sint16 offset)
{
        static char str[32];
        snprintf(str, 32, "[SP%c%02Xh]", offset<0?'-':'+', 
                                  offset<0?-offset:offset);
        return str;
}
#endif


//#define DUMPHEAP

enum UCSegments {
        SEG_STACK      = 0x0000,
        SEG_STACK_FIRST= 0x0001,
        SEG_STACK_LAST = 0x7FFE,
        SEG_STRING     = 0x8000,
        SEG_LIST       = 0x8001, // I don't think this is used
        SEG_OBJ        = 0x8002,
        SEG_GLOBAL     = 0x8003
};

UCMachine* UCMachine::ucmachine = 0;

UCMachine::UCMachine(Intrinsic *iset, unsigned int icount)
{
        con.Print(MM_INFO, "Creating UCMachine...\n");

        assert(ucmachine == 0);
        ucmachine = this;

        // zero globals
        globals = new BitSet(0x1000);

        convuse = new ConvertUsecodeU8; 
        loadIntrinsics(iset, icount); 

        listIDs = new idMan(1, 65534, 128);
        stringIDs = new idMan(1, 65534, 256);

        con.AddConsoleCommand("UCMachine::getGlobal", ConCmd_getGlobal);
        con.AddConsoleCommand("UCMachine::setGlobal", ConCmd_setGlobal);
#ifdef DEBUG
        con.AddConsoleCommand("UCMachine::traceObjID", ConCmd_traceObjID);
        con.AddConsoleCommand("UCMachine::tracePID", ConCmd_tracePID);
        con.AddConsoleCommand("UCMachine::traceClass", ConCmd_traceClass);
        con.AddConsoleCommand("UCMachine::traceEvents", ConCmd_traceEvents);
        con.AddConsoleCommand("UCMachine::traceAll", ConCmd_traceAll);
        con.AddConsoleCommand("UCMachine::stopTrace", ConCmd_stopTrace);

        tracing_enabled = false;
        trace_all = false;
#endif
}


UCMachine::~UCMachine()
{
        con.Print(MM_INFO, "Destroying UCMachine...\n");

        con.RemoveConsoleCommand(UCMachine::ConCmd_getGlobal);
        con.RemoveConsoleCommand(UCMachine::ConCmd_setGlobal);
#ifdef DEBUG
        con.RemoveConsoleCommand(UCMachine::ConCmd_traceObjID);
        con.RemoveConsoleCommand(UCMachine::ConCmd_tracePID);
        con.RemoveConsoleCommand(UCMachine::ConCmd_traceClass);
        con.RemoveConsoleCommand(UCMachine::ConCmd_traceAll);
        con.RemoveConsoleCommand(UCMachine::ConCmd_stopTrace);
#endif

        ucmachine = 0;

        delete globals; globals = 0;
        delete convuse; convuse = 0;
        delete listIDs; listIDs = 0;
        delete stringIDs; stringIDs = 0;
}

void UCMachine::reset()
{
        con.Print(MM_INFO, "Resetting UCMachine\n");

        // clear globals
        globals->setSize(0x1000);

        // clear strings, lists
        std::map<uint16, UCList*>::iterator iter;
        for (iter = listHeap.begin(); iter != listHeap.end(); ++iter)
                delete (iter->second);
        listHeap.clear();
        stringHeap.clear();
}

void UCMachine::loadIntrinsics(Intrinsic *i, unsigned int icount)
{
        intrinsics=i;
        intrinsiccount=icount;
}

bool UCMachine::execProcess(UCProcess* p)
{
        assert(p);

        uint32 base = p->usecode->get_class_base_offset(p->classid);
        IBufferDataSource cs(p->usecode->get_class(p->classid) + base,
                                                 p->usecode->get_class_size(p->classid) - base);
        cs.seek(p->ip);

#ifdef DEBUG
        if (trace_show(p->pid, p->item_num, p->classid)) {
                pout << std::hex << "running process " << p->pid
                         << ", item " << p->item_num << ", type " << p->type
                         << ", class " << p->classid << ", offset " << p->ip
                         << std::dec << std::endl;
        }
#endif

        bool cede = false;
        bool error = false;

        while(!cede && !error && !p->is_terminated())
        {

                uint8 opcode = cs.read1();

#ifdef DEBUG
                uint16 trace_classid = p->classid;
                ObjId trace_objid = p->item_num;
                ProcId trace_pid = p->pid;
#endif

                LOGPF(("sp = %02X; %04X:%04X: %02X\t",
                           p->stack.stacksize(), p->classid, p->ip, opcode));

                sint8 si8a, si8b;
                uint8 ui8a;
                uint16 ui16a, ui16b;
                uint32 ui32a, ui32b;
                sint16 si16a, si16b;
                sint32 si32a, si32b;

                switch(opcode)
                {

                // POP opcodes
                case 0x00:
                        // 00 xx
                        // pop 16 bit int, and assign LS 8 bit int into bp+xx
                        si8a = static_cast<sint8>(cs.read1());
                        ui16a = p->stack.pop2();
                        p->stack.assign1(p->bp+si8a, static_cast<uint8>(ui16a));
                        LOGPF(("pop byte\t%s = %02Xh\n", print_bp(si8a), ui16a));
                        break;

                case 0x01:
                        // 01 xx
                        // pop 16 bit int into bp+xx
                        si8a = static_cast<sint8>(cs.read1());
                        ui16a = p->stack.pop2();
                        p->stack.assign2(p->bp+si8a, ui16a);
                        LOGPF(("pop\t\t%s = %04Xh\n", print_bp(si8a), ui16a));
                        break;

                case 0x02:
                        // 02 xx
                        // pop 32 bit int into bp+xx
                        si8a = static_cast<sint8>(cs.read1());
                        ui32a = p->stack.pop4();
                        p->stack.assign4(p->bp+si8a, ui32a);
                        LOGPF(("pop dword\t%s = %08Xh\n", print_bp(si8a), ui32a));
                        break;

                case 0x03:
                        // 03 xx yy
                        // pop yy bytes into bp+xx
                        {
                                si8a = static_cast<sint8>(cs.read1());
                                uint8 size = cs.read1();
                                uint8 buf[256];
                                p->stack.pop(buf, size);
                                p->stack.assign(p->bp+si8a, buf, size);
                                LOGPF(("pop huge\t%s %i\n", print_bp(si8a), size));
                        }
                        break;

                case 0x08:
                        // 08
                        // pop 32bits into result register
                        LOGPF(("pop dword\tprocess result\n"));
                        p->result = p->stack.pop4();
                        break;

                case 0x09:
                        // 09 xx yy zz
                        // pop yy bytes into an element of list bp+xx (or slist if zz set)
                {
                        si8a = static_cast<sint8>(cs.read1());
                        ui32a = cs.read1();
                        si8b = static_cast<sint8>(cs.read1());
                        LOGPF(("assign element\t%s (%02X) (slist==%02X)\n",
                                   print_bp(si8a), ui32a, si8b));
                        ui16a = p->stack.pop2()-1; // index
                        ui16b = p->stack.access2(p->bp+si8a);
                        UCList* l = getList(ui16b);
                        if (!l) {
                                perr << "assign element to an invalid list (" << ui16b << ")"
                                         << std::endl;
                                error = true;
                                break;
                        }
                        if (si8b) { // slist?
                                // what special behaviour do we need here?
                                // probably just that the overwritten element has to be freed?
                                if (ui32a != 2) error = true; // um?
                                l->assign(ui16a, p->stack.access());
                                p->stack.pop2(); // advance SP
                        } else {
                                l->assign(ui16a, p->stack.access());
                                p->stack.addSP(ui32a);
                        }
                } break;

                // PUSH opcodes

                case 0x0A:
                        // 0A xx
                        // push sign-extended 8 bit xx onto the stack as 16 bit
                        ui16a = static_cast<sint8>(cs.read1());
                        p->stack.push2(ui16a);
                        LOGPF(("push byte\t%04Xh\n", ui16a));
                        break;

                case 0x0B:
                        // 0B xx xx
                        // push 16 bit xxxx onto the stack
                        ui16a = cs.read2();
                        p->stack.push2(ui16a);
                        LOGPF(("push\t\t%04Xh\n", ui16a));
                        break;

                case 0x0C:
                        // 0C xx xx xx xx
                        // push 32 bit xxxxxxxx onto the stack
                        ui32a = cs.read4();
                        p->stack.push4(ui32a);
                        LOGPF(("push dword\t%08Xh\n", ui32a));
                        break;

                case 0x0D:
                        // 0D xx xx yy ... yy 00
                        // push string (yy ... yy) of length xx xx onto the stack
                        {
                                ui16a = cs.read2();
                                char *str = new char[ui16a+1];
                                cs.read(str, ui16a);
                                str[ui16a] = 0;
                                LOGPF(("push string\t\"%s\"\n", str));
                                ui16b = cs.read1();
                                if (ui16b != 0) error = true;
                                p->stack.push2(assignString(str));
                                delete[] str;
                        }
                        break;

                case 0x0E:
                        // 0E xx yy
                        // pop yy values of size xx and push the resulting list
                        // (list is created in reverse order)
                        {
                                ui16a = cs.read1();
                                ui16b = cs.read1();
                                UCList* l = new UCList(ui16a, ui16b);
                                p->stack.addSP(ui16a * (ui16b - 1));
                                for (unsigned int i = 0; i < ui16b; i++) {
                                        l->append(p->stack.access());
                                        p->stack.addSP(-ui16a);
                                }
                                p->stack.addSP(ui16a * (ui16b + 1));
                                p->stack.push2(assignList(l));
                                LOGPF(("create list\t%02X (%02X)\n", ui16b, ui16a));
                        }
                        break;

                // Usecode function and intrinsic calls


                case 0x0F:
                        // 0F xx yyyy
                        // intrinsic call. xx is number of argument bytes
                        // (includes this pointer, if present)
                        // NB: do not actually pop these argument bytes
                        {
                                uint16 arg_bytes = cs.read1();
                                uint16 func = cs.read2();
                                LOGPF(("calli\t\t%04Xh (%02Xh arg bytes) %s \n", func, arg_bytes, convuse->intrinsics()[func]));

                                // !constants
                                if (func >= intrinsiccount || intrinsics[func] == 0) {
                                        p->temp32 = 0;
                                        perr << "Unhandled intrinsic \'" << convuse->intrinsics()[func] << "\' (" << std::hex << func << std::dec << ") called" << std::endl;
                                } else {
                                        if (intrinsics[func] == UCMachine::I_dummyProcess ||
                                                intrinsics[func] == UCMachine::I_true) {
//                                              perr << "Unhandled intrinsic \'" << convuse->intrinsics()[func] << "\' (" << std::hex << func << std::dec << ") called" << std::endl;
                                        }
                                        uint8 *argbuf = new uint8[arg_bytes];
                                        p->stack.pop(argbuf, arg_bytes);
                                        p->stack.addSP(-arg_bytes); // don't really pop the args

                                        p->temp32 = intrinsics[func](argbuf, arg_bytes);

                                        delete[] argbuf;
                                }



                                // REALLY MAJOR HACK:
                                // see docs/u8bugs.txt and
                                // https://sourceforge.net/tracker/index.php?func=detail&aid=1018748&group_id=53819&atid=471709
                                if (GAME_IS_U8 && p->classid == 0x48B && func == 0xD0)
                                { // 0xD0 = setAvatarInStasis
                                        globals->setBits(0, 1, 1);
                                }

                        }
                        break;


                case 0x11:
                        // 11 xx xx yy yy
                        // Ultima 8:
                        // call the function at offset yy yy of class xx xx
                        // Crusader:
                        // call function number yy yy of class xx xx
                        {
                                uint16 new_classid = cs.read2();
                                uint16 new_offset = cs.read2();
                                LOGPF(("call\t\t%04X:%04X\n", new_classid, new_offset));
                                if (GAME_IS_CRUSADER) {
                                        new_offset = p->usecode->get_class_event(new_classid,
                                                                                                                         new_offset);
                                }

                                p->ip = static_cast<uint16>(cs.getPos());       // Truncates!!
                                p->call(new_classid, new_offset);

                                // Update the code segment
                                uint32 base = p->usecode->get_class_base_offset(p->classid);
                                cs.load(p->usecode->get_class(p->classid) + base,
                                                p->usecode->get_class_size(p->classid) - base);
                                cs.seek(p->ip);

                                // Resume execution
                        }
                        break;

                case 0x12:
                        // 12
                        // pop 16bits into temp register
                        p->temp32 = p->stack.pop2();
                        LOGPF(("pop\t\ttemp = %04X\n", (p->temp32 & 0xFFFF)));
                        break;

                case 0x13:
                        // 13
                        // pop 32bits into temp register
                        // NB: 0x13 isn't used AFAIK, but this is a 'logical' guess
                        p->temp32 = p->stack.pop4();
                        LOGPF(("pop long\t\ttemp = %08X\n", p->temp32));
                        break;

                // Arithmetic

                case 0x14:
                        // 14
                        // 16 bit add
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        p->stack.push2(static_cast<uint16>(si16a + si16b));
                        LOGPF(("add\n"));
                        break;

                case 0x15:
                        // 15
                        // 32 bit add
                        si32a = static_cast<sint32>(p->stack.pop4());
                        si32b = static_cast<sint32>(p->stack.pop4());
                        p->stack.push4(static_cast<uint32>(si32a + si32b));
                        LOGPF(("add long\n"));
                        break;


                case 0x16:
                        // 16
                        // pop two strings from the stack and push the concatenation
                        // (free the originals? order?)
                        ui16a = p->stack.pop2();
                        ui16b = p->stack.pop2();
                        if (ui16b == 0) {
                                perr << "Trying to append to string 0." << std::endl;
                                error = true;
                                break;
                        }
                        stringHeap[ui16b] += getString(ui16a);
                        freeString(ui16a);
                        p->stack.push2(ui16b);
                        LOGPF(("concat\t\t= %s\n", stringHeap[ui16b].c_str()));
                        break;

                case 0x17:
                        // 17
                        // pop two lists from the stack and push the 'sum' of the lists
                        // (freeing the originals)
                {
                        ui16a = p->stack.pop2();
                        ui16b = p->stack.pop2();
                        UCList* listA = getList(ui16a);
                        UCList* listB = getList(ui16b);

                        if (listB && listA) {
                                if (listA->getElementSize() != listB->getElementSize()) {
                                        perr << "Trying to append lists with different element "
                                                 << "sizes (" << listB->getElementSize() << " != "
                                                 << listA->getElementSize() << ")" << std::endl;
                                        error = true;
                                } else {
                                        listB->appendList(*listA);
                                }
                                // CHECKME: do we allow appending a list to itself?
                                assert(ui16a != ui16b);
                                freeList(ui16a);
                                p->stack.push2(ui16b);
                        } else {
                                // at least one of the lists didn't exist. Error or not?
                                // for now: if one exists, push that one.
                                // if neither exists, push 0.

                                if (listA) {
                                        p->stack.push2(ui16a);
                                } else if (listB) {
                                        p->stack.push2(ui16b);
                                } else {
                                        p->stack.push2(0);
                                }
                        }
                        LOGPF(("append\n"));
                }       break;

                case 0x19:
                        // 19 02
                        // add two stringlists, removing duplicates
                        ui32a = cs.read1();
                        if (ui32a != 2) error = true;
                        ui16a = p->stack.pop2();
                        ui16b = p->stack.pop2();
                        getList(ui16b)->unionStringList(*getList(ui16a));
                        freeStringList(ui16a); // contents are actually freed in unionSL
                        p->stack.push2(ui16b);
                        LOGPF(("union slist\t(%02X)\n", ui32a));
                        break;

                case 0x1A:
                        // 1A
                        // substract string list
                        // NB: this one takes a length parameter in crusader. (not in U8)!!
                        // (or rather, it seems it takes one after all? -wjp,20030511)
                        ui32a = cs.read1(); // elementsize
                        ui32a = 2;
                        ui16a = p->stack.pop2();
                        ui16b = p->stack.pop2();
                        getList(ui16b)->substractStringList(*getList(ui16a));
                        freeStringList(ui16a);
                        p->stack.push2(ui16b);
                        LOGPF(("remove slist\t(%02X)\n", ui32a));
                        break;                  

                case 0x1B:
                        // 1B xx
                        // pop two lists from the stack and remove the 2nd from the 1st
                        // (free the originals? order?)
                        // only occurs in crusader.
                        ui32a = cs.read1(); // elementsize
                        ui16a = p->stack.pop2();
                        ui16b = p->stack.pop2();
                        getList(ui16b)->substractList(*getList(ui16a));
                        freeList(ui16a);
                        p->stack.push2(ui16b);
                        LOGPF(("remove list\t(%02X)\n", ui32a));
                        break;

                case 0x1C:
                        // 1C
                        // subtract two 16 bit integers
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        p->stack.push2(static_cast<uint16>(si16b - si16a)); // !! order?
                        LOGPF(("sub\n"));
                        break;

                case 0x1D:
                        // 1D
                        // subtract two 32 bit integers
                        si32a = static_cast<sint16>(p->stack.pop4());
                        si32b = static_cast<sint16>(p->stack.pop4());
                        p->stack.push4(static_cast<uint32>(si32b - si32a)); // !! order?
                        LOGPF(("sub long\n"));
                        break;

                case 0x1E:
                        // 1E
                        // multiply two 16 bit integers
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        p->stack.push2(static_cast<uint16>(si16a * si16b));
                        LOGPF(("mul\n"));
                        break;

                case 0x1F:
                        // 1F
                        // multiply two 32 bit integers
                        si32a = static_cast<sint16>(p->stack.pop4());
                        si32b = static_cast<sint16>(p->stack.pop4());
                        p->stack.push4(static_cast<uint32>(si32a * si32b));
                        LOGPF(("mul long\n"));
                        break;

                case 0x20:
                        // 20
                        // divide two 16 bit integers    (order?)
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        if (si16a != 0) {
                                p->stack.push2(static_cast<uint16>(si16b / si16a));
                        } else {
                                perr.printf("division by zero.\n");
                                p->stack.push2(0);
                        }
                        LOGPF(("div\n"));
                        break;

                case 0x21:
                        // 21
                        // divide two 32 bit integers    (order?)
                        si32a = static_cast<sint16>(p->stack.pop4());
                        si32b = static_cast<sint16>(p->stack.pop4());
                        if (si32a != 0) {
                                p->stack.push4(static_cast<uint32>(si32b / si32a));
                        } else {
                                perr.printf("division by zero.\n");
                                p->stack.push4(0);
                        }
                        LOGPF(("div\n"));
                        break;

                case 0x22:
                        // 22
                        // 16 bit mod    (order?)
                        // is this a C-style %?
                        // or return values between 0 and si16a-1 ?
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        if (si16a != 0) {
                                p->stack.push2(static_cast<uint16>(si16b % si16a));
                        } else {
                                perr.printf("division by zero.\n");
                                p->stack.push2(0);
                        }
                        LOGPF(("mod\n"));
                        break;

                case 0x23:
                        // 23
                        // 32 bit mod   (order)?
                        // also see 0x22
                        si32a = static_cast<sint16>(p->stack.pop4());
                        si32b = static_cast<sint16>(p->stack.pop4());
                        if (si32a != 0) {
                                p->stack.push4(static_cast<uint32>(si32b % si32a));
                        } else {
                                perr.printf("division by zero.\n");
                                p->stack.push4(0);
                        }
                        LOGPF(("mod long\n"));
                        break;

                case 0x24:
                        // 24
                        // 16 bit cmp
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        if (si16a == si16b) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("cmp\n"));
                        break;

                case 0x25:
                        // 25
                        // 32 bit cmp
                        si32a = static_cast<sint32>(p->stack.pop4());
                        si32b = static_cast<sint32>(p->stack.pop4());
                        if (si32a == si32b) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("cmp long\n"));
                        break;


                case 0x26:
                        // 26
                        // compare two strings
                        // (delete strings)
                        ui16a = p->stack.pop2();
                        ui16b = p->stack.pop2();
                        if (getString(ui16b) == getString(ui16a))
                                p->stack.push2(1);
                        else
                                p->stack.push2(0);
                        freeString(ui16a);
                        freeString(ui16b);
                        LOGPF(("strcmp\n"));
                        break;


                case 0x28:
                        // 28
                        // 16 bit less-than
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        if (si16b < si16a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("lt\n"));
                        break;

                case 0x29:
                        // 29
                        // 32 bit less-than
                        si32a = static_cast<sint32>(p->stack.pop4());
                        si32b = static_cast<sint32>(p->stack.pop4());
                        if (si32b < si32a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("lt long\n"));
                        break;

                case 0x2A:
                        // 2A
                        // 16 bit less-or-equal
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        if (si16b <= si16a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("le\n"));
                        break;

                case 0x2B:
                        // 2B
                        // 32 bit less-or-equal
                        si32a = static_cast<sint32>(p->stack.pop4());
                        si32b = static_cast<sint32>(p->stack.pop4());
                        if (si32b <= si32a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("le long\n"));
                        break;

                case 0x2C:
                        // 2C
                        // 16 bit greater-than
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        if (si16b > si16a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("gt\n"));
                        break;

                case 0x2D:
                        // 2D
                        // 32 bit greater-than
                        si32a = static_cast<sint32>(p->stack.pop4());
                        si32b = static_cast<sint32>(p->stack.pop4());
                        if (si32b > si32a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("gt long\n"));
                        break;

                case 0x2E:
                        // 2E
                        // 16 bit greater-or-equal
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        if (si16b >= si16a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("ge\n"));
                        break;

                case 0x2F:
                        // 2F
                        // 32 bit greater-or-equal
                        si32a = static_cast<sint32>(p->stack.pop4());
                        si32b = static_cast<sint32>(p->stack.pop4());
                        if (si32b >= si32a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("ge long\n"));
                        break;

                case 0x30:
                        // 30
                        // 16 bit boolean not
                        ui16a = p->stack.pop2();
                        if (!ui16a) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("not\n"));
                        break;


                case 0x31:
                        // 31
                        // 32 bit boolean not (both input and output 32 bit?)
                        ui32a = p->stack.pop4();
                        if (!ui32a) {
                                p->stack.push4(1);
                        } else {
                                p->stack.push4(0);
                        }
                        LOGPF(("not long\n"));
                        break;

                case 0x32:
                        // 32
                        // 16 bit boolean and
                        ui16a = p->stack.pop2();
                        ui16b = p->stack.pop2();
                        if (ui16a && ui16b) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("and\n"));
                        break;

                case 0x33:
                        // 33
                        // 32 bit boolean and
                        ui32a = p->stack.pop4();
                        ui32b = p->stack.pop4();
                        if (ui32a && ui32b) {
                                p->stack.push4(1);
                        } else {
                                p->stack.push4(0);
                        }
                        LOGPF(("and long\n"));
                        break;

                case 0x34:
                        // 34
                        // 16 bit boolean or
                        ui16a = p->stack.pop2();
                        ui16b = p->stack.pop2();
                        if (ui16a || ui16b) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("or\n"));
                        break;

                case 0x35:
                        // 35
                        // 32 bit boolean or
                        ui32a = p->stack.pop4();
                        ui32b = p->stack.pop4();
                        if (ui32a || ui32b) {
                                p->stack.push4(1);
                        } else {
                                p->stack.push4(0);
                        }
                        LOGPF(("or long\n"));
                        break;

                case 0x36:
                        // 36
                        // 16 bit not-equal
                        si16a = static_cast<sint16>(p->stack.pop2());
                        si16b = static_cast<sint16>(p->stack.pop2());
                        if (si16a != si16b) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("ne\n"));
                        break;

                case 0x37:
                        // 37
                        // 32 bit not-equal
                        si32a = static_cast<sint16>(p->stack.pop4());
                        si32b = static_cast<sint16>(p->stack.pop4());
                        if (si32a != si32b) {
                                p->stack.push2(1);
                        } else {
                                p->stack.push2(0);
                        }
                        LOGPF(("ne long\n"));
                        break;


                case 0x38:
                        // 38 xx yy
                        // is element (size xx) in list? (or slist if yy is true)
                        // free list/slist afterwards

                        ui16a = cs.read1();
                        ui32a = cs.read1();
                        ui16b = p->stack.pop2();
                        if (ui32a) { // stringlist
                                if (ui16a != 2) error = true;
                                if (getList(ui16b)->stringInList(p->stack.pop2()))
                                        p->stack.push2(1);
                                else
                                        p->stack.push2(0);
                                freeStringList(ui16b);
                        } else {
                                bool found = getList(ui16b)->inList(p->stack.access());
                                p->stack.addSP(ui16a);
                                if (found)
                                        p->stack.push2(1);
                                else
                                        p->stack.push2(0);

                                freeList(ui16b);
                        }
                        LOGPF(("in list\t\t%s slist==%02X\n",