hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
0e5a28e063
qse/ase/stx/interp.c
hyung-hwan a30619c53d
2008-03-04 05:21:33 +00:00

381 lines
9.5 KiB
C
Raw Blame History

/*
* $Id: interp.c 118 2008-03-03 11:21:33Z baconevi $
*/
#include <ase/stx/interp.h>
#include <ase/stx/method.h>
#include <ase/stx/object.h>
#include <ase/stx/array.h>
#include <ase/stx/class.h>
#include <ase/bas/assert.h>
#include <ase/bas/memory.h>
/*
activation record
....
....
....
-------------------
previous stack_base
-------------------
method
-------------------
pc
-------------------
temporaries
-------------------
arguments
-------------------
receiver
------------------- <----- current stack_base
....
....
....
*/
struct process_t
{
ase_word_t* stack;
ase_word_t stack_size;
ase_word_t stack_base;
ase_word_t stack_top;
ase_word_t receiver;
ase_word_t method;
ase_word_t pc;
/* cached information about the method above */
ase_word_t* literals;
ase_byte_t* bytecodes;
ase_word_t bytecode_size;
ase_size_t argcount;
ase_size_t tmpcount;
};
typedef struct process_t process_t;
static int __run_process (ase_stx_t* stx, process_t* proc);
static int __push_to_stack (ase_stx_t* stx,
process_t* proc, ase_word_t what, ase_word_t index);
static int __store_from_stack (ase_stx_t* stx,
process_t* proc, ase_word_t what, ase_word_t index);
static int __send_message (ase_stx_t* stx, process_t* proc,
ase_word_t nargs, ase_word_t selector, ase_bool_t to_super);
static int __return_from_message (ase_stx_t* stx, process_t* proc);
static int __dispatch_primitive (ase_stx_t* stx, process_t* proc, ase_word_t no);
int ase_stx_interp (ase_stx_t* stx, ase_word_t receiver, ase_word_t method)
{
process_t proc;
ase_stx_method_t* mthobj;
ase_word_t i;
int n;
// TODO: size of process stack.
proc.stack = (ase_word_t*)ase_malloc (10000 * ase_sizeof(ase_word_t));
if (proc.stack == ASE_NULL) {
ase_printf (ASE_T("out of memory in ase_stx_interp\n"));
return -1;
}
proc.stack_size = 10000;
proc.stack_base = 0;
proc.stack_top = 0;
mthobj = (ase_stx_method_t*)ASE_STX_OBJECT(stx,method);
ase_assert (mthobj != ASE_NULL);
proc.literals = mthobj->literals;
proc.bytecodes = ASE_STX_DATA(stx, mthobj->bytecodes);
proc.bytecode_size = ASE_STX_SIZE(stx, mthobj->bytecodes);
/* TODO: disable the method with arguments for start-up */
proc.argcount = ASE_STX_FROM_SMALLINT(mthobj->argcount);
proc.tmpcount = ASE_STX_FROM_SMALLINT(mthobj->tmpcount);
proc.receiver = receiver;
proc.method = method;
proc.pc = 0;
proc.stack_base = proc.stack_top;
/* push the receiver */
proc.stack[proc.stack_top++] = receiver;
/* push arguments */
for (i = 0; i < proc.argcount; i++) {
proc.stack[proc.stack_top++] = stx->nil;
}
/* secure space for temporaries */
for (i = 0; i < proc.tmpcount; i++)
proc.stack[proc.stack_top++] = stx->nil;
/* push dummy pc */
proc.stack[proc.stack_top++] = 0;
/* push dummy method */
proc.stack[proc.stack_top++] = stx->nil;
/* push dummy previous stack base */
proc.stack[proc.stack_top++] = 0;
n = __run_process (stx, &proc);
ase_free (proc.stack);
return n;
}
static int __run_process (ase_stx_t* stx, process_t* proc)
{
int code, next, next2;
while (proc->pc < proc->bytecode_size) {
code = proc->bytecodes[proc->pc++];
#ifdef DEBUG
ase_printf (ASE_T("code = 0x%x\n"), code);
#endif
if (code >= 0x00 && code <= 0x3F) {
/* stack - push */
__push_to_stack (stx, proc, code >> 4, code & 0x0F);
}
else if (code >= 0x40 && code <= 0x5F) {
/* stack - store */
int what = code >> 4;
int index = code & 0x0F;
__store_from_stack (stx, proc, code >> 4, code & 0x0F);
}
/* TODO: more here .... */
else if (code == 0x67) {
/* pop stack top */
proc->stack_top--;
}
/* TODO: more here .... */
else if (code == 0x6A) {
proc->stack[proc->stack_top++] = stx->nil;
}
else if (code == 0x6B) {
proc->stack[proc->stack_top++] = stx->true;
}
else if (code == 0x6C) {
proc->stack[proc->stack_top++] = stx->false;
}
else if (code == 0x6D) {
/* push receiver */
proc->stack[proc->stack_top++] = proc->receiver;
}
/* TODO: more here .... */
else if (code == 0x70) {
/* send message to self */
next = proc->bytecodes[proc->pc++];
if (__send_message (stx, proc, next >> 5,
proc->literals[next & 0x1F], ase_false) == -1) break;
}
else if (code == 0x71) {
/* send message to super */
next = proc->bytecodes[proc->pc++];
if (__send_message (stx, proc, next >> 5,
proc->literals[next & 0x1F], ase_true) == -1) break;
}
else if (code == 0x72) {
/* send message to self extended */
next = proc->bytecodes[proc->pc++];
next2 = proc->bytecodes[proc->pc++];
if (__send_message (stx, proc, next >> 5,
proc->literals[next2], ase_false) == -1) break;
}
else if (code == 0x73) {
/* send message to super extended */
next = proc->bytecodes[proc->pc++];
next2 = proc->bytecodes[proc->pc++];
if (__send_message (stx, proc, next >> 5,
proc->literals[next2], ase_true) == -1) break;
}
/* more code .... */
else if (code == 0x78) {
/* return receiver */
proc->stack[proc->stack_top++] = proc->receiver;
if (__return_from_message (stx, proc) == -1) break;
}
else if (code == 0x7C) {
/* return from message */
if (__return_from_message (stx, proc) == -1) break;
}
else if (code >= 0xF0 && code <= 0xFF) {
/* primitive */
next = proc->bytecodes[proc->pc++];
__dispatch_primitive (stx, proc, ((code & 0x0F) << 8) | next);
}
else {
ase_printf (ASE_T("INVALID OPCODE...........\n"));
break;
}
}
return 0;
}
static int __push_to_stack (ase_stx_t* stx,
process_t* proc, ase_word_t what, ase_word_t index)
{
switch (what) {
case 0: /* receiver variable */
proc->stack[proc->stack_top++] =
ASE_STX_WORD_AT(stx, proc->stack[proc->stack_base], index);
break;
case 1: /* temporary variable */
proc->stack[proc->stack_top++] =
proc->stack[proc->stack_base + 1 + index];
break;
case 2: /* literal constant */
proc->stack[proc->stack_top++] = proc->literals[index];
break;
case 3: /* literal variable */
break;
}
return 0;
}
static int __store_from_stack (ase_stx_t* stx,
process_t* proc, ase_word_t what, ase_word_t index)
{
switch (what) {
case 4: /* receiver variable */
ASE_STX_WORD_AT(stx,proc->stack[proc->stack_base],index) = proc->stack[--proc->stack_top];
break;
case 5: /* temporary location */
proc->stack[proc->stack_base + 1 + index] = proc->stack[--proc->stack_top];
break;
}
return 0;
}
static int __send_message (ase_stx_t* stx, process_t* proc,
ase_word_t nargs, ase_word_t selector, ase_bool_t to_super)
{
ase_word_t receiver, method;
ase_word_t i, tmpcount, argcount;
ase_stx_method_t* mthobj;
ase_assert (ASE_STX_CLASS(stx,selector) == stx->class_symbol);
receiver = proc->stack[proc->stack_top - nargs - 1];
method = ase_stx_lookup_method (
stx, ASE_STX_CLASS(stx,receiver),
ASE_STX_DATA(stx,selector), to_super);
if (method == stx->nil) {
ase_printf (ASE_T("cannot find the method....\n"));
return -1;
}
mthobj = (ase_stx_method_t*)ASE_STX_OBJECT(stx,method);
argcount = ASE_STX_FROM_SMALLINT(mthobj->argcount);
tmpcount = ASE_STX_FROM_SMALLINT(mthobj->tmpcount);
ase_assert (argcount == nargs);
/* secure space for temporaries */
for (i = 0; i < tmpcount; i++) {
proc->stack[proc->stack_top++] = stx->nil;
}
/* push pc */
proc->stack[proc->stack_top++] = proc->pc;
/* push method */
proc->stack[proc->stack_top++] = proc->method;
/* push previous stack base */
proc->stack[proc->stack_top++] = proc->stack_base;
proc->stack_base = proc->stack_top - 3 - tmpcount - argcount - 1;
ase_assert (proc->stack_base > 0);
proc->receiver = receiver;
proc->method = method;
proc->pc = 0;
proc->literals = mthobj->literals;
proc->bytecodes = ASE_STX_DATA(stx, mthobj->bytecodes);
proc->bytecode_size = ASE_STX_SIZE(stx, mthobj->bytecodes);
proc->argcount = argcount;
proc->tmpcount = tmpcount;
return 0;
}
static int __return_from_message (ase_stx_t* stx, process_t* proc)
{
ase_word_t method, pc, stack_base;
ase_stx_method_t* mthobj;
if (proc->stack_base == 0) {
/* return from the startup method */
return -1;
}
stack_base = proc->stack[proc->stack_base + 1 + proc->tmpcount + proc->argcount + 2];
method = proc->stack[proc->stack_base + 1 + proc->tmpcount + proc->argcount + 1];
pc = proc->stack[proc->stack_base + 1 + proc->tmpcount + proc->argcount];
mthobj = (ase_stx_method_t*)ASE_STX_OBJECT(stx,method);
ase_assert (mthobj != ASE_NULL);
/* return value is located on top of the previous stack */
proc->stack[proc->stack_base - 1] = proc->stack[proc->stack_top - 1];
/* restore the stack pointers */
proc->stack_top = proc->stack_base;
proc->stack_base = stack_base;
proc->receiver = proc->stack[stack_base];
proc->method = method;
proc->pc = pc;
proc->literals = mthobj->literals;
proc->bytecodes = ASE_STX_DATA(stx, mthobj->bytecodes);
proc->bytecode_size = ASE_STX_SIZE(stx, mthobj->bytecodes);
proc->argcount = ASE_STX_FROM_SMALLINT(mthobj->argcount);
proc->tmpcount = ASE_STX_FROM_SMALLINT(mthobj->tmpcount);
return 0;
}
static int __dispatch_primitive (ase_stx_t* stx, process_t* proc, ase_word_t no)
{
switch (no) {
case 0:
ase_printf (ASE_T("[[ hello stx smalltalk ]]\n"));
break;
case 1:
ase_printf (ASE_T("<< AMAZING STX SMALLTALK WORLD >>\n"));
break;
case 2:
ase_printf (ASE_T("<< FUNKY STX SMALLTALK >> %d\n"),
ASE_STX_FROM_SMALLINT(proc->stack[proc->stack_base + 1]));
break;
case 3:
ase_printf (ASE_T("<< HIGH STX SMALLTALK >> %d, %d\n"),
ASE_STX_FROM_SMALLINT(proc->stack[proc->stack_base + 1]),
ASE_STX_FROM_SMALLINT(proc->stack[proc->stack_base + 2]));
break;
case 20:
ase_printf (ASE_T("<< PRIMITIVE 20 >>\n"));
break;
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink