hyung-hwan/moo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

work in progress to support the named primitive via shared object loading

Browse Source
This commit is contained in:
hyunghwan.chung 2015-10-08 14:26:04 +00:00
parent 5c69f6c3b4
commit 8c963d919c
17 changed files with 1032 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

209
stix/kernel/Apex.st Normal file
View File

@ -0,0 +1,209 @@
#class Apex(nil)
{
#dcl(#class) sysdic.
## -------------------------------------------------------
## -------------------------------------------------------
#method(#class) dump
{
<primitive: #dump>
}
#method dump
{
<primitive: #dump>
}
## -------------------------------------------------------
## -------------------------------------------------------
#method(#class) yourself
{
^self.
}
#method yourself
{
^self.
}
## -------------------------------------------------------
## -------------------------------------------------------
#method(#class) new
{
<primitive: #new>
self primitiveFailed.
}
#method(#class) new: anInteger
{
<primitive: #newWithSize>
self primitiveFailed.
}
## -------------------------------------------------------
## -------------------------------------------------------
#method class
{
<primitive: #class>
}
#method(#class) class
{
<primitive: #class>
^Class
}
## -------------------------------------------------------
## -------------------------------------------------------
#method basicSize
{
<primitive: #basicSize>
^0
}
#method basicAt: anInteger
{
<primitive: #basicAt>
self error: 'out of range'.
}
#method basicAt: anInteger put: anObject
{
<primitive: #basicAtPut>
self error: 'out of range'.
}
#method(#class) basicSize
{
<primitive: #basicSize>
^0
}
#method(#class) basicAt: anInteger
{
<primitive: #basicAt>
self error: 'out of range'.
}
#method(#class) basicAt: anInteger put: anObject
{
<primitive: #basicAtPut>
self error: 'out of range'.
}
## -------------------------------------------------------
## -------------------------------------------------------
#method == anObject
{
"check if the receiver is identical to anObject.
this doesn't compare the contents"
<primitive: #identical>
}
#method ~~ anObject
{
<primitive: #notIdentical>
^(self == anObject) not.
}
#method(#class) == anObject
{
"check if the receiver is identical to anObject.
this doesn't compare the contents"
<primitive: #identical>
}
#method(#class) ~~ anObject
{
<primitive: #notIdentical>
^(self == anObject) not.
}
## TODO: add = and ~= for equality check.
#method isNil
{
"^self == nil."
^false
}
#method notNil
{
"^(self == nil) not"
"^self ~= nil."
^true.
}
#method(#class) isNil
{
"^self == nil."
^false
}
#method(#class) notNil
{
"^(self == nil) not"
"^self ~= nil."
^true.
}
## -------------------------------------------------------
## -------------------------------------------------------
"
#method(#class) respondsTo: selectorSymbol
{
TODO: find selectorSymbol in the class method dictionary...
}
#method respondsTo: selectorSymbol
{
TODO: find selectorSymbol in the method dictionary...
}
"
## -------------------------------------------------------
## -------------------------------------------------------
#method(#class) primitiveFailed
{
## TODO: implement this
## PrimitiveFailureError signal.
'primitive failed' dump.
}
#method primitiveFailed
{
self class primitiveFailed.
}
#method(#class) doesNotUnderstand: messageSymbol
{
## TODO: implement this
## UnrecognizedMessage signal.
'does not understand' dump.
}
#method doesNotUnderstand: messageSymbol
{
self class doesNotUnderstand: messageSymbol
}
#method(#class) error: msgText
{
## TODO: implement this
## Error signal: msgText.
msgText dump.
}
#method error: aString
{
self class error: aString.
}
}

93
stix/kernel/Boolean.st Normal file
View File

@ -0,0 +1,93 @@
#class Boolean(Object)
{
"TODO: do i need to really define methods defined in True and False here?
and call subclassResponsibiltiy?"
}
#class True(Boolean)
{
#method not
{
^false
}
#method & aBoolean
{
^aBoolean
}
#method | aBoolean
{
^true
}
#method and: aBlock
{
^aBlock value
}
#method or: aBlock
{
^true
}
#method ifTrue: trueBlock ifFalse: falseBlock
{
^trueBlock value.
}
#method ifTrue: trueBlock
{
^trueBlock value.
}
#method ifFalse: falseBlock
{
^nil.
}
}
#class False(Boolean)
{
#method not
{
^true
}
#method & aBoolean
{
^false
}
#method | aBoolean
{
^aBoolean
}
#method and: aBlock
{
^false
}
#method or: aBlock
{
^aBlock value
}
#method ifTrue: trueBlock ifFalse: falseBlock
{
^falseBlock value.
}
#method ifTrue: trueBlock
{
^nil.
}
#method ifFalse: falseBlock
{
^falseBlock value.
}
}

5
stix/kernel/Class.st Normal file
View File

@ -0,0 +1,5 @@
#class(#pointer) Class(Apex)
{
#dcl spec selfspec superclass subclasses name instvars classvars classinstvars pooldics instmthdic classmthdic.
}

40
stix/kernel/Collection-Array.st Normal file
View File

@ -0,0 +1,40 @@
#class(#pointer) Array(Collection)
{
#method size
{
^self basicSize.
}
#method at: anInteger
{
^self basicAt: anInteger.
}
#method at: anInteger put: aValue
{
^self basicAt: anInteger put: aValue.
}
#method first
{
^self at: 1.
}
#method last
{
^self at: self size.
}
#method do: aBlock
{
1 to: self size do: [:i | aBlock value: (self at: i)].
}
}
#class(#character) String(Array)
{
}
#class(#character) Symbol(Array)
{
}

13
stix/kernel/Collection-ByteArray.st Normal file
View File

@ -0,0 +1,13 @@
#class(#byte) ByteArray(Collection)
{
#method at: anInteger
{
^self basicAt: anInteger.
}
#method at: anInteger put: aValue
{
^self basicAt: anInteger put: aValue.
}
}

31
stix/kernel/Collection-Set.st Normal file
View File

@ -0,0 +1,31 @@
#class Set(Collection)
{
#dcl tally bucket.
}
#class SymbolSet(Set)
{
}
#class Dictionary(Set)
{
}
#class SystemDictionary(Dictionary)
{
}
#class Namespace(Set)
{
}
#class PoolDictionary(Set)
{
}
#class MethodDictionary(Dictionary)
{
}

3
stix/kernel/Collection.st Normal file
View File

@ -0,0 +1,3 @@
#class Collection(Object)
{
}

37
stix/kernel/Number.st Normal file
View File

@ -0,0 +1,37 @@
#class Number(Magnitude)
{
#method add: aNumber
{
<primitive: 7>
}
#method + aNumber
{
<primitive: 7>
}
#method - aNumber
{
<primitive: 8>
}
#method * aNumber
{
<primitive: 8>
}
#method = aNumber
{
<primitive: 10>
}
#method < aNumber
{
<primitive: 11>
}
#method > aNumber
{
<primitive: 12>
}
}

4
stix/kernel/Object.st Normal file
View File

@ -0,0 +1,4 @@
#class Object(Apex)
{
}

273
stix/lib/Stix.st → stix/kernel/Stix.st
View File

@ -1,98 +1,19 @@
#class Apex(nil)
#include 'Apex.st'.
#include 'Object.st'.
#include 'UndefinedObject.st'.
#include 'Class.st'.
#include 'Boolean.st'.
#class Error(Object)
{
#dcl(#class) sysdic.
#method(#class) yourself
#method(#class) signal: aString
{
^self.
}
#method yourself
{
^self.
}
#method(#class) dump
{
<primitive: #dump>
}
#method dump
{
<primitive: #dump>
}
#method(#class) new
{
## <primitive: 1>
<primitive: #new>
}
#method(#class) new: anInteger
{
## <primitive: 2>
<primitive: #newWithSize>
}
#method basicSize
{
## <primitive: 3>
<primitive: #basicSize>
^0
}
#method basicAt: anInteger
{
## <primitive: 4>
<primitive: #basicAt>
## self error: 'out of range'.
}
#method basicAt: anInteger put: anObject
{
## <primitive: 5>
<primitive: #basicAtPut>
## self error: 'out of range'.
}
#method badReturnError
{
## TODO: implement this
}
#method mustBeBoolean
{
## TODO: implement this
}
#method doesNotUnderstand: aMessageSymbol
{
## TODO: implement this
}
#method error: anErrorString
{
anErrorString dump.
"accept an arbitary object instead of a string.
the object can be sent displayString for string conversion"
}
}
#class Object(Apex)
{
}
#class UndefinedObject(Apex)
{
}
#class(#pointer) Class(Apex)
{
#dcl spec selfspec superclass subclasses name instvars classvars classinstvars pooldics instmthdic classmthdic.
}
#class Magnitude(Object)
{
}
@ -142,122 +63,43 @@
{
<primitive: #integerGT>
}
#method to: end by: step do: aBlock
{
| i |
i := self.
(step > 0)
ifTrue: [
[ i <= end ] whileTrue: [
aBlock value: i.
i := i + step.
]
]
ifFalse: [
[ i >= end ] whileTrue: [
aBlock value: i.
i := i - step.
]
].
}
#method to: end do: aBlock
{
^self to: end by: 1 do: aBlock.
}
}
#class SmallInteger(Number)
{
}
#class Boolean(Object)
{
#include 'Collection.st'.
#include 'Collection-ByteArray.st'.
#include 'Collection-Array.st'.
#include 'Collection-Set.st'.
}
#class True(Boolean)
{
#method ifTrue: trueBlock ifFalse: falseBlock
{
^trueBlock value.
}
#method ifTrue: trueBlock
{
^trueBlock value.
}
#method ifFalse: falseBlock
{
^nil.
}
}
#class False(Boolean)
{
#method ifTrue: trueBlock ifFalse: falseBlock
{
^falseBlock value.
}
#method ifTrue: trueBlock
{
^nil.
}
#method ifFalse: falseBlock
{
^falseBlock value.
}
}
#class Collection(Object)
{
}
#class(#byte) ByteArray(Collection)
{
#method at: anInteger
{
^self basicAt: anInteger.
}
#method at: anInteger put: aValue
{
^self basicAt: anInteger put: aValue.
}
}
#class(#pointer) Array(Collection)
{
#method at: anInteger
{
^self basicAt: anInteger.
}
#method at: anInteger put: aValue
{
^self basicAt: anInteger put: aValue.
}
}
#class(#character) String(Array)
{
}
#class(#character) Symbol(Array)
{
}
#class Set(Collection)
{
#dcl tally bucket.
}
#class SymbolSet(Set)
{
}
#class Dictionary(Set)
{
}
#class SystemDictionary(Dictionary)
{
}
#class Namespace(Set)
{
}
#class PoolDictionary(Set)
{
}
#class MethodDictionary(Dictionary)
{
}
#class(#pointer) Context(Apex)
{
@ -391,11 +233,29 @@
{
ip := source pc.
}
"------ TODO: -------------------------------------"
#method on: anError do: anExceptionBlock
{
"TODO: handle if anError is an ErrorSet .."
}
#method ensure: aBlock
{
}
#method ifCurtailed: aBlock
{
}
"------ TODO: -------------------------------------"
}
#class(#pointer) CompiledMethod(Object)
{
#dcl owner preamble ntmprs nargs code source.
#dcl owner preamble preamble_data_1 preamble_data_2 ntmprs nargs code source.
}
@ -413,6 +273,14 @@
self.funcs := Dictionary new.
self.name := aString.
self.handle := self privateOpen: self.name.
"[ self.handle := self privateOpen: self.name ]
on: Error do: [
]
on: XError do: [
]."
^self.
}
#method close
@ -432,7 +300,7 @@
## self.funcs at: aFunctionName put: f.
## ].
f := self privateGetSymbol: aFunctionName in: self.handle.
## f isNil ifTrue: [ self error: 'No such function' ].
f isNil ifTrue: [ self error: 'No such function' ].
^self privateCall: f withSig: aString withArgs: anArray
}
@ -440,7 +308,7 @@ f := self privateGetSymbol: aFunctionName in: self.handle.
#method privateOpen: aString
{
<primitive: #ffiOpen>
## throw an exception here.
^nil. ## TODO: Error signal: 'can not open'
}
#method privateClose: aHandle
@ -456,6 +324,7 @@ f := self privateGetSymbol: aFunctionName in: self.handle.
#method privateGetSymbol: aString in: aHandle
{
<primitive: #ffiGetSym>
^nil.
}
}

12
stix/kernel/UndefinedObject.st Normal file
View File

@ -0,0 +1,12 @@
#class UndefinedObject(Apex)
{
#method isNil
{
^true
}
#method notNil
{
^false.
}
}

17
stix/lib/test-005.st → stix/kernel/test-005.st
View File

@ -224,14 +224,27 @@
[self getTen] value dump.
}
#method(#class) abc
{
<primitive: #abc_integer_add>
}
#method(#class) main
{
| ffi |
"| ffi |
ffi := FFI new: 'libc.so.6'.
## ffi call: #printf with: #((str '%d') (int 10) (long 20)).
ffi call: #printf withSig: 'i|sii' withArgs: #(S'hello world %d %d\n' 11123 9876543).
## ffi call: #puts withSig: 'i|s' withArgs: #('hello world').
ffi close.
ffi close."
self abc.
FFI isNil dump.
FFI notNil dump.
nil isNil dump.
nil notNil dump.
nil class dump.
nil class class class dump.
}
}

49
stix/lib/comp.c
View File

@ -1493,13 +1493,13 @@ static const stix_uch_t* add_io_name (stix_t* stix, const stix_ucs_t* name)
static int begin_include (stix_t* stix)
{
stix_ioarg_t* arg;
stix_io_arg_t* arg;
const stix_uch_t* io_name;
io_name = add_io_name (stix, &stix->c->tok.name);
if (!io_name) return -1;
arg = (stix_ioarg_t*) stix_callocmem (stix, STIX_SIZEOF(*arg));
arg = (stix_io_arg_t*) stix_callocmem (stix, STIX_SIZEOF(*arg));
if (!arg) goto oops;
arg->name = io_name;
@ -1546,7 +1546,7 @@ oops:
static int end_include (stix_t* stix)
{
int x;
stix_ioarg_t* cur;
stix_io_arg_t* cur;
if (stix->c->curinp == &stix->c->arg) return 0; /* no include */
@ -2561,8 +2561,10 @@ static int compile_method_primitive (stix_t* stix)
set_syntax_error (stix, STIX_SYNERR_PRIMITIVE, &stix->c->tok.loc, &stix->c->tok.name);
return -1;
}
/* TODO: other modifiers?
/* TODO: other modifiers than primitive: ?
* <primitive: 10>
* <primitive: #primitive_name>
* <some-other-modifier: xxxx>
*/
@ -2593,6 +2595,23 @@ static int compile_method_primitive (stix_t* stix)
prim_no = stix_getprimno (stix, &stix->c->tok.name);
if (prim_no <= -1)
{
const stix_uch_t* us;
/* the primitive is not found */
us = stix_findchar (stix->c->tok.name.ptr, stix->c->tok.name.len, '_');
if (us > stix->c->tok.name.ptr && us < stix->c->tok.name.ptr + stix->c->tok.name.len - 1)
{
stix_size_t lit_idx;
/* the symbol literal contains an underscore.
* and it is none of the first of the last character */
if (add_symbol_literal(stix, &stix->c->tok.name, &lit_idx) >= 0 &&
STIX_OOI_IN_PREAMBLE_INDEX_RANGE(lit_idx))
{
stix->c->mth.prim_type = 2; /* named primitive */
stix->c->mth.prim_no = lit_idx;
break;
}
}
set_syntax_error (stix, STIX_SYNERR_PRIMNO, &stix->c->tok.loc, &stix->c->tok.name);
return -1;
}
@ -2601,6 +2620,8 @@ static int compile_method_primitive (stix_t* stix)
set_syntax_error (stix, STIX_SYNERR_PRIMNO, &stix->c->tok.loc, &stix->c->tok.name);
return -1;
}
stix->c->mth.prim_type = 1;
stix->c->mth.prim_no = prim_no;
break;
@ -4086,8 +4107,9 @@ static int add_compiled_method (stix_t* stix)
preamble_code = STIX_METHOD_PREAMBLE_NONE;
preamble_index = 0;
if (stix->c->mth.prim_no < 0)
if (stix->c->mth.prim_type <= 0)
{
/* no primitive is set */
if (stix->c->mth.code.len <= 0)
{
preamble_code = STIX_METHOD_PREAMBLE_RETURN_RECEIVER;
@ -4186,13 +4208,19 @@ static int add_compiled_method (stix_t* stix)
}
}
}
else
else if (stix->c->mth.prim_type == 1)
{
preamble_code = STIX_METHOD_PREAMBLE_PRIMITIVE;
preamble_index = stix->c->mth.prim_no;
}
else
{
STIX_ASSERT (stix->c->mth.prim_type == 2);
preamble_code = STIX_METHOD_PREAMBLE_NAMED_PRIMITIVE;
preamble_index = stix->c->mth.prim_no;
}
STIX_ASSERT (preamble_index >= 0 && preamble_index <= 0xFFFF); /* TODO: replace 0xFFFF by a proper macro name */
STIX_ASSERT (STIX_OOI_IN_PREAMBLE_INDEX_RANGE(preamble_index));
mth->owner = stix->c->cls.self_oop;
mth->preamble = STIX_OOP_FROM_SMINT(STIX_METHOD_MAKE_PREAMBLE(preamble_code, preamble_index));
@ -4236,7 +4264,8 @@ static int compile_method_definition (stix_t* stix)
stix->c->mth.literal_count = 0;
stix->c->mth.balit_count = 0;
stix->c->mth.arlit_count = 0;
stix->c->mth.prim_no = -1;
stix->c->mth.prim_type = 0;
stix->c->mth.prim_no = 0;
stix->c->mth.blk_depth = 0;
stix->c->mth.code.len = 0;
@ -5089,7 +5118,7 @@ static void fini_compiler (stix_t* stix)
}
}
int stix_compile (stix_t* stix, stix_ioimpl_t io)
int stix_compile (stix_t* stix, stix_io_impl_t io)
{
int n;
@ -5158,7 +5187,7 @@ oops:
* closed. close them */
while (stix->c->curinp != &stix->c->arg)
{
stix_ioarg_t* prev;
stix_io_arg_t* prev;
/* nothing much to do about a close error */
stix->c->impl (stix, STIX_IO_CLOSE, stix->c->curinp);

461
stix/lib/exec.c
View File

@ -91,6 +91,18 @@
#endif
#if defined(STIX_DEBUG_EXEC)
# define DBGOUT_EXEC_0(fmt) printf(fmt "\n")
# define DBGOUT_EXEC_1(fmt,a1) printf(fmt "\n",a1)
# define DBGOUT_EXEC_2(fmt,a1,a2) printf(fmt "\n", a1, a2)
# define DBGOUT_EXEC_3(fmt,a1,a2,a3) printf(fmt "\n", a1, a2, a3)
#else
# define DBGOUT_EXEC_0(fmt)
# define DBGOUT_EXEC_1(fmt,a1)
# define DBGOUT_EXEC_2(fmt,a1,a2)
# define DBGOUT_EXEC_3(fmt,a1,a2,a3)
#endif
static STIX_INLINE int activate_new_method (stix_t* stix, stix_oop_method_t mth)
{
stix_oop_context_t ctx;
@ -199,7 +211,9 @@ static STIX_INLINE int activate_new_method (stix_t* stix, stix_oop_method_t mth)
/* swtich the active context */
SWITCH_ACTIVE_CONTEXT (stix, ctx);
#if defined(STIX_DEBUG_EXEC)
printf ("<<ENTERING>> SP=%d\n", (int)stix->sp);
#endif
return 0;
#if 0
@ -208,16 +222,20 @@ reuse_context:
ctx->_class = stix->_method_context;
ctx->receiver_or_source = ACTIVE_STACK_GET(stix, stix->sp - nargs);
#if defined(STIX_DEBUG_EXEC)
printf ("####### REUSING CONTEXT INSTEAD OF <<ENTERING>> WITH RECEIVER ");
print_object (stix, ctx->receiver_or_source);
printf ("\n");
#endif
for (i = 0; i < nargs; i++)
{
ctx->slot[i] = ACTIVE_STACK_GET (stix, stix->sp - nargs + i + 1);
#if defined(STIX_DEBUG_EXEC)
printf ("REUSING ARGUMENT %d - ", (int)i);
print_object (stix, ctx->slot[i]);
printf ("\n");
#endif
}
for (; i <= stix->sp; i++) ctx->slot[i] = stix->_nil;
/* keep the sender
@ -248,9 +266,11 @@ static stix_oop_method_t find_method (stix_t* stix, stix_oop_t receiver, const s
int dic_no;
/* TODO: implement method lookup cache */
#if defined(STIX_DEBUG_EXEC)
printf ("==== FINDING METHOD FOR %p [", receiver);
print_ucs (message);
printf ("] in ");
#endif
cls = (stix_oop_class_t)STIX_CLASSOF(stix, receiver);
if ((stix_oop_t)cls == stix->_class)
@ -258,17 +278,21 @@ printf ("] in ");
/* receiver is a class object */
c = receiver;
dic_no = STIX_CLASS_MTHDIC_CLASS;
#if defined(STIX_DEBUG_EXEC)
printf ("class method dictioanry of ");
print_object(stix, (stix_oop_t)((stix_oop_class_t)c)->name);
printf ("\n");
#endif
}
else
{
c = (stix_oop_t)cls;
dic_no = STIX_CLASS_MTHDIC_INSTANCE;
#if defined(STIX_DEBUG_EXEC)
printf ("instance method dictioanry of ");
print_object(stix, (stix_oop_t)((stix_oop_class_t)c)->name);
printf ("\n");
#endif
}
@ -384,6 +408,49 @@ static int primitive_dump (stix_t* stix, stix_ooi_t nargs)
return 1; /* success */
}
static int primitive_identical (stix_t* stix, stix_ooi_t nargs)
{
stix_oop_t rcv, arg, b;
STIX_ASSERT (nargs == 1);
rcv = ACTIVE_STACK_GET(stix, stix->sp - 1);
arg = ACTIVE_STACK_GET(stix, stix->sp);
b = (rcv == arg)? stix->_true: stix->_false;
ACTIVE_STACK_POP (stix);
ACTIVE_STACK_SETTOP (stix, b);
return 1;
}
static int primitive_not_identical (stix_t* stix, stix_ooi_t nargs)
{
stix_oop_t rcv, arg, b;
STIX_ASSERT (nargs == 1);
rcv = ACTIVE_STACK_GET(stix, stix->sp - 1);
arg = ACTIVE_STACK_GET(stix, stix->sp);
b = (rcv != arg)? stix->_true: stix->_false;
ACTIVE_STACK_POP (stix);
ACTIVE_STACK_SETTOP (stix, b);
return 1;
}
static int primitive_class (stix_t* stix, stix_ooi_t nargs)
{
stix_oop_t rcv, c;
STIX_ASSERT (nargs == 0);
rcv = ACTIVE_STACK_GETTOP (stix);
c = STIX_CLASSOF(stix, rcv);
ACTIVE_STACK_SETTOP (stix, c);
return 1; /* success */
}
static int primitive_new (stix_t* stix, stix_ooi_t nargs)
{
stix_oop_t rcv, obj;
@ -504,7 +571,7 @@ static int primitive_basic_at (stix_t* stix, stix_ooi_t nargs)
break;
case STIX_OBJ_TYPE_WORD:
/* TODO: largeINteger if the word is too large */
/* TODO: LargeInteger if the word is too large */
v = STIX_OOP_FROM_SMINT(((stix_oop_word_t)rcv)->slot[idx]);
break;
@ -623,7 +690,9 @@ static int primitive_block_value (stix_t* stix, stix_ooi_t nargs)
org_blkctx = (stix_oop_context_t)ACTIVE_STACK_GET(stix, stix->sp - nargs);
if (STIX_CLASSOF(stix, org_blkctx) != stix->_block_context)
{
#if defined(STIX_DEBUG_EXEC)
printf ("PRIMITVE VALUE RECEIVER IS NOT A BLOCK CONTEXT\n");
#endif
return 0;
}
@ -635,7 +704,9 @@ printf ("PRIMITVE VALUE RECEIVER IS NOT A BLOCK CONTEXT\n");
* For example, [thisContext value] value.
*/
STIX_ASSERT (STIX_OBJ_GET_SIZE(org_blkctx) > STIX_CONTEXT_NAMED_INSTVARS);
#if defined(STIX_DEBUG_EXEC)
printf ("PRIM REVALUING AN BLOCKCONTEXT\n");
#endif
return 0;
}
STIX_ASSERT (STIX_OBJ_GET_SIZE(org_blkctx) == STIX_CONTEXT_NAMED_INSTVARS);
@ -643,8 +714,10 @@ printf ("PRIM REVALUING AN BLOCKCONTEXT\n");
if (STIX_OOP_TO_SMINT(org_blkctx->method_or_nargs) != nargs)
{
/* the number of argument doesn't match */
#if defined(STIX_DEBUG_EXEC)
/* TODO: better handling of primitive failure */
printf ("PRIM BlockContext value FAIL - NARGS MISMATCH\n");
#endif
return 0;
}
@ -669,8 +742,10 @@ printf ("PRIM BlockContext value FAIL - NARGS MISMATCH\n");
blkctx->receiver_or_source = (stix_oop_t)org_blkctx;
blkctx->home = org_blkctx->home;
blkctx->origin = org_blkctx->origin;
#if defined(STIX_DEBUG_EXEC)
printf ("~~~~~~~~~~ BLOCK VALUING %p TO NEW BLOCK %p\n", org_blkctx, blkctx);
#endif
#endif
/* TODO: check the stack size of a block context to see if it's large enough to hold arguments */
/* copy the arguments to the stack */
@ -692,7 +767,9 @@ printf ("~~~~~~~~~~ BLOCK VALUING %p TO NEW BLOCK %p\n", org_blkctx, blkctx);
blkctx->sp = STIX_OOP_FROM_SMINT(local_ntmprs);
blkctx->sender = (stix_oop_t)stix->active_context;
#if defined(STIX_DEBUG_EXEC)
printf ("<<ENTERING BLOCK>>\n");
#endif
SWITCH_ACTIVE_CONTEXT (stix, (stix_oop_context_t)blkctx);
return 1;
}
@ -1242,6 +1319,10 @@ typedef struct primitive_t primitive_t;
static primitive_t primitives[] =
{
{ -1, primitive_dump, "dump" },
{ 1, primitive_identical, "identical" },
{ 1, primitive_not_identical, "notIdentical" },
{ 0, primitive_class, "class" },
{ 0, primitive_new, "new" },
{ 1, primitive_new_with_size, "newWithSize" },
{ 0, primitive_basic_size, "basicSize" },
@ -1282,6 +1363,171 @@ int stix_getprimno (stix_t* stix, const stix_ucs_t* name)
return -1;
}
static stix_mod_t* query_primitive_module (stix_t* stix, const stix_uch_t* name)
{
stix_rbt_pair_t* pair;
stix_mod_data_t* mdp;
stix_cstr_t ea;
int n;
STIX_ASSERT (nsegs == 2);
pair = stix_rbt_search (stix->modtab, segs[0].ptr, segs[0].len);
if (pair)
{
mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
}
else
{
stix_mod_data_t md;
stix_mod_load_t load = STIX_NULL;
stix_mod_spec_t spec;
stix_size_t buflen;
/*stix_char_t buf[64 + 15] = STIX_T("_stix_mod_");*/
/* maximum module name length is 64. 15 is decomposed to 13 + 1 + 1.
* 13 for _stix_mod_t
* 1 for _ at the end when stix_mod_xxx_ is attempted.
* 1 for the terminating '\0'
*/
stix_char_t buf[64 + 15];
/* the terminating null isn't needed in buf here */
STIX_MEMCPY (buf, STIX_T("_stix_mod_"), STIX_SIZEOF(stix_char_t) * 13);
if (segs[0].len > STIX_COUNTOF(buf) - 15)
{
/* module name too long */
ea.ptr = segs[0].ptr;
ea.len = segs[0].len;
stix_seterror (stix, STIX_ESEGTL, &ea, STIX_NULL);
return STIX_NULL;
}
#if defined(STIX_ENABLE_STATIC_MODULE)
/* attempt to find a statically linked module */
/* TODO: binary search ... */
for (n = 0; n < STIX_COUNTOF(static_modtab); n++)
{
if (stix_strcmp (static_modtab[n].modname, segs[0].ptr) == 0)
{
load = static_modtab[n].modload;
break;
}
}
/*if (n >= STIX_COUNTOF(static_modtab))
{
ea.ptr = segs[0].ptr;
ea.len = segs[0].len;
stix_seterror (stix, STIX_ENOENT, &ea, STIX_NULL);
return STIX_NULL;
}*/
if (load)
{
/* found the module in the staic module table */
STIX_MEMSET (&md, 0, STIX_SIZEOF(md));
/* Note md.handle is STIX_NULL for a static module */
/* i copy-insert 'md' into the table before calling 'load'.
* to pass the same address to load(), query(), etc */
pair = stix_rbt_insert (stix->modtab, segs[0].ptr, segs[0].len, &md, STIX_SIZEOF(md));
if (pair == STIX_NULL)
{
stix_seterrnum (stix, STIX_ENOMEM, STIX_NULL);
return STIX_NULL;
}
mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
if (load (&mdp->mod, stix) <= -1)
{
stix_rbt_delete (stix->modtab, segs[0].ptr, segs[0].len);
return STIX_NULL;
}
goto done;
}
#endif
/* attempt to find an external module */
STIX_MEMSET (&spec, 0, STIX_SIZEOF(spec));
if (stix->opt.mod[0].len > 0)
spec.prefix = stix->opt.mod[0].ptr;
else spec.prefix = STIX_T(STIX_DEFAULT_MODPREFIX);
if (stix->opt.mod[1].len > 0)
spec.postfix = stix->opt.mod[1].ptr;
else spec.postfix = STIX_T(STIX_DEFAULT_MODPOSTFIX);
STIX_MEMSET (&md, 0, STIX_SIZEOF(md));
if (stix->prm.modopen && stix->prm.modsym && stix->prm.modclose)
{
spec.name = segs[0].ptr;
md.handle = stix->prm.modopen (stix, &spec);
}
else md.handle = STIX_NULL;
if (md.handle == STIX_NULL)
{
ea.ptr = segs[0].ptr;
ea.len = segs[0].len;
stix_seterror (stix, STIX_ENOENT, &ea, STIX_NULL);
return STIX_NULL;
}
buflen = stix_strcpy (&buf[13], segs[0].ptr);
/* attempt stix_mod_xxx */
load = stix->prm.modsym (stix, md.handle, &buf[1]);
if (!load)
{
/* attempt _stix_mod_xxx */
load = stix->prm.modsym (stix, md.handle, &buf[0]);
if (!load)
{
/* attempt stix_mod_xxx_ */
buf[13 + buflen] = STIX_T('_');
buf[13 + buflen + 1] = STIX_T('\0');
load = stix->prm.modsym (stix, md.handle, &buf[1]);
if (!load)
{
ea.ptr = &buf[1];
ea.len = 12 + buflen;
stix_seterror (stix, STIX_ENOENT, &ea, STIX_NULL);
stix->prm.modclose (stix, md.handle);
return STIX_NULL;
}
}
}
/* i copy-insert 'md' into the table before calling 'load'.
* to pass the same address to load(), query(), etc */
pair = stix_rbt_insert (stix->modtab, segs[0].ptr, segs[0].len, &md, STIX_SIZEOF(md));
if (pair == STIX_NULL)
{
stix_seterrnum (stix, STIX_ENOMEM, STIX_NULL);
stix->prm.modclose (stix, md.handle);
return STIX_NULL;
}
mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
if (load (&mdp->mod, stix) <= -1)
{
stix_rbt_delete (stix->modtab, segs[0].ptr, segs[0].len);
stix->prm.modclose (stix, mdp->handle);
return STIX_NULL;
}
}
done:
n = mdp->mod.query (&mdp->mod, stix, segs[1].ptr, sym);
return (n <= -1)? STIX_NULL: &mdp->mod;
}
/* ------------------------------------------------------------------------- */
int stix_execute (stix_t* stix)
@ -1290,12 +1536,12 @@ int stix_execute (stix_t* stix)
stix_ooi_t b1, b2;
stix_oop_t return_value;
stix_size_t inst_counter;
#if defined(STIX_PROFILE_EXEC)
stix_size_t inst_counter = 0;
#endif
STIX_ASSERT (stix->active_context != STIX_NULL);
inst_counter = 0;
while (1)
{
@ -1308,7 +1554,10 @@ printf ("IP => %d ", (int)stix->ip);
#if 0
printf ("BCODE = %x\n", bcode);
#endif
inst_counter++;
#if defined(STIX_PROFILE_EXEC)
inst_counter++;
#endif
switch (bcode)
{
@ -1327,7 +1576,7 @@ inst_counter++;
case BCODE_PUSH_INSTVAR_7:
b1 = bcode & 0x7; /* low 3 bits */
push_instvar:
printf ("PUSH_INSTVAR %d\n", (int)b1);
DBGOUT_EXEC_1 ("PUSH_INSTVAR %d", (int)b1);
STIX_ASSERT (STIX_OBJ_GET_FLAGS_TYPE(stix->active_context->origin->receiver_or_source) == STIX_OBJ_TYPE_OOP);
ACTIVE_STACK_PUSH (stix, ((stix_oop_oop_t)stix->active_context->origin->receiver_or_source)->slot[b1]);
break;
@ -1347,7 +1596,7 @@ printf ("PUSH_INSTVAR %d\n", (int)b1);
case BCODE_STORE_INTO_INSTVAR_7:
b1 = bcode & 0x7; /* low 3 bits */
store_instvar:
printf ("STORE_INTO_INSTVAR %d\n", (int)b1);
DBGOUT_EXEC_1 ("STORE_INTO_INSTVAR %d", (int)b1);
STIX_ASSERT (STIX_OBJ_GET_FLAGS_TYPE(stix->active_context->receiver_or_source) == STIX_OBJ_TYPE_OOP);
((stix_oop_oop_t)stix->active_context->origin->receiver_or_source)->slot[b1] = ACTIVE_STACK_GETTOP(stix);
break;
@ -1366,7 +1615,7 @@ printf ("STORE_INTO_INSTVAR %d\n", (int)b1);
case BCODE_POP_INTO_INSTVAR_7:
b1 = bcode & 0x7; /* low 3 bits */
pop_into_instvar:
printf ("POP_INTO_INSTVAR %d\n", (int)b1);
DBGOUT_EXEC_1 ("POP_INTO_INSTVAR %d", (int)b1);
STIX_ASSERT (STIX_OBJ_GET_FLAGS_TYPE(stix->active_context->receiver_or_source) == STIX_OBJ_TYPE_OOP);
((stix_oop_oop_t)stix->active_context->origin->receiver_or_source)->slot[b1] = ACTIVE_STACK_GETTOP(stix);
ACTIVE_STACK_POP (stix);
@ -1452,8 +1701,7 @@ printf ("POP_INTO_INSTVAR %d\n", (int)b1);
if ((bcode >> 4) & 1)
{
/* push - bit 4 on*/
printf ("PUSH_TEMPVAR %d - ", (int)b1);
DBGOUT_EXEC_1 ("PUSH_TEMPVAR %d", (int)b1);
ACTIVE_STACK_PUSH (stix, ctx->slot[bx]);
}
else
@ -1464,18 +1712,18 @@ printf ("PUSH_TEMPVAR %d - ", (int)b1);
if ((bcode >> 3) & 1)
{
/* pop - bit 3 on */
DBGOUT_EXEC_1 ("POP_INTO_TEMPVAR %d", (int)b1);
ACTIVE_STACK_POP (stix);
printf ("POP_INTO_TEMPVAR %d - ", (int)b1);
}
else
{
printf ("STORE_INTO_TEMPVAR %d - ", (int)b1);
}
else
{
DBGOUT_EXEC_1 ("STORE_INTO_TEMPVAR %d", (int)b1);
}
}
print_object (stix, ctx->slot[bx]);
printf ("\n");
/*
print_object (stix, ctx->slot[bx]);
printf ("\n");
*/
break;
}
@ -1494,9 +1742,11 @@ printf ("\n");
case BCODE_PUSH_LITERAL_7:
b1 = bcode & 0x7; /* low 3 bits */
push_literal:
printf ("PUSH_LITERAL idx=%d - ", (int)b1);
print_object (stix, stix->active_method->slot[b1]);
printf ("\n");
DBGOUT_EXEC_1 ("PUSH_LITERAL %d", (int)b1);
/*
print_object (stix, stix->active_method->slot[b1]);
printf ("\n");
*/
ACTIVE_STACK_PUSH (stix, stix->active_method->slot[b1]);
break;
@ -1535,19 +1785,19 @@ printf ("\n");
if ((bcode >> 2) & 1)
{
/* pop */
DBGOUT_EXEC_1("POP_INTO_OBJECT %d", (int)b1);
ACTIVE_STACK_POP (stix);
printf ("POP_INTO_OBJECT %d - ", (int)b1);
}
else
{
printf ("STORE_INTO_OBJECT %d - ", (int)b1);
}
else
{
DBGOUT_EXEC_1("STORE_INTO_OBJECT %d", (int)b1);
}
}
else
{
/* push */
DBGOUT_EXEC_1("PUSH_OBJECT %d", (int)b1);
ACTIVE_STACK_PUSH (stix, ass->value);
printf ("PUSH_OBJECT %d - ", (int)b1);
}
break;
}
@ -1556,7 +1806,7 @@ printf ("PUSH_OBJECT %d - ", (int)b1);
case BCODE_JUMP_FORWARD_X:
FETCH_PARAM_CODE_TO (stix, b1);
printf ("JUMP_FORWARD %d\n", (int)b1);
DBGOUT_EXEC_1 ("JUMP_FORWARD %d", (int)b1);
stix->ip += b1;
break;
@ -1564,13 +1814,13 @@ printf ("JUMP_FORWARD %d\n", (int)b1);
case BCODE_JUMP_FORWARD_1:
case BCODE_JUMP_FORWARD_2:
case BCODE_JUMP_FORWARD_3:
printf ("JUMP_FORWARD %d\n", (int)(bcode & 0x3));
DBGOUT_EXEC_1 ("JUMP_FORWARD %d", (int)(bcode & 0x3));
stix->ip += (bcode & 0x3); /* low 2 bits */
break;
case BCODE_JUMP_BACKWARD_X:
FETCH_PARAM_CODE_TO (stix, b1);
printf ("JUMP_BACKWARD %d\n", (int)b1);
DBGOUT_EXEC_1 ("JUMP_BACKWARD %d", (int)b1);
stix->ip += b1;
break;
@ -1578,7 +1828,7 @@ printf ("JUMP_BACKWARD %d\n", (int)b1);
case BCODE_JUMP_BACKWARD_1:
case BCODE_JUMP_BACKWARD_2:
case BCODE_JUMP_BACKWARD_3:
printf ("JUMP_BACKWARD %d\n", (int)(bcode & 0x3));
DBGOUT_EXEC_1 ("JUMP_BACKWARD %d", (int)(bcode & 0x3));
stix->ip -= (bcode & 0x3); /* low 2 bits */
break;
@ -1598,14 +1848,14 @@ return -1;
case BCODE_JUMP2_FORWARD:
FETCH_PARAM_CODE_TO (stix, b1);
printf ("JUMP2_FORWARD %d\n", (int)b1);
DBGOUT_EXEC_1 ("JUMP2_FORWARD %d", (int)b1);
stix->ip += MAX_CODE_JUMP + b1;
break;
break;
case BCODE_JUMP2_BACKWARD:
FETCH_PARAM_CODE_TO (stix, b1);
printf ("JUMP2_BACKWARD %d\n", (int)b1);
DBGOUT_EXEC_1 ("JUMP2_BACKWARD %d", (int)b1);
stix->ip -= MAX_CODE_JUMP + b1;
break;
@ -1654,22 +1904,24 @@ printf ("JUMP2_BACKWARD %d\n", (int)b1);
{
/* pop */
ACTIVE_STACK_POP (stix);
printf ("POP_INTO_CTXTEMPVAR %d %d - ", (int)b1, (int)b2);
DBGOUT_EXEC_2 ("POP_INTO_CTXTEMPVAR %d %d", (int)b1, (int)b2);
}
else
{
DBGOUT_EXEC_2 ("STORE_INTO_CTXTEMPVAR %d %d", (int)b1, (int)b2);
}
else
{
printf ("STORE_INTO_CTXTEMPVAR %d %d - ", (int)b1, (int)b2);
}
}
else
{
/* push */
ACTIVE_STACK_PUSH (stix, ctx->slot[b2]);
printf ("PUSH_CTXTEMPVAR %d %d - ", (int)b1, (int)b2);
DBGOUT_EXEC_2 ("PUSH_CTXTEMPVAR %d %d", (int)b1, (int)b2);
}
/*
print_object (stix, ctx->slot[b2]);
printf ("\n");
*/
break;
}
/* -------------------------------------------------------- */
@ -1716,22 +1968,23 @@ printf ("\n");
{
/* pop */
ACTIVE_STACK_POP (stix);
printf ("POP_INTO_OBJVAR %d %d - ", (int)b1, (int)b2);
DBGOUT_EXEC_2 ("POP_INTO_OBJVAR %d %d", (int)b1, (int)b2);
}
else
{
DBGOUT_EXEC_2 ("STORE_INTO_OBJVAR %d %d", (int)b1, (int)b2);
}
else
{
printf ("STORE_INTO_OBJVAR %d %d - ", (int)b1, (int)b2);
}
}
else
{
/* push */
printf ("PUSH_OBJVAR %d %d - ", (int)b1, (int)b2);
DBGOUT_EXEC_2 ("PUSH_OBJVAR %d %d", (int)b1, (int)b2);
ACTIVE_STACK_PUSH (stix, t->slot[b1]);
}
/*
print_object (stix, t->slot[b1]);
printf ("\n");
*/
break;
}
@ -1769,15 +2022,19 @@ printf ("\n");
selector = (stix_oop_char_t)stix->active_method->slot[b2];
#if defined(STIX_DEBUG_EXEC)
printf ("SEND_MESSAGE%s TO RECEIVER AT STACKPOS=%d NARGS=%d SELECTOR=", (((bcode >> 2) & 1)? "_TO_SUPER": ""), (int)(stix->sp - b1), (int)b1);
print_object (stix, (stix_oop_t)selector);
fflush (stdout);
#endif
STIX_ASSERT (STIX_CLASSOF(stix, selector) == stix->_symbol);
newrcv = ACTIVE_STACK_GET(stix, stix->sp - b1);
#if defined(STIX_DEBUG_EXEC)
printf (" RECEIVER = ");
print_object(stix, newrcv);
printf ("\n");
#endif
mthname.ptr = selector->slot;
mthname.len = STIX_OBJ_GET_SIZE(selector);
newmth = find_method (stix, newrcv, &mthname, ((bcode >> 2) & 1));
@ -1797,36 +2054,36 @@ printf ("]\n");
switch (preamble_code)
{
case STIX_METHOD_PREAMBLE_RETURN_RECEIVER:
printf ("RETURN RECEIVER AT PREAMBLE\n");
DBGOUT_EXEC_0 ("METHOD_PREAMBLE_RETURN_RECEIVER");
ACTIVE_STACK_POPS (stix, b1); /* pop arguments only*/
break;
case STIX_METHOD_PREAMBLE_RETURN_NIL:
printf ("RETURN NIL AT PREAMBLE\n");
DBGOUT_EXEC_0 ("METHOD_PREAMBLE_RETURN_NIL");
ACTIVE_STACK_POPS (stix, b1);
ACTIVE_STACK_SETTOP (stix, stix->_nil);
break;
case STIX_METHOD_PREAMBLE_RETURN_TRUE:
printf ("RETURN TRUE AT PREAMBLE\n");
DBGOUT_EXEC_0 ("METHOD_PREAMBLE_RETURN_TRUE");
ACTIVE_STACK_POPS (stix, b1);
ACTIVE_STACK_SETTOP (stix, stix->_true);
break;
case STIX_METHOD_PREAMBLE_RETURN_FALSE:
printf ("RETURN FALSE AT PREAMBLE\n");
DBGOUT_EXEC_0 ("METHOD_PREAMBLE_RETURN_FALSE");
ACTIVE_STACK_POPS (stix, b1);
ACTIVE_STACK_SETTOP (stix, stix->_false);
break;
case STIX_METHOD_PREAMBLE_RETURN_INDEX:
printf ("RETURN %d AT PREAMBLE\n", (int)STIX_METHOD_GET_PREAMBLE_INDEX(preamble));
DBGOUT_EXEC_1 ("METHOD_PREAMBLE_RETURN_INDEX %d", (int)STIX_METHOD_GET_PREAMBLE_INDEX(preamble));
ACTIVE_STACK_POPS (stix, b1);
ACTIVE_STACK_SETTOP (stix, STIX_OOP_FROM_SMINT(STIX_METHOD_GET_PREAMBLE_INDEX(preamble)));
break;
case STIX_METHOD_PREAMBLE_RETURN_NEGINDEX:
printf ("RETURN %d AT PREAMBLE\n", (int)-STIX_METHOD_GET_PREAMBLE_INDEX(preamble));
DBGOUT_EXEC_1 ("METHOD_PREAMBLE_RETURN_NEGINDEX %d", (int)STIX_METHOD_GET_PREAMBLE_INDEX(preamble));
ACTIVE_STACK_POPS (stix, b1);
ACTIVE_STACK_SETTOP (stix, STIX_OOP_FROM_SMINT(-STIX_METHOD_GET_PREAMBLE_INDEX(preamble)));
break;
@ -1837,7 +2094,8 @@ printf ("RETURN %d AT PREAMBLE\n", (int)-STIX_METHOD_GET_PREAMBLE_INDEX(preamble
ACTIVE_STACK_POPS (stix, b1); /* pop arguments only */
printf ("RETURN INSTVAR AT PREAMBLE index %d\n", (int)STIX_METHOD_GET_PREAMBLE_INDEX(preamble));
DBGOUT_EXEC_1 ("METHOD_PREAMBLE_RETURN_INSTVAR %d", (int)STIX_METHOD_GET_PREAMBLE_INDEX(preamble));
/* replace the receiver by an instance variable of the receiver */
rcv = (stix_oop_oop_t)ACTIVE_STACK_GETTOP(stix);
STIX_ASSERT (STIX_OBJ_GET_FLAGS_TYPE(rcv) == STIX_OBJ_TYPE_OOP);
@ -1863,11 +2121,14 @@ printf ("RETURN INSTVAR AT PREAMBLE index %d\n", (int)STIX_METHOD_GET_PREAMBLE_I
break;
}
case STIX_METHOD_PREAMBLE_PRIMITIVE:
{
stix_ooi_t prim_no;
prim_no = STIX_METHOD_GET_PREAMBLE_INDEX(preamble);
DBGOUT_EXEC_1 ("METHOD_PREAMBLE_PRIMITIVE %d", (int)prim_no);
if (prim_no >= 0 && prim_no < STIX_COUNTOF(primitives) &&
(primitives[prim_no].nargs < 0 || primitives[prim_no].nargs == b1))
{
@ -1880,12 +2141,46 @@ printf ("RETURN INSTVAR AT PREAMBLE index %d\n", (int)STIX_METHOD_GET_PREAMBLE_I
if (n >= 1) break;
}
/* primitive failed. fall through */
/* primitive failed */
if (activate_new_method (stix, newmth) <= -1) goto oops;
break;
}
case STIX_METHOD_PREAMBLE_NAMED_PRIMITIVE:
{
stix_ooi_t prim_name_index;
stix_oop_t name;
primitive_handler_t handler;
prim_name_index = STIX_METHOD_GET_PREAMBLE_INDEX(preamble);
DBGOUT_EXEC_1 ("METHOD_PREAMBLE_NAMED_PRIMITIVE %d", (int)prim_name_index);
name = newmth->slot[prim_name_index];
STIX_ASSERT (STIX_ISTYPEOF(stix,name,STIX_OBJ_TYPE_CHAR));
STIX_ASSERT (STIX_OBJ_GET_FLAGS_EXTRA(name));
STIX_ASSERT (STIX_CLASSOF(stix,name) == stix->_symbol);
handler = query_primitive_module (stix, ((stix_oop_char_t)name)->slot);
if (handler)
{
stix_pushtmp (stix, (stix_oop_t*)&newmth);
n = handler (stix, b1);
stix_poptmp (stix);
if (n <= -1) goto oops;
if (n >= 1) break;
}
/* primitive failed */
if (activate_new_method (stix, newmth) <= -1) goto oops;
break;
}
default:
if (activate_new_method (stix, newmth) <= -1) goto oops;
break;
/* this must not happen */
stix->errnum = STIX_EINTERN;
return -1;
}
break; /* CMD_SEND_MESSAGE */
@ -1894,60 +2189,60 @@ printf ("RETURN INSTVAR AT PREAMBLE index %d\n", (int)STIX_METHOD_GET_PREAMBLE_I
/* -------------------------------------------------------- */
case BCODE_PUSH_RECEIVER:
printf ("PUSH_RECEIVER %p TO STACK INDEX %d\n", stix->active_context->origin->receiver_or_source, (int)stix->sp);
DBGOUT_EXEC_0 ("PUSH_RECEIVER");
ACTIVE_STACK_PUSH (stix, stix->active_context->origin->receiver_or_source);
break;
case BCODE_PUSH_NIL:
printf ("PUSH_NIL\n");
DBGOUT_EXEC_0 ("PUSH_NIL");
ACTIVE_STACK_PUSH (stix, stix->_nil);
break;
case BCODE_PUSH_TRUE:
printf ("PUSH_TRUE\n");
DBGOUT_EXEC_0 ("PUSH_TRUE");
ACTIVE_STACK_PUSH (stix, stix->_true);
break;
case BCODE_PUSH_FALSE:
printf ("PUSH_FALSE\n");
DBGOUT_EXEC_0 ("PUSH_FALSE");
ACTIVE_STACK_PUSH (stix, stix->_false);
break;
case BCODE_PUSH_CONTEXT:
printf ("PUSH_CONTEXT\n");
DBGOUT_EXEC_0 ("PUSH_CONTEXT");
ACTIVE_STACK_PUSH (stix, (stix_oop_t)stix->active_context);
break;
case BCODE_PUSH_NEGONE:
printf ("PUSH_NEGONE\n");
DBGOUT_EXEC_0 ("PUSH_NEGONE");
ACTIVE_STACK_PUSH (stix, STIX_OOP_FROM_SMINT(-1));
break;
case BCODE_PUSH_ZERO:
printf ("PUSH_ZERO\n");
DBGOUT_EXEC_0 ("PUSH_ZERO");
ACTIVE_STACK_PUSH (stix, STIX_OOP_FROM_SMINT(0));
break;
case BCODE_PUSH_ONE:
printf ("PUSH_ONE\n");
DBGOUT_EXEC_0 ("PUSH_ONE");
ACTIVE_STACK_PUSH (stix, STIX_OOP_FROM_SMINT(1));
break;
case BCODE_PUSH_TWO:
printf ("PUSH_TWO\n");
DBGOUT_EXEC_0 ("PUSH_TWO");
ACTIVE_STACK_PUSH (stix, STIX_OOP_FROM_SMINT(2));
break;
case BCODE_PUSH_INTLIT:
FETCH_PARAM_CODE_TO (stix, b1);
DBGOUT_EXEC_1 ("PUSH_INTLIT %d", (int)b1);
ACTIVE_STACK_PUSH (stix, STIX_OOP_FROM_SMINT(b1));
printf ("PUSH_INTLIT %d\n", (int)b1);
break;
case BCODE_PUSH_NEGINTLIT:
FETCH_PARAM_CODE_TO (stix, b1);
DBGOUT_EXEC_1 ("PUSH_NEGINTLIT %d", (int)-b1);
ACTIVE_STACK_PUSH (stix, STIX_OOP_FROM_SMINT(-b1));
printf ("PUSH_NEGINTLIT %d\n", (int)-b1);
break;
/* -------------------------------------------------------- */
@ -1955,7 +2250,7 @@ printf ("PUSH_NEGINTLIT %d\n", (int)-b1);
case BCODE_DUP_STACKTOP:
{
stix_oop_t t;
printf ("DUP_STACKTOP SP=%d\n", (int)stix->sp);
DBGOUT_EXEC_0 ("DUP_STACKTOP");
STIX_ASSERT (!ACTIVE_STACK_ISEMPTY(stix));
t = ACTIVE_STACK_GETTOP(stix);
ACTIVE_STACK_PUSH (stix, t);
@ -1963,22 +2258,25 @@ printf ("DUP_STACKTOP SP=%d\n", (int)stix->sp);
}
case BCODE_POP_STACKTOP:
printf ("POP_STACKTOP\n");
DBGOUT_EXEC_0 ("POP_STACKTOP");
STIX_ASSERT (!ACTIVE_STACK_ISEMPTY(stix));
ACTIVE_STACK_POP (stix);
break;
case BCODE_RETURN_STACKTOP:
printf ("RETURN_STACKTOP\n");
DBGOUT_EXEC_0 ("RETURN_STACKTOP");
return_value = ACTIVE_STACK_GETTOP(stix);
ACTIVE_STACK_POP (stix);
goto handle_return;
case BCODE_RETURN_RECEIVER:
printf ("RETURN_RECEIVER\n");
DBGOUT_EXEC_0 ("RETURN_RECEIVER");
return_value = stix->active_context->origin->receiver_or_source;
handle_return:
#if defined(STIX_DEBUG_EXEC)
printf ("<<LEAVING>> SP=%d\n", (int)stix->sp);
#endif
/* put the instruction pointer back to the return
* instruction (RETURN_RECEIVER or RETURN_RECEIVER)
@ -2032,8 +2330,9 @@ printf ("<<LEAVING>> SP=%d\n", (int)stix->sp);
/* the sending context of the intial context has been set to nil.
* use this fact to tell an initial context from a normal context. */
STIX_ASSERT (stix->active_context->receiver_or_source == stix->_nil);
#if defined(STIX_DEBUG_EXEC)
printf ("<<<RETURNIGN TO THE INITIAL CONTEXT>>>\n");
#endif
STIX_ASSERT (stix->sp == 0);
goto done;
}
@ -2041,7 +2340,8 @@ printf ("<<<RETURNIGN TO THE INITIAL CONTEXT>>>\n");
break;
case BCODE_RETURN_FROM_BLOCK:
printf ("LEAVING_BLOCK\n");
DBGOUT_EXEC_0 ("RETURN_FROM_BLOCK");
STIX_ASSERT(STIX_CLASSOF(stix, stix->active_context) == stix->_block_context);
return_value = ACTIVE_STACK_GETTOP(stix);
@ -2058,7 +2358,7 @@ printf ("LEAVING_BLOCK\n");
FETCH_PARAM_CODE_TO (stix, b1);
FETCH_PARAM_CODE_TO (stix, b2);
printf ("MAKE_BLOCK %d %d\n", (int)b1, (int)b2);
DBGOUT_EXEC_2 ("MAKE_BLOCK %d %d", (int)b1, (int)b2);
STIX_ASSERT (b1 >= 0);
STIX_ASSERT (b2 >= b1);
@ -2099,7 +2399,9 @@ printf ("MAKE_BLOCK %d %d\n", (int)b1, (int)b2);
stix_ooi_t nargs, ntmprs;
stix_oop_context_t rctx;
stix_oop_context_t blkctx;
printf ("SEND_BLOCK_COPY\n");
DBGOUT_EXEC_0 ("SEND_BLOCK_COPY");
/* it emulates thisContext blockCopy: nargs ofTmprCount: ntmprs */
STIX_ASSERT (stix->sp >= 2);
@ -2200,7 +2502,10 @@ printf ("UNKNOWN BYTE CODE ENCOUNTERED %x\n", (int)bcode);
}
done:
#if defined(STIX_PROFILE_EXEC)
printf ("TOTAL_INST_COUTNER = %lu\n", (unsigned long int)inst_counter);
#endif
return 0;
@ -2209,8 +2514,10 @@ oops:
return -1;
}
int stix_invoke (stix_t* stix, const stix_ucs_t* objname, const stix_ucs_t* mthname)
{
if (activate_initial_context (stix, objname, mthname) <= -1) return -1;
return stix_execute (stix);
}

8
stix/lib/main.c
View File

@ -65,7 +65,7 @@ static stix_mmgr_t sys_mmgr =
};
static STIX_INLINE stix_ssize_t open_input (stix_t* stix, stix_ioarg_t* arg)
static STIX_INLINE stix_ssize_t open_input (stix_t* stix, stix_io_arg_t* arg)
{
if (arg->includer)
{
@ -108,7 +108,7 @@ static STIX_INLINE stix_ssize_t open_input (stix_t* stix, stix_ioarg_t* arg)
return 0;
}
static STIX_INLINE stix_ssize_t read_input (stix_t* stix, stix_ioarg_t* arg)
static STIX_INLINE stix_ssize_t read_input (stix_t* stix, stix_io_arg_t* arg)
{
xtn_t* xtn = stix_getxtn(stix);
stix_size_t n, bcslen, ucslen, remlen;
@ -141,14 +141,14 @@ static STIX_INLINE stix_ssize_t read_input (stix_t* stix, stix_ioarg_t* arg)
return ucslen;
}
static STIX_INLINE stix_ssize_t close_input (stix_t* stix, stix_ioarg_t* arg)
static STIX_INLINE stix_ssize_t close_input (stix_t* stix, stix_io_arg_t* arg)
{
STIX_ASSERT (arg->handle != STIX_NULL);
fclose ((FILE*)arg->handle);
return 0;
}
static stix_ssize_t input_handler (stix_t* stix, stix_iocmd_t cmd, stix_ioarg_t* arg)
static stix_ssize_t input_handler (stix_t* stix, stix_io_cmd_t cmd, stix_io_arg_t* arg)
{
switch (cmd)
{

32
stix/lib/stix-prv.h
View File

@ -50,6 +50,8 @@
/* this is for gc debugging */
#define STIX_DEBUG_GC_001
/*#define STIX_DEBUG_EXEC*/
#define STIX_PROFILE_EXEC
#include <stdio.h> /* TODO: delete these header inclusion lines */
#include <string.h>
@ -159,13 +161,13 @@
/* SOURCE CODE I/O FOR COMPILER */
/* ========================================================================= */
enum stix_iocmd_t
enum stix_io_cmd_t
{
STIX_IO_OPEN,
STIX_IO_CLOSE,
STIX_IO_READ
};
typedef enum stix_iocmd_t stix_iocmd_t;
typedef enum stix_io_cmd_t stix_io_cmd_t;
struct stix_ioloc_t
{
@ -183,14 +185,14 @@ struct stix_iolxc_t
typedef struct stix_iolxc_t stix_iolxc_t;
/*
enum stix_ioarg_flag_t
enum stix_io_arg_flag_t
{
STIX_IO_INCLUDED = (1 << 0)
};
typedef enum stix_ioarg_flag_t stix_ioarg_flag_t; */
typedef enum stix_io_arg_flag_t stix_io_arg_flag_t; */
typedef struct stix_ioarg_t stix_ioarg_t;
struct stix_ioarg_t
typedef struct stix_io_arg_t stix_io_arg_t;
struct stix_io_arg_t
{
/**
* [IN] I/O object name.
@ -216,7 +218,7 @@ struct stix_ioarg_t
* [IN] points to the data of the includer. It is #STIX_NULL for the
* main stream.
*/
stix_ioarg_t* includer;
stix_io_arg_t* includer;
/*-----------------------------------------------------------------*/
/*----------- from here down, internal use only -------------------*/
@ -232,10 +234,10 @@ struct stix_ioarg_t
/*-----------------------------------------------------------------*/
};
typedef stix_ssize_t (*stix_ioimpl_t) (
typedef stix_ssize_t (*stix_io_impl_t) (
stix_t* stix,
stix_iocmd_t cmd,
stix_ioarg_t* arg
stix_io_cmd_t cmd,
stix_io_arg_t* arg
);
struct stix_iotok_t
@ -363,7 +365,7 @@ typedef struct stix_code_t stix_code_t;
struct stix_compiler_t
{
/* input handler */
stix_ioimpl_t impl;
stix_io_impl_t impl;
/* information about the last meaningful character read.
* this is a copy of curinp->lxc if no ungetting is performed.
@ -377,10 +379,10 @@ struct stix_compiler_t
int nungots;
/* static input data buffer */
stix_ioarg_t arg;
stix_io_arg_t arg;
/* pointer to the current input data. initially, it points to &arg */
stix_ioarg_t* curinp;
stix_io_arg_t* curinp;
/* the last token read */
stix_iotok_t tok;
@ -480,6 +482,8 @@ struct stix_compiler_t
stix_size_t arlit_count;
stix_size_t arlit_capa;
/* 0 for no primitive, 1 for a normal primitive, 2 for a named primitive */
int prim_type;
/* primitive number */
stix_ooi_t prim_no;
@ -1062,7 +1066,7 @@ int stix_utf8toucs (
/* ========================================================================= */
int stix_compile (
stix_t* stix,
stix_ioimpl_t io
stix_io_impl_t io
);
void stix_getsynerr (

62
stix/lib/stix.h
View File

@ -73,6 +73,8 @@ struct stix_ucs_t
};
typedef struct stix_ucs_t stix_ucs_t;
/* =========================================================================
* PRIMITIVE MACROS
* ========================================================================= */
@ -584,9 +586,9 @@ struct stix_association_t
};
#if defined(STIX_USE_OBJECT_TRAILER)
# define STIX_METHOD_NAMED_INSTVARS 5
# define STIX_METHOD_NAMED_INSTVARS 7
#else
# define STIX_METHOD_NAMED_INSTVARS 6
# define STIX_METHOD_NAMED_INSTVARS 8
#endif
typedef struct stix_method_t stix_method_t;
typedef struct stix_method_t* stix_oop_method_t;
@ -599,6 +601,8 @@ struct stix_method_t
/* primitive number */
stix_oop_t preamble; /* SmallInteger */
stix_oop_t preamble_data[2]; /* SmallInteger */
/* number of temporaries including arguments */
stix_oop_t tmpr_count; /* SmallInteger */
@ -644,9 +648,12 @@ struct stix_method_t
#define STIX_METHOD_PREAMBLE_RETURN_NEGINDEX 6
#define STIX_METHOD_PREAMBLE_RETURN_INSTVAR 7
#define STIX_METHOD_PREAMBLE_PRIMITIVE 8
#define STIX_METHOD_PREAMBLE_NAMED_PRIMITIVE 9 /* index is an index to the symbol table */
/* the index is an 16-bit unsigned integer. */
#define STIX_OOI_IN_PREAMBLE_INDEX_RANGE(ooi) ((ooi) >= 0 && (ooi) <= 0xFFFF)
#define STIX_METHOD_PREAMBLE_INDEX_MIN 0x0000
#define STIX_METHOD_PREAMBLE_INDEX_MAX 0xFFFF
#define STIX_OOI_IN_PREAMBLE_INDEX_RANGE(num) ((num) >= STIX_METHOD_PREAMBLE_INDEX_MIN && (num) <= STIX_METHOD_PREAMBLE_INDEX_MAX)
#define STIX_CONTEXT_NAMED_INSTVARS 8
typedef struct stix_context_t stix_context_t;
@ -733,19 +740,58 @@ struct stix_heap_t
typedef struct stix_t stix_t;
typedef void (*stix_cbimpl_t) (stix_t* stix);
/* =========================================================================
* MODULE MANIPULATION
* ========================================================================= */
enum stix_mod_cmd_t
{
STIX_MOD_OPEN,
STIX_MOD_CLOSE,
STIX_MOD_READ
};
typedef enum stix_mod_cmd_t stix_mod_cmd_t;
struct stix_mod_arg_t
{
/* [INPUT] */
const stix_uch_t* prefix;
const stix_uch_t* postfix;
const stix_uch_t* name;
/* [OUTPUT] */
void* handle;
};
typedef struct stix_mod_arg_t stix_mod_arg_t;
typedef int (*stix_mod_impl_t) (
stix_t* stix,
stix_mod_cmd_t cmd,
stix_mod_arg_t* arg
);
/* =========================================================================
* IO MANIPULATION
* ========================================================================= */
/* TODO: MOVE stix_io_impl_t HERE */
/* =========================================================================
* CALLBACK MANIPULATION
* ========================================================================= */
typedef void (*stix_cb_impl_t) (stix_t* stix);
typedef struct stix_cb_t stix_cb_t;
struct stix_cb_t
{
stix_cbimpl_t gc;
stix_cbimpl_t fini;
stix_cb_impl_t gc;
stix_cb_impl_t fini;
/* private below */
stix_cb_t* prev;
stix_cb_t* next;
stix_cb_t* prev;
stix_cb_t* next;
};
#if defined(STIX_INCLUDE_COMPILER)
typedef struct stix_compiler_t stix_compiler_t;
#endif