scummvm/engines/glk/glulxe/funcs.cpp

/* 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 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#include "glk/glulxe/glulxe.h"

namespace Glk {
namespace Glulxe {

void Glulxe::enter_function(uint funcaddr, uint argc, uint *argv) {
	uint ix, jx;
	acceleration_func accelFunc;
	int locallen;
	int functype;
	uint modeaddr, opaddr, val;
	int loctype, locnum;
	uint addr = funcaddr;

	accelFunc = accel_get_func(addr);
	if (accelFunc) {
		profile_in(addr, stackptr, true);
		val = (this->*accelFunc)(argc, argv);
		profile_out(stackptr);
		pop_callstub(val);
		return;
	}

	profile_in(addr, stackptr, false);

	/* Check the Glulx type identifier byte. */
	functype = Mem1(addr);
	if (functype != 0xC0 && functype != 0xC1) {
		if (functype >= 0xC0 && functype <= 0xDF)
			fatal_error_i("Call to unknown type of function.", addr);
		else
			fatal_error_i("Call to non-function.", addr);
	}
	addr++;

	/* Bump the frameptr to the top. */
	frameptr = stackptr;

	/* Go through the function's locals-format list, copying it to the
	   call frame. At the same time, we work out how much space the locals
	   will actually take up. (Including padding.) */
	ix = 0;
	locallen = 0;
	while (1) {
		/* Grab two bytes from the locals-format list. These are
		   unsigned (0..255 range). */
		loctype = Mem1(addr);
		addr++;
		locnum = Mem1(addr);
		addr++;

		/* Copy them into the call frame. */
		StkW1(frameptr + 8 + 2 * ix, loctype);
		StkW1(frameptr + 8 + 2 * ix + 1, locnum);
		ix++;

		/* If the type is zero, we're done, except possibly for two more
		   zero bytes in the call frame (to ensure 4-byte alignment.) */
		if (loctype == 0) {
			/* Make sure ix is even. */
			if (ix & 1) {
				StkW1(frameptr + 8 + 2 * ix, 0);
				StkW1(frameptr + 8 + 2 * ix + 1, 0);
				ix++;
			}
			break;
		}

		/* Pad to 4-byte or 2-byte alignment if these locals are 4 or 2
		   bytes long. */
		if (loctype == 4) {
			while (locallen & 3)
				locallen++;
		} else if (loctype == 2) {
			while (locallen & 1)
				locallen++;
		} else if (loctype == 1) {
			/* no padding */
		} else {
			fatal_error("Illegal local type in locals-format list.");
		}

		/* Add the length of the locals themselves. */
		locallen += (loctype * locnum);
	}

	/* Pad the locals to 4-byte alignment. */
	while (locallen & 3)
		locallen++;

	/* We now know how long the locals-frame and locals segments are. */
	localsbase = frameptr + 8 + 2 * ix;
	valstackbase = localsbase + locallen;

	/* Test for stack overflow. */
	/* This really isn't good enough; if the format list overflowed the
	   stack, we've already written outside the stack array. */
	if (valstackbase >= stacksize)
		fatal_error("Stack overflow in function call.");

	/* Fill in the beginning of the stack frame. */
	StkW4(frameptr + 4, 8 + 2 * ix);
	StkW4(frameptr, 8 + 2 * ix + locallen);

	/* Set the stackptr and PC. */
	stackptr = valstackbase;
	pc = addr;

	/* Zero out all the locals. */
	for (jx = 0; jx < (uint)locallen; jx++)
		StkW1(localsbase + jx, 0);

	if (functype == 0xC0) {
		/* Push the function arguments on the stack. The locals have already
		   been zeroed. */
		if (stackptr + 4 * (argc + 1) >= stacksize)
			fatal_error("Stack overflow in function arguments.");
		for (ix = 0; ix < argc; ix++) {
			val = argv[(argc - 1) - ix];
			StkW4(stackptr, val);
			stackptr += 4;
		}
		StkW4(stackptr, argc);
		stackptr += 4;
	} else {
		/* Copy in function arguments. This is a bit gross, since we have to
		   follow the locals format. If there are fewer arguments than locals,
		   that's fine -- we've already zeroed out this space. If there are
		   more arguments than locals, the extras are silently dropped. */
		modeaddr = frameptr + 8;
		opaddr = localsbase;
		ix = 0;
		while (ix < argc) {
			loctype = Stk1(modeaddr);
			modeaddr++;
			locnum = Stk1(modeaddr);
			modeaddr++;
			if (loctype == 0)
				break;
			if (loctype == 4) {
				while (opaddr & 3)
					opaddr++;
				while (ix < argc && locnum) {
					val = argv[ix];
					StkW4(opaddr, val);
					opaddr += 4;
					ix++;
					locnum--;
				}
			} else if (loctype == 2) {
				while (opaddr & 1)
					opaddr++;
				while (ix < argc && locnum) {
					val = argv[ix] & 0xFFFF;
					StkW2(opaddr, val);
					opaddr += 2;
					ix++;
					locnum--;
				}
			} else if (loctype == 1) {
				while (ix < argc && locnum) {
					val = argv[ix] & 0xFF;
					StkW1(opaddr, val);
					opaddr += 1;
					ix++;
					locnum--;
				}
			}
		}
	}

	/* If the debugger is compiled in, check for a breakpoint on this
	   function. (Checking the function address, not the starting PC.) */
	debugger_check_func_breakpoint(funcaddr);
}

void Glulxe::leave_function() {
	profile_out(stackptr);
	stackptr = frameptr;
}

void Glulxe::push_callstub(uint desttype, uint destaddr) {
	if (stackptr + 16 > stacksize)
		fatal_error("Stack overflow in callstub.");
	StkW4(stackptr + 0, desttype);
	StkW4(stackptr + 4, destaddr);
	StkW4(stackptr + 8, pc);
	StkW4(stackptr + 12, frameptr);
	stackptr += 16;
}

void Glulxe::pop_callstub(uint returnvalue) {
	uint desttype, destaddr;
	uint newpc, newframeptr;

	if (stackptr < 16)
		fatal_error("Stack underflow in callstub.");
	stackptr -= 16;

	newframeptr = Stk4(stackptr + 12);
	newpc = Stk4(stackptr + 8);
	destaddr = Stk4(stackptr + 4);
	desttype = Stk4(stackptr + 0);

	pc = newpc;
	frameptr = newframeptr;

	/* Recompute valstackbase and localsbase */
	valstackbase = frameptr + Stk4(frameptr);
	localsbase = frameptr + Stk4(frameptr + 4);

	switch (desttype) {

	case 0x11:
		fatal_error("String-terminator call stub at end of function call.");
		break;

	case 0x10:
		/* This call stub was pushed during a string-decoding operation!
		   We have to restart it. (Note that the return value is discarded.) */
		stream_string(pc, 0xE1, destaddr);
		break;

	case 0x12:
		/* This call stub was pushed during a number-printing operation.
		   Restart that. (Return value discarded.) */
		stream_num(pc, true, destaddr);
		break;

	case 0x13:
		/* This call stub was pushed during a C-string printing operation.
		   We have to restart it. (Note that the return value is discarded.) */
		stream_string(pc, 0xE0, destaddr);
		break;

	case 0x14:
		/* This call stub was pushed during a Unicode printing operation.
		   We have to restart it. (Note that the return value is discarded.) */
		stream_string(pc, 0xE2, destaddr);
		break;

	default:
		/* We're back in the original frame, so we can store the returnvalue.
		   (If we tried to do this before resetting frameptr, a result
		   destination on the stack would go astray.) */
		store_operand(desttype, destaddr, returnvalue);
		break;
	}
}

uint Glulxe::pop_callstub_string(int *bitnum) {
	uint desttype, destaddr, newpc;

	if (stackptr < 16)
		fatal_error("Stack underflow in callstub.");
	stackptr -= 16;

	newpc = Stk4(stackptr + 8);
	destaddr = Stk4(stackptr + 4);
	desttype = Stk4(stackptr + 0);

	pc = newpc;

	if (desttype == 0x11) {
		return 0;
	}
	if (desttype == 0x10) {
		*bitnum = destaddr;
		return pc;
	}

	fatal_error("Function-terminator call stub at end of string.");
	return 0;
}

} // End of namespace Glulxe
} // End of namespace Glk