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

introduced the Error class to represent an error code as an object.

Browse Source 
rewrote STIX_ASSERT() to call stix_logbfmt() via stix_assertfailed()
This commit is contained in:
hyunghwan.chung 2016-12-26 18:44:47 +00:00
parent 61f2c89aaa
commit a9c48b75e6
30 changed files with 1003 additions and 1027 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
stix/kernel/Apex.st
View File

@ -332,4 +332,10 @@
}
}
#class Error(Apex)
{
#method isError
{
^true
}
}

16
stix/kernel/Stdio.st
View File

@ -1,5 +1,7 @@
#class(#byte) Stdio(Object) from 'stdio'
{
#dcl(#class) in out err.
(*
* The following methods are generated by the module.
* #method(#class) _newInstSize { <primitive: #stdio._newInstSize> }
@ -9,15 +11,12 @@
#method(#class) new: size
{
##self prohibited
##raise exception. prohibited...
## ignore the specified size
^(super new: (self _newInstSize))
}
#method(#class) new
{
##self prohibited
##raise exception. prohibited...
^(super new: (self _newInstSize))
}
@ -30,17 +29,20 @@
(* ---------------------
#method(#class) input
{
^(super new) open: 0 for: 'r'
self.in isNil ifTrue: [ self.in := ^(super new) open: 0 for: 'r' ].
^self.in.
}
#method(#class) output
{
^(super new) open: 1 for: 'w'
self.out isNil ifTrue: [ self.out := ^(super new) open: 1 for: 'w' ].
^self.out.
}
#method(#class) error
{
^(super new) open: 2 for: 'w'
self.err isNil ifTrue: [ self.err := ^(super new) open: 2 for: 'w' ].
^self.err.
}
------------------------ *)

13
stix/kernel/Stix.st
View File

@ -4,19 +4,6 @@
#########################################################################################
#class Error(Object)
{
#method(#class) signal: aString
{
"accept an arbitary object instead of a string.
the object can be sent displayString for string conversion"
}
#method isError
{
^true
}
}
#class Magnitude(Object)
{

26
stix/kernel/test-014.st
View File

@ -126,26 +126,23 @@
##v1 := Stdio2 open: '/tmp/1.txt' for: 'w+'.
v1 := Stdio2 new open: '/tmp/1.txt' for: 'w+'.
(v1 isError)
ifTrue: [
System logNl: ('Error in opening a file....').
]
ifFalse: [
## v1 puts: 'hello'.
v1 puts ('hello', 'world', 'good', C'\n', C'\t', 'under my umbrella.', C'\n').
v1 close.
(*v1 format(10, 20) isNil ifFalse: [
'Beautiful life' dump.
].*)
].
nil isNil ifTrue: [ 'NIL NIL NIL' dump. ].
(Apex new) notNil ifTrue: [ 'APEX NIL NIL NIL' dump. ].
(*
v1 format(10 20 30) isNil
procecure call is treated as if it is a unary message...
v1 format(10 , 20 , 30) isNil ifTrue: [
xxxx
].
*)
v1 format(10, 20) isNil ifFalse: [
'Beautiful life' dump.
].
self varg_test (10, 20, 30, 40, 50) dump.
self varg_test2 (10, 20, 30, 40, 50) dump.
self varg_test3 (10, 20, 30, 40, 50) dump.
@ -153,7 +150,6 @@ procecure call is treated as if it is a unary message...
thisContext vargCount dump.
}
#method(#class) varg_test()
{
0 to: (thisContext vargCount - 1) do: [:k |

1
stix/lib/Makefile.am
View File

@ -47,7 +47,6 @@ libstix_la_SOURCES = \
logfmt.c \
gc.c \
heap.c \
ignite.c \
obj.c \
proc.c \
rbt.c \

15
stix/lib/Makefile.in
View File

@ -137,9 +137,9 @@ libstix_la_DEPENDENCIES = $(am__DEPENDENCIES_2)
am_libstix_la_OBJECTS = libstix_la-bigint.lo libstix_la-comp.lo \
libstix_la-debug.lo libstix_la-decode.lo libstix_la-dic.lo \
libstix_la-exec.lo libstix_la-logfmt.lo libstix_la-gc.lo \
libstix_la-heap.lo libstix_la-ignite.lo libstix_la-obj.lo \
libstix_la-proc.lo libstix_la-rbt.lo libstix_la-stix.lo \
libstix_la-sym.lo libstix_la-utf8.lo libstix_la-utl.lo
libstix_la-heap.lo libstix_la-obj.lo libstix_la-proc.lo \
libstix_la-rbt.lo libstix_la-stix.lo libstix_la-sym.lo \
libstix_la-utf8.lo libstix_la-utl.lo
libstix_la_OBJECTS = $(am_libstix_la_OBJECTS)
AM_V_lt = $(am__v_lt_@AM_V@)
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
@ -414,7 +414,6 @@ libstix_la_SOURCES = \
logfmt.c \
gc.c \
heap.c \
ignite.c \
obj.c \
proc.c \
rbt.c \
@ -586,7 +585,6 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstix_la-exec.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstix_la-gc.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstix_la-heap.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstix_la-ignite.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstix_la-logfmt.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstix_la-obj.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstix_la-proc.Plo@am__quote@
@ -684,13 +682,6 @@ libstix_la-heap.lo: heap.c
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libstix_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libstix_la-heap.lo `test -f 'heap.c' || echo '$(srcdir)/'`heap.c
libstix_la-ignite.lo: ignite.c
@am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libstix_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libstix_la-ignite.lo -MD -MP -MF $(DEPDIR)/libstix_la-ignite.Tpo -c -o libstix_la-ignite.lo `test -f 'ignite.c' || echo '$(srcdir)/'`ignite.c
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libstix_la-ignite.Tpo $(DEPDIR)/libstix_la-ignite.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='ignite.c' object='libstix_la-ignite.lo' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libstix_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libstix_la-ignite.lo `test -f 'ignite.c' || echo '$(srcdir)/'`ignite.c
libstix_la-obj.lo: obj.c
@am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libstix_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libstix_la-obj.lo -MD -MP -MF $(DEPDIR)/libstix_la-obj.Tpo -c -o libstix_la-obj.lo `test -f 'obj.c' || echo '$(srcdir)/'`obj.c
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libstix_la-obj.Tpo $(DEPDIR)/libstix_la-obj.Plo

255
stix/lib/bigint.c
View File

@ -126,13 +126,13 @@ static STIX_INLINE int oow_mul_overflow (stix_oow_t a, stix_oow_t b, stix_oow_t*
#endif
#if (STIX_SIZEOF_OOI_T == STIX_SIZEOF_INT) && defined(STIX_HAVE_BUILTIN_SMUL_OVERFLOW)
# define smooi_mul_overflow(a,b,c) __builtin_smul_overflow(a,b,c)
# define smooi_mul_overflow(stix,a,b,c) __builtin_smul_overflow(a,b,c)
#elif (STIX_SIZEOF_OOI_T == STIX_SIZEOF_LONG) && defined(STIX_HAVE_BUILTIN_SMULL_OVERFLOW)
# define smooi_mul_overflow(a,b,c) __builtin_smull_overflow(a,b,c)
# define smooi_mul_overflow(stix,a,b,c) __builtin_smull_overflow(a,b,c)
#elif (STIX_SIZEOF_OOI_T == STIX_SIZEOF_LONG_LONG) && defined(STIX_HAVE_BUILTIN_SMULLL_OVERFLOW)
# define smooi_mul_overflow(a,b,c) __builtin_smulll_overflow(a,b,c)
# define smooi_mul_overflow(stix,a,b,c) __builtin_smulll_overflow(a,b,c)
#else
static STIX_INLINE int smooi_mul_overflow (stix_ooi_t a, stix_ooi_t b, stix_ooi_t* c)
static STIX_INLINE int smooi_mul_overflow (stix_t* stix, stix_ooi_t a, stix_ooi_t b, stix_ooi_t* c)
{
/* take note that this function is not supposed to handle
* the whole stix_ooi_t range. it handles the smooi subrange */
@ -140,8 +140,8 @@ static STIX_INLINE int smooi_mul_overflow (stix_ooi_t a, stix_ooi_t b, stix_ooi_
#if (STIX_SIZEOF_UINTMAX_T > STIX_SIZEOF_OOI_T)
stix_intmax_t k;
STIX_ASSERT (STIX_IN_SMOOI_RANGE(a));
STIX_ASSERT (STIX_IN_SMOOI_RANGE(b));
STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(a));
STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(b));
k = (stix_intmax_t)a * (stix_intmax_t)b;
*c = (stix_ooi_t)k;
@ -151,8 +151,8 @@ static STIX_INLINE int smooi_mul_overflow (stix_ooi_t a, stix_ooi_t b, stix_ooi_
stix_ooi_t ua, ub;
STIX_ASSERT (STIX_IN_SMOOI_RANGE(a));
STIX_ASSERT (STIX_IN_SMOOI_RANGE(b));
STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(a));
STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(b));
*c = a * b;
@ -220,7 +220,7 @@ static int is_normalized_integer (stix_t* stix, stix_oop_t oop)
stix_oow_t sz;
sz = STIX_OBJ_GET_SIZE(oop);
STIX_ASSERT (sz >= 1);
STIX_ASSERT (stix, sz >= 1);
return ((stix_oop_liword_t)oop)->slot[sz - 1] == 0? 0: 1;
}
@ -233,7 +233,7 @@ STIX_INLINE static int is_bigint (stix_t* stix, stix_oop_t x)
{
stix_oop_t c;
STIX_ASSERT (STIX_OOP_IS_POINTER(x));
STIX_ASSERT (stix, STIX_OOP_IS_POINTER(x));
/* TODO: is it better to introduce a special integer mark into the class itself */
/* TODO: or should it check if it's a subclass, subsubclass, subsubsubclass, etc of a large_integer as well? */
@ -254,12 +254,12 @@ STIX_INLINE int stix_isint (stix_t* stix, stix_oop_t x)
static STIX_INLINE int bigint_to_oow (stix_t* stix, stix_oop_t num, stix_oow_t* w)
{
STIX_ASSERT (STIX_OOP_IS_POINTER(num));
STIX_ASSERT (STIX_OBJ_GET_CLASS(num) == stix->_large_positive_integer ||
STIX_ASSERT (stix, STIX_OOP_IS_POINTER(num));
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(num) == stix->_large_positive_integer ||
STIX_OBJ_GET_CLASS(num) == stix->_large_negative_integer);
#if (STIX_LIW_BITS == STIX_OOW_BITS)
STIX_ASSERT (STIX_OBJ_GET_SIZE(num) >= 1);
STIX_ASSERT (stix, STIX_OBJ_GET_SIZE(num) >= 1);
if (STIX_OBJ_GET_SIZE(num) == 1)
{
*w = ((stix_oop_word_t)num)->slot[0];
@ -272,7 +272,7 @@ static STIX_INLINE int bigint_to_oow (stix_t* stix, stix_oop_t num, stix_oow_t*
* you must not call this function with an unnormalized
* large integer. */
STIX_ASSERT (STIX_OBJ_GET_SIZE(num) >= 2);
STIX_ASSERT (stix, STIX_OBJ_GET_SIZE(num) >= 2);
if (STIX_OBJ_GET_SIZE(num) == 2)
{
*w = MAKE_WORD (((stix_oop_halfword_t)num)->slot[0], ((stix_oop_halfword_t)num)->slot[1]);
@ -310,7 +310,7 @@ static STIX_INLINE int integer_to_oow (stix_t* stix, stix_oop_t x, stix_oow_t* w
}
}
STIX_ASSERT (is_bigint(stix, x));
STIX_ASSERT (stix, is_bigint(stix, x));
return bigint_to_oow (stix, x, w);
}
@ -341,7 +341,7 @@ int stix_inttooow (stix_t* stix, stix_oop_t x, stix_oow_t* w)
static STIX_INLINE stix_oop_t make_bigint_with_oow (stix_t* stix, stix_oow_t w)
{
#if (STIX_LIW_BITS == STIX_OOW_BITS)
STIX_ASSERT (STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_liw_t));
STIX_ASSERT (stix, STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_liw_t));
return stix_instantiate (stix, stix->_large_positive_integer, &w, 1);
#elif (STIX_LIW_BITS == STIX_OOHW_BITS)
stix_liw_t hw[2];
@ -358,7 +358,7 @@ static STIX_INLINE stix_oop_t make_bigint_with_ooi (stix_t* stix, stix_ooi_t i)
#if (STIX_LIW_BITS == STIX_OOW_BITS)
stix_oow_t w;
STIX_ASSERT (STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_liw_t));
STIX_ASSERT (stix, STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_liw_t));
if (i >= 0)
{
w = i;
@ -369,7 +369,7 @@ static STIX_INLINE stix_oop_t make_bigint_with_ooi (stix_t* stix, stix_ooi_t i)
/* The caller must ensure that i is greater than the smallest value
* that stix_ooi_t can represent. otherwise, the absolute value
* cannot be held in stix_ooi_t. */
STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t));
STIX_ASSERT (stix, i > STIX_TYPE_MIN(stix_ooi_t));
w = -i;
return stix_instantiate (stix, stix->_large_negative_integer, &w, 1);
}
@ -386,7 +386,7 @@ static STIX_INLINE stix_oop_t make_bigint_with_ooi (stix_t* stix, stix_ooi_t i)
}
else
{
STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t));
STIX_ASSERT (stix, i > STIX_TYPE_MIN(stix_ooi_t));
w = -i;
hw[0] = w /*& STIX_LBMASK(stix_oow_t,STIX_LIW_BITS)*/;
hw[1] = w >> STIX_LIW_BITS;
@ -403,8 +403,8 @@ static STIX_INLINE stix_oop_t make_bloated_bigint_with_ooi (stix_t* stix, stix_o
stix_oow_t w;
stix_oop_t z;
STIX_ASSERT (extra <= STIX_OBJ_SIZE_MAX - 1);
STIX_ASSERT (STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_liw_t));
STIX_ASSERT (stix, extra <= STIX_OBJ_SIZE_MAX - 1);
STIX_ASSERT (stix, STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_liw_t));
if (i >= 0)
{
w = i;
@ -412,7 +412,7 @@ static STIX_INLINE stix_oop_t make_bloated_bigint_with_ooi (stix_t* stix, stix_o
}
else
{
STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t));
STIX_ASSERT (stix, i > STIX_TYPE_MIN(stix_ooi_t));
w = -i;
z = stix_instantiate (stix, stix->_large_negative_integer, STIX_NULL, 1 + extra);
}
@ -426,7 +426,7 @@ static STIX_INLINE stix_oop_t make_bloated_bigint_with_ooi (stix_t* stix, stix_o
stix_oow_t w;
stix_oop_t z;
STIX_ASSERT (extra <= STIX_OBJ_SIZE_MAX - 2);
STIX_ASSERT (stix, extra <= STIX_OBJ_SIZE_MAX - 2);
if (i >= 0)
{
w = i;
@ -436,7 +436,7 @@ static STIX_INLINE stix_oop_t make_bloated_bigint_with_ooi (stix_t* stix, stix_o
}
else
{
STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t));
STIX_ASSERT (stix, i > STIX_TYPE_MIN(stix_ooi_t));
w = -i;
hw[0] = w /*& STIX_LBMASK(stix_oow_t,STIX_LIW_BITS)*/;
hw[1] = w >> STIX_LIW_BITS;
@ -460,7 +460,7 @@ static STIX_INLINE stix_oop_t make_bigint_with_intmax (stix_t* stix, stix_intmax
/* this is not a generic function. it can't handle v
* if it's STIX_TYPE_MIN(stix_intmax_t) */
STIX_ASSERT (v > STIX_TYPE_MIN(stix_intmax_t));
STIX_ASSERT (stix, v > STIX_TYPE_MIN(stix_intmax_t));
ui = (v >= 0)? v: -v;
len = 0;
@ -476,7 +476,7 @@ static STIX_INLINE stix_oop_t make_bigint_with_intmax (stix_t* stix, stix_intmax
stix_oop_t stix_oowtoint (stix_t* stix, stix_oow_t w)
{
STIX_ASSERT (STIX_TYPE_IS_UNSIGNED(stix_oow_t));
STIX_ASSERT (stix, STIX_TYPE_IS_UNSIGNED(stix_oow_t));
/*if (STIX_IN_SMOOI_RANGE(w))*/
if (w <= STIX_SMOOI_MAX)
{
@ -494,7 +494,7 @@ static STIX_INLINE stix_oop_t expand_bigint (stix_t* stix, stix_oop_t oop, stix_
stix_oow_t i;
stix_oow_t count;
STIX_ASSERT (STIX_OOP_IS_POINTER(oop));
STIX_ASSERT (stix, STIX_OOP_IS_POINTER(oop));
count = STIX_OBJ_GET_SIZE(oop);
if (inc > STIX_OBJ_SIZE_MAX - count)
@ -521,7 +521,7 @@ static STIX_INLINE stix_oop_t _clone_bigint (stix_t* stix, stix_oop_t oop, stix_
stix_oop_t z;
stix_oow_t i;
STIX_ASSERT (STIX_OOP_IS_POINTER(oop));
STIX_ASSERT (stix, STIX_OOP_IS_POINTER(oop));
if (count <= 0) count = STIX_OBJ_GET_SIZE(oop);
stix_pushtmp (stix, &oop);
@ -545,14 +545,14 @@ static STIX_INLINE stix_oop_t clone_bigint_negated (stix_t* stix, stix_oop_t oop
{
stix_oop_t c;
STIX_ASSERT (STIX_OOP_IS_POINTER(oop));
STIX_ASSERT (stix, STIX_OOP_IS_POINTER(oop));
if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer)
{
c = stix->_large_negative_integer;
}
else
{
STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
c = stix->_large_positive_integer;
}
@ -592,7 +592,7 @@ static stix_oop_t normalize_bigint (stix_t* stix, stix_oop_t oop)
{
stix_oow_t count;
STIX_ASSERT (STIX_OOP_IS_POINTER(oop));
STIX_ASSERT (stix, STIX_OOP_IS_POINTER(oop));
count = count_effective_digits (oop);
#if (STIX_LIW_BITS == STIX_OOW_BITS)
@ -607,8 +607,8 @@ static stix_oop_t normalize_bigint (stix_t* stix, stix_oop_t oop)
}
else
{
STIX_ASSERT (-STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
STIX_ASSERT (stix, -STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP(-(stix_ooi_t)w);
}
}
@ -622,7 +622,7 @@ static stix_oop_t normalize_bigint (stix_t* stix, stix_oop_t oop)
}
else
{
STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
return STIX_SMOOI_TO_OOP(-(stix_ooi_t)((stix_oop_liword_t)oop)->slot[0]);
}
}
@ -637,8 +637,8 @@ static stix_oop_t normalize_bigint (stix_t* stix, stix_oop_t oop)
}
else
{
STIX_ASSERT (-STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
STIX_ASSERT (stix, -STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP(-(stix_ooi_t)w);
}
}
@ -737,7 +737,7 @@ static STIX_INLINE int is_equal (stix_t* stix, stix_oop_t x, stix_oop_t y)
STIX_MEMCMP(((stix_oop_liword_t)x)->slot, ((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(x) * STIX_SIZEOF(stix_liw_t)) == 0;
}
static void complement2_unsigned_array (const stix_liw_t* x, stix_oow_t xs, stix_liw_t* z)
static void complement2_unsigned_array (stix_t* stix, const stix_liw_t* x, stix_oow_t xs, stix_liw_t* z)
{
stix_oow_t i;
stix_lidw_t w;
@ -762,7 +762,7 @@ static void complement2_unsigned_array (const stix_liw_t* x, stix_oow_t xs, stix
* this function is not designed to handle such a case.
* in fact, 0 is a small integer and it must not stand a change
* to be given to this function */
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
}
static STIX_INLINE stix_oow_t add_unsigned_array (const stix_liw_t* x, stix_oow_t xs, const stix_liw_t* y, stix_oow_t ys, stix_liw_t* z)
@ -857,7 +857,7 @@ static STIX_INLINE stix_oow_t add_unsigned_array (const stix_liw_t* x, stix_oow_
#endif
}
static STIX_INLINE stix_oow_t subtract_unsigned_array (const stix_liw_t* x, stix_oow_t xs, const stix_liw_t* y, stix_oow_t ys, stix_liw_t* z)
static STIX_INLINE stix_oow_t subtract_unsigned_array (stix_t* stix, const stix_liw_t* x, stix_oow_t xs, const stix_liw_t* y, stix_oow_t ys, stix_liw_t* z)
{
#if 1
stix_oow_t i;
@ -865,12 +865,12 @@ static STIX_INLINE stix_oow_t subtract_unsigned_array (const stix_liw_t* x, stix
if (x == y)
{
STIX_ASSERT (xs == ys);
STIX_ASSERT (stix, xs == ys);
z[0] = 0;
return 1;
}
STIX_ASSERT (!is_less_unsigned_array(x, xs, y, ys));
STIX_ASSERT (stix, !is_less_unsigned_array(x, xs, y, ys));
for (i = 0; i < ys; i++)
{
@ -903,12 +903,12 @@ static STIX_INLINE stix_oow_t subtract_unsigned_array (const stix_liw_t* x, stix
if (x == y)
{
STIX_ASSERT (xs == ys);
STIX_ASSERT (stix, xs == ys);
z[0] = 0;
return 1;
}
STIX_ASSERT (!is_less_unsigned_array(x, xs, y, ys));
STIX_ASSERT (stix, !is_less_unsigned_array(x, xs, y, ys));
borrowed_word = (stix_lidw_t)1 << STIX_LIW_BITS;
for (i = 0; i < ys; i++)
@ -940,7 +940,7 @@ static STIX_INLINE stix_oow_t subtract_unsigned_array (const stix_liw_t* x, stix
}
}
STIX_ASSERT (borrow == 0);
STIX_ASSERT (stix, borrow == 0);
while (i > 1 && z[i - 1] == 0) i--;
return i; /* the number of effective digits in the result */
@ -1120,8 +1120,8 @@ static STIX_INLINE stix_oow_t multiply_unsigned_array_karatsuba (stix_t* stix, c
ndigits_yl = nshifts; /* ndigits of lower part of y */
ndigits_yh = ys - nshifts; /* ndigits of uppoer part of y */
STIX_ASSERT (ndigits_xl >= ndigits_xh);
STIX_ASSERT (ndigits_yl >= ndigits_yh);
STIX_ASSERT (stix, ndigits_xl >= ndigits_xh);
STIX_ASSERT (stix, ndigits_yl >= ndigits_yh);
/* make a temporary buffer for (b0 + b1) and (a1 * b1) */
tmplen[0] = ndigits_xh + ndigits_yh;
@ -1186,10 +1186,10 @@ static STIX_INLINE stix_oow_t multiply_unsigned_array_karatsuba (stix_t* stix, c
}
/* (a0+a1)*(b0+b1) -(a0*b0) */
xlen = subtract_unsigned_array(zsp, xlen, tmp[0], tmplen[0], zsp);
xlen = subtract_unsigned_array(stix, zsp, xlen, tmp[0], tmplen[0], zsp);
/* (a0+a1)*(b0+b1) - (a0*b0) - (a1*b1) */
xlen = subtract_unsigned_array(zsp, xlen, tmp[1], tmplen[1], zsp);
xlen = subtract_unsigned_array(stix, zsp, xlen, tmp[1], tmplen[1], zsp);
/* a1b1 is in tmp[1]. add (a1b1 * B^2n) to the high part of 'z' */
zsp = z + (nshifts * 2); /* emulate shifting for "* B^2n". */
xlen = zcapa - (nshifts * 2);
@ -1240,8 +1240,8 @@ oops:
ndigits_yl = nshifts; /* ndigits of lower part of y */
ndigits_yh = ys - nshifts; /* ndigits of uppoer part of y */
STIX_ASSERT (ndigits_xl >= ndigits_xh);
STIX_ASSERT (ndigits_yl >= ndigits_yh);
STIX_ASSERT (stix, ndigits_xl >= ndigits_xh);
STIX_ASSERT (stix, ndigits_yl >= ndigits_yh);
/* make a temporary buffer for (b0 + b1) and (a1 * b1) */
tmplen[0] = ndigits_yl + ndigits_yh + 1;
@ -1305,11 +1305,11 @@ oops:
}
/* w = w - tmp[0] */
xlen = subtract_unsigned_array(tmp[2], xlen, tmp[0], tmplen[0], tmp[2]);
xlen = subtract_unsigned_array(stix, tmp[2], xlen, tmp[0], tmplen[0], tmp[2]);
/* r = w - tmp[1] */
zsp = z + nshifts; /* emulate shifting for "* B^n" */
xlen = subtract_unsigned_array(tmp[2], xlen, tmp[1], tmplen[1], zsp);
xlen = subtract_unsigned_array(stix, tmp[2], xlen, tmp[1], tmplen[1], zsp);
/* a1b1 is in tmp[1]. add (a1b1 * B^2n) to the high part of 'z' */
zsp = z + (nshifts * 2); /* emulate shifting for "* B^2n". */
@ -1405,10 +1405,7 @@ static STIX_INLINE void rshift_unsigned_array (stix_liw_t* x, stix_oow_t xs, sti
STIX_MEMSET (&x[xs - word_shifts], 0, word_shifts * STIX_SIZEOF(stix_liw_t));
}
static void divide_unsigned_array (
const stix_liw_t* x, stix_oow_t xs,
const stix_liw_t* y, stix_oow_t ys,
stix_liw_t* q, stix_liw_t* r)
static void divide_unsigned_array (stix_t* stix, const stix_liw_t* x, stix_oow_t xs, const stix_liw_t* y, stix_oow_t ys, stix_liw_t* q, stix_liw_t* r)
{
/* TODO: this function needs to be rewritten for performance improvement.
* the binary long division is extremely slow for a big number */
@ -1430,7 +1427,7 @@ static void divide_unsigned_array (
stix_oow_t rs, i , j;
STIX_ASSERT (xs >= ys);
STIX_ASSERT (stix, xs >= ys);
STIX_MEMSET (q, 0, STIX_SIZEOF(*q) * xs);
STIX_MEMSET (r, 0, STIX_SIZEOF(*q) * xs);
@ -1447,7 +1444,7 @@ static void divide_unsigned_array (
rs = count_effective (r, xs);
if (!is_less_unsigned_array (r, rs, y, ys))
{
subtract_unsigned_array (r, rs, y, ys, r);
subtract_unsigned_array (stix, r, rs, y, ys, r);
STIX_SETBITS (stix_liw_t, q[i], j, 1, 1);
}
}
@ -1489,7 +1486,7 @@ static stix_oop_t subtract_unsigned_integers (stix_t* stix, stix_oop_t x, stix_o
{
stix_oop_t z;
STIX_ASSERT (!is_less_unsigned(x, y));
STIX_ASSERT (stix, !is_less_unsigned(x, y));
stix_pushtmp (stix, &x);
stix_pushtmp (stix, &y);
@ -1497,7 +1494,7 @@ static stix_oop_t subtract_unsigned_integers (stix_t* stix, stix_oop_t x, stix_o
stix_poptmps (stix, 2);
if (!z) return STIX_NULL;
subtract_unsigned_array (
subtract_unsigned_array (stix,
((stix_oop_liword_t)x)->slot, STIX_OBJ_GET_SIZE(x),
((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y),
((stix_oop_liword_t)z)->slot);
@ -1551,7 +1548,7 @@ static stix_oop_t divide_unsigned_integers (stix_t* stix, stix_oop_t x, stix_oop
stix_oop_t qq, rr;
/* the caller must ensure that x >= y */
STIX_ASSERT (!is_less_unsigned (x, y));
STIX_ASSERT (stix, !is_less_unsigned (x, y));
stix_pushtmp (stix, &x);
stix_pushtmp (stix, &y);
qq = stix_instantiate (stix, stix->_large_positive_integer, STIX_NULL, STIX_OBJ_GET_SIZE(x));
@ -1566,7 +1563,7 @@ static stix_oop_t divide_unsigned_integers (stix_t* stix, stix_oop_t x, stix_oop
stix_poptmps (stix, 3);
if (!rr) return STIX_NULL;
divide_unsigned_array (
divide_unsigned_array (stix,
((stix_oop_liword_t)x)->slot, STIX_OBJ_GET_SIZE(x),
((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y),
((stix_oop_liword_t)qq)->slot, ((stix_oop_liword_t)rr)->slot);
@ -1585,8 +1582,8 @@ stix_oop_t stix_addints (stix_t* stix, stix_oop_t x, stix_oop_t y)
/* no integer overflow/underflow must occur as the possible integer
* range is narrowed by the tag bits used */
STIX_ASSERT (STIX_SMOOI_MAX + STIX_SMOOI_MAX < STIX_TYPE_MAX(stix_ooi_t));
STIX_ASSERT (STIX_SMOOI_MIN + STIX_SMOOI_MIN > STIX_TYPE_MIN(stix_ooi_t));
STIX_ASSERT (stix, STIX_SMOOI_MAX + STIX_SMOOI_MAX < STIX_TYPE_MAX(stix_ooi_t));
STIX_ASSERT (stix, STIX_SMOOI_MIN + STIX_SMOOI_MIN > STIX_TYPE_MIN(stix_ooi_t));
i = STIX_OOP_TO_SMOOI(x) + STIX_OOP_TO_SMOOI(y);
if (STIX_IN_SMOOI_RANGE(i)) return STIX_SMOOI_TO_OOP(i);
@ -1688,8 +1685,8 @@ stix_oop_t stix_subints (stix_t* stix, stix_oop_t x, stix_oop_t y)
/* no integer overflow/underflow must occur as the possible integer
* range is narrowed by the tag bits used */
STIX_ASSERT (STIX_SMOOI_MAX - STIX_SMOOI_MIN < STIX_TYPE_MAX(stix_ooi_t));
STIX_ASSERT (STIX_SMOOI_MIN - STIX_SMOOI_MAX > STIX_TYPE_MIN(stix_ooi_t));
STIX_ASSERT (stix, STIX_SMOOI_MAX - STIX_SMOOI_MIN < STIX_TYPE_MAX(stix_ooi_t));
STIX_ASSERT (stix, STIX_SMOOI_MIN - STIX_SMOOI_MAX > STIX_TYPE_MIN(stix_ooi_t));
i = STIX_OOP_TO_SMOOI(x) - STIX_OOP_TO_SMOOI(y);
if (STIX_IN_SMOOI_RANGE(i)) return STIX_SMOOI_TO_OOP(i);
@ -1786,7 +1783,7 @@ stix_oop_t stix_mulints (stix_t* stix, stix_oop_t x, stix_oop_t y)
xv = STIX_OOP_TO_SMOOI(x);
yv = STIX_OOP_TO_SMOOI(y);
if (smooi_mul_overflow (xv, yv, &i))
if (smooi_mul_overflow (stix, xv, yv, &i))
{
/* overflowed - convert x and y normal objects and carry on */
@ -1916,7 +1913,7 @@ stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, s
*/
q = xv / yv;
STIX_ASSERT (STIX_IN_SMOOI_RANGE(q));
STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(q));
r = xv - yv * q; /* xv % yv; */
if (r)
@ -1941,7 +1938,7 @@ stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, s
* change the sign of r to the divisor's sign */
r += yv;
--q;
STIX_ASSERT (r && !IS_SIGN_DIFF(yv, r));
STIX_ASSERT (stix, r && !IS_SIGN_DIFF(yv, r));
}
}
else
@ -1965,14 +1962,14 @@ stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, s
* architecture. */
r -= yv;
++q;
STIX_ASSERT (xv && !IS_SIGN_DIFF(xv, r));
STIX_ASSERT (stix, xv && !IS_SIGN_DIFF(xv, r));
}
}
}
if (rem)
{
STIX_ASSERT (STIX_IN_SMOOI_RANGE(r));
STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(r));
*rem = STIX_SMOOI_TO_OOP(r);
}
@ -2231,7 +2228,7 @@ stix_oop_t stix_bitatint (stix_t* stix, stix_oop_t x, stix_oop_t y)
#if defined(STIX_LIMIT_OBJ_SIZE)
if (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer) return STIX_SMOOI_TO_OOP(0);
STIX_ASSERT (STIX_OBJ_SIZE_BITS_MAX <= STIX_TYPE_MAX(stix_oow_t));
STIX_ASSERT (stix, STIX_OBJ_SIZE_BITS_MAX <= STIX_TYPE_MAX(stix_oow_t));
if (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer)
{
return STIX_SMOOI_TO_OOP (0);
@ -2246,7 +2243,7 @@ stix_oop_t stix_bitatint (stix_t* stix, stix_oop_t x, stix_oop_t y)
if (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer) return STIX_SMOOI_TO_OOP(0);
sign = bigint_to_oow (stix, y, &w);
STIX_ASSERT (sign >= 0);
STIX_ASSERT (stix, sign >= 0);
if (sign >= 1)
{
wp = (w - 1) / STIX_LIW_BITS;
@ -2256,7 +2253,7 @@ stix_oop_t stix_bitatint (stix_t* stix, stix_oop_t x, stix_oop_t y)
{
stix_oop_t quo, rem;
STIX_ASSERT (sign == 0);
STIX_ASSERT (stix, sign == 0);
stix_pushtmp (stix, &x);
y = stix_subints (stix, y, STIX_SMOOI_TO_OOP(1));
@ -2269,7 +2266,7 @@ stix_oop_t stix_bitatint (stix_t* stix, stix_oop_t x, stix_oop_t y)
if (!quo) return STIX_NULL;
sign = integer_to_oow (stix, quo, &wp);
STIX_ASSERT (sign >= 0);
STIX_ASSERT (stix, sign >= 0);
if (sign == 0)
{
/* too large. set it to xs so that it gets out of
@ -2277,9 +2274,9 @@ stix_oop_t stix_bitatint (stix_t* stix, stix_oop_t x, stix_oop_t y)
wp = xs;
}
STIX_ASSERT (STIX_OOP_IS_SMOOI(rem));
STIX_ASSERT (stix, STIX_OOP_IS_SMOOI(rem));
bp = STIX_OOP_TO_SMOOI(rem);
STIX_ASSERT (bp >= 0 && bp < STIX_LIW_BITS);
STIX_ASSERT (stix, bp >= 0 && bp < STIX_LIW_BITS);
}
if (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer)
@ -2429,7 +2426,7 @@ stix_oop_t stix_bitandints (stix_t* stix, stix_oop_t x, stix_oop_t y)
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] & (stix_liw_t)w[1];
}
STIX_ASSERT (carry[1] == 0);
STIX_ASSERT (stix, carry[1] == 0);
/* 2's complement on the remaining part of x. the lacking part
* in y is treated as if they are all 1s. */
@ -2439,7 +2436,7 @@ stix_oop_t stix_bitandints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry[0] = w[0] >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0];
}
STIX_ASSERT (carry[0] == 0);
STIX_ASSERT (stix, carry[0] == 0);
/* 2's complement on the final result */
((stix_oop_liword_t)z)->slot[zs] = ~(stix_liw_t)0;
@ -2450,7 +2447,7 @@ stix_oop_t stix_bitandints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry[0] = w[0] >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0];
}
STIX_ASSERT (carry[0] == 0);
STIX_ASSERT (stix, carry[0] == 0);
STIX_OBJ_SET_CLASS (z, stix->_large_negative_integer);
}
@ -2484,7 +2481,7 @@ stix_oop_t stix_bitandints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] & (stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
/* handle the longer part in x than y
*
@ -2649,7 +2646,7 @@ stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] | (stix_liw_t)w[1];
}
STIX_ASSERT (carry[1] == 0);
STIX_ASSERT (stix, carry[1] == 0);
/* do nothing about the extra part in x and the lacking part
* in y for the reason shown in [NOTE] in the 'else if' block
@ -2665,7 +2662,7 @@ stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry[0] = w[0] >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0];
}
STIX_ASSERT (carry[0] == 0);
STIX_ASSERT (stix, carry[0] == 0);
STIX_OBJ_SET_CLASS (z, stix->_large_negative_integer);
}
@ -2689,7 +2686,7 @@ stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
goto adjust_to_negative;
}
else if (negy)
@ -2705,7 +2702,7 @@ stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] | (stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
/* [NOTE]
* in theory, the lacking part in ys is all 1s when y is
@ -2867,7 +2864,7 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] ^ (stix_liw_t)w[1];
}
STIX_ASSERT (carry[1] == 0);
STIX_ASSERT (stix, carry[1] == 0);
/* treat the lacking part in y as all 1s */
for (; i < xs; i++)
@ -2876,7 +2873,7 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry[0] = w[0] >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] ^ (~(stix_liw_t)0);
}
STIX_ASSERT (carry[0] == 0);
STIX_ASSERT (stix, carry[0] == 0);
}
else if (negx)
{
@ -2898,7 +2895,7 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
adjust_to_negative:
/* 2's complement on the final result */
@ -2910,7 +2907,7 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
STIX_OBJ_SET_CLASS (z, stix->_large_negative_integer);
}
@ -2927,7 +2924,7 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] ^ (stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
/* treat the lacking part in y as all 1s */
for (; i < xs; i++)
@ -3017,7 +3014,7 @@ stix_oop_t stix_bitinvint (stix_t* stix, stix_oop_t x)
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ~(stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
}
else
{
@ -3037,7 +3034,7 @@ stix_oop_t stix_bitinvint (stix_t* stix, stix_oop_t x)
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
#else
carry = 1;
for (i = 0; i < xs; i++)
@ -3046,9 +3043,9 @@ stix_oop_t stix_bitinvint (stix_t* stix, stix_oop_t x)
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
}
STIX_ASSERT (i == zs);
STIX_ASSERT (stix, i == zs);
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)carry;
STIX_ASSERT ((carry >> STIX_LIW_BITS) == 0);
STIX_ASSERT (stix, (carry >> STIX_LIW_BITS) == 0);
#endif
STIX_OBJ_SET_CLASS (z, stix->_large_negative_integer);
@ -3069,7 +3066,7 @@ static STIX_INLINE stix_oop_t rshift_negative_bigint (stix_t* stix, stix_oop_t x
stix_lidw_t carry;
stix_oow_t i, xs;
STIX_ASSERT (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer);
xs = STIX_OBJ_GET_SIZE(x);
stix_pushtmp (stix, &x);
@ -3086,7 +3083,7 @@ static STIX_INLINE stix_oop_t rshift_negative_bigint (stix_t* stix, stix_oop_t x
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ~(stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
/* shift to the right */
rshift_unsigned_array (((stix_oop_liword_t)z)->slot, xs, shift);
@ -3106,7 +3103,7 @@ static STIX_INLINE stix_oop_t rshift_negative_bigint (stix_t* stix, stix_oop_t x
carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
}
STIX_ASSERT (carry == 0);
STIX_ASSERT (stix, carry == 0);
#else
carry = 1;
for (i = 0; i < xs; i++)
@ -3116,7 +3113,7 @@ static STIX_INLINE stix_oop_t rshift_negative_bigint (stix_t* stix, stix_oop_t x
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
}
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)carry;
STIX_ASSERT ((carry >> STIX_LIW_BITS) == 0);
STIX_ASSERT (stix, (carry >> STIX_LIW_BITS) == 0);
#endif
return z; /* z is not normalized */
@ -3132,8 +3129,8 @@ static STIX_INLINE stix_oop_t rshift_negative_bigint_and_normalize (stix_t* stix
stix_oow_t shift;
int sign;
STIX_ASSERT (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer);
STIX_ASSERT (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer);
/* for convenience in subtraction below.
* it could be STIX_TYPE_MAX(stix_oow_t)
@ -3162,7 +3159,7 @@ static STIX_INLINE stix_oop_t rshift_negative_bigint_and_normalize (stix_t* stix
/* no more shift */
return normalize_bigint (stix, z);
}
STIX_ASSERT (sign <= -1);
STIX_ASSERT (stix, sign <= -1);
}
stix_pushtmp (stix, &y);
@ -3176,7 +3173,7 @@ static STIX_INLINE stix_oop_t rshift_negative_bigint_and_normalize (stix_t* stix
stix_ooi_t v;
v = STIX_OOP_TO_SMOOI(x);
STIX_ASSERT (v < 0);
STIX_ASSERT (stix, v < 0);
/* normal right shift of a small negative integer */
if (shift >= STIX_OOI_BITS - 1)
@ -3199,7 +3196,7 @@ static STIX_INLINE stix_oop_t rshift_negative_bigint_and_normalize (stix_t* stix
while (1);
/* this part must not be reached */
STIX_ASSERT (!"internal error - must not happen");
STIX_ASSERT (stix, !"internal error - must not happen");
stix->errnum = STIX_EINTERN;
return STIX_NULL;
}
@ -3210,8 +3207,8 @@ static STIX_INLINE stix_oop_t rshift_positive_bigint_and_normalize (stix_t* stix
stix_oow_t zs, shift;
int sign;
STIX_ASSERT (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer);
STIX_ASSERT (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer);
zs = STIX_OBJ_GET_SIZE(x);
@ -3246,7 +3243,7 @@ static STIX_INLINE stix_oop_t rshift_positive_bigint_and_normalize (stix_t* stix
else
{
if (shift == 0) break;
STIX_ASSERT (sign <= -1);
STIX_ASSERT (stix, sign <= -1);
}
}
while (1);
@ -3260,7 +3257,7 @@ static STIX_INLINE stix_oop_t lshift_bigint_and_normalize (stix_t* stix, stix_oo
stix_oow_t wshift, shift;
int sign;
STIX_ASSERT (STIX_OBJ_GET_CLASS(y) == stix->_large_positive_integer);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(y) == stix->_large_positive_integer);
/* this loop is very inefficient as shifting is repeated
* with lshift_unsigned_array(). however, this part of the
@ -3300,16 +3297,16 @@ static STIX_INLINE stix_oop_t lshift_bigint_and_normalize (stix_t* stix, stix_oo
{
if (shift == 0)
{
STIX_ASSERT (is_normalized_integer (stix, x));
STIX_ASSERT (stix, is_normalized_integer (stix, x));
return x;
}
STIX_ASSERT (sign >= 1);
STIX_ASSERT (stix, sign >= 1);
}
}
while (1);
/* this part must not be reached */
STIX_ASSERT (!"internal error - must not happen");
STIX_ASSERT (stix, !"internal error - must not happen");
stix->errnum = STIX_EINTERN;
return STIX_NULL;
}
@ -3466,7 +3463,7 @@ stix_oop_t stix_bitshiftint (stix_t* stix, stix_oop_t x, stix_oop_t y)
/* the maximum number of bit shifts are guaranteed to be
* small enough to fit into the stix_oow_t type. so i can
* easily assume that all bits are shifted out */
STIX_ASSERT (STIX_OBJ_SIZE_BITS_MAX <= STIX_TYPE_MAX(stix_oow_t));
STIX_ASSERT (stix, STIX_OBJ_SIZE_BITS_MAX <= STIX_TYPE_MAX(stix_oow_t));
return (negx)? STIX_SMOOI_TO_OOP(-1): STIX_SMOOI_TO_OOP(0);
#else
if (negx)
@ -3483,7 +3480,7 @@ stix_oop_t stix_bitshiftint (stix_t* stix, stix_oop_t x, stix_oop_t y)
* small enough to fit into the stix_oow_t type. so i can
* simply return a failure here becuase it's surely too
* large after shifting */
STIX_ASSERT (STIX_TYPE_MAX(stix_oow_t) >= STIX_OBJ_SIZE_BITS_MAX);
STIX_ASSERT (stix, STIX_TYPE_MAX(stix_oow_t) >= STIX_OBJ_SIZE_BITS_MAX);
stix->errnum = STIX_EOOMEM; /* is it a soft failure or a hard failure? is this error code proper? */
return STIX_NULL;
#else
@ -3510,7 +3507,7 @@ stix_oop_t stix_bitshiftint (stix_t* stix, stix_oop_t x, stix_oop_t y)
/* right shift */
bigint_and_negative_oow:
STIX_ASSERT (sign <= -1);
STIX_ASSERT (stix, sign <= -1);
if (negx)
{
@ -3562,7 +3559,7 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
radix = -radix;
}
STIX_ASSERT (radix >= 2 && radix <= 36);
STIX_ASSERT (stix, radix >= 2 && radix <= 36);
ptr = str;
end = str + len;
@ -3667,7 +3664,7 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
ptr--;
}
STIX_ASSERT (w <= STIX_TYPE_MAX(stix_liw_t));
STIX_ASSERT (stix, w <= STIX_TYPE_MAX(stix_liw_t));
if (hwlen == 0 || w > 0) hwp[hwlen++] = w;
}
else
@ -3693,7 +3690,7 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
hwp = hw;
}
STIX_ASSERT (ptr < end);
STIX_ASSERT (stix, ptr < end);
do
{
r1 = 0;
@ -3740,25 +3737,25 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
while (ptr < end);
}
STIX_ASSERT (hwlen >= 1);
STIX_ASSERT (stix, hwlen >= 1);
#if (STIX_LIW_BITS == STIX_OOW_BITS)
if (hwlen == 1)
{
w = hwp[0];
STIX_ASSERT (-STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (stix, -STIX_SMOOI_MAX == STIX_SMOOI_MIN);
if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP((stix_ooi_t)w * sign);
}
#elif (STIX_LIW_BITS == STIX_OOHW_BITS)
if (hwlen == 1)
{
STIX_ASSERT (hwp[0] <= STIX_SMOOI_MAX);
STIX_ASSERT (stix, hwp[0] <= STIX_SMOOI_MAX);
return STIX_SMOOI_TO_OOP((stix_ooi_t)hwp[0] * sign);
}
else if (hwlen == 2)
{
w = MAKE_WORD(hwp[0], hwp[1]);
STIX_ASSERT (-STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (stix, -STIX_SMOOI_MAX == STIX_SMOOI_MIN);
if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP((stix_ooi_t)w * sign);
}
#else
@ -3776,10 +3773,10 @@ oops_einval:
return STIX_NULL;
}
static stix_oow_t oow_to_text (stix_oow_t w, int radix, stix_ooch_t* buf)
static stix_oow_t oow_to_text (stix_t* stix, stix_oow_t w, int radix, stix_ooch_t* buf)
{
stix_ooch_t* ptr;
STIX_ASSERT (radix >= 2 && radix <= 36);
STIX_ASSERT (stix, radix >= 2 && radix <= 36);
ptr = buf;
do
@ -3974,7 +3971,7 @@ stix_oop_t stix_inttostr (stix_t* stix, stix_oop_t num, int radix)
stix_oow_t xlen = 0, seglen;
stix_oop_t s;
STIX_ASSERT (radix >= 2 && radix <= 36);
STIX_ASSERT (stix, radix >= 2 && radix <= 36);
if (!stix_isint(stix,num)) goto oops_einval;
v = integer_to_oow (stix, num, &w);
@ -3989,7 +3986,7 @@ stix_oop_t stix_inttostr (stix_t* stix, stix_oop_t num, int radix)
stix_ooch_t buf[STIX_OOW_BITS + 1];
stix_oow_t len;
len = oow_to_text (w, radix, buf);
len = oow_to_text (stix, w, radix, buf);
if (v < 0) buf[len++] = '-';
reverse_string (buf, len);
@ -4038,7 +4035,7 @@ stix_oop_t stix_inttostr (stix_t* stix, stix_oop_t num, int radix)
while (1);
}
STIX_ASSERT (xpos >= 1);
STIX_ASSERT (stix, xpos >= 1);
if (STIX_OBJ_GET_CLASS(num) == stix->_large_negative_integer) xbuf[--xpos] = '-';
s = stix_makestring (stix, &xbuf[xpos], xlen - xpos);
@ -4082,7 +4079,7 @@ stix_oop_t stix_inttostr (stix_t* stix, stix_oop_t num, int radix)
{
stix_liw_t* tmp;
divide_unsigned_array (a, as, b, bs, q, r);
divide_unsigned_array (stix, a, as, b, bs, q, r);
/* get 'rs' before 'as' gets changed */
rs = count_effective (r, as);
@ -4102,19 +4099,19 @@ stix_oop_t stix_inttostr (stix_t* stix, stix_oop_t num, int radix)
}
#if (STIX_LIW_BITS == STIX_OOW_BITS)
STIX_ASSERT (rs == 1);
STIX_ASSERT (stix, rs == 1);
w = r[0];
#elif (STIX_LIW_BITS == STIX_OOHW_BITS)
if (rs == 1) w = r[0];
else
{
STIX_ASSERT (rs == 2);
STIX_ASSERT (stix, rs == 2);
w = MAKE_WORD (r[0], r[1]);
}
#else
# error UNSUPPORTED LIW BIT SIZE
#endif
seglen = oow_to_text (w, radix, &xbuf[xlen]);
seglen = oow_to_text (stix, w, radix, &xbuf[xlen]);
xlen += seglen;
if (r == a) break; /* reached the last block */

116
stix/lib/comp.c
View File

@ -405,7 +405,7 @@ static int string_to_smooi (stix_t* stix, stix_oocs_t* str, int radixed, stix_oo
ptr = str->ptr,
end = str->ptr + str->len;
STIX_ASSERT (ptr < end);
STIX_ASSERT (stix, ptr < end);
if (*ptr == '+' || *ptr == '-')
{
@ -415,7 +415,7 @@ static int string_to_smooi (stix_t* stix, stix_oocs_t* str, int radixed, stix_oo
if (radixed)
{
STIX_ASSERT (ptr < end);
STIX_ASSERT (stix, ptr < end);
base = 0;
do
@ -429,7 +429,7 @@ static int string_to_smooi (stix_t* stix, stix_oocs_t* str, int radixed, stix_oo
}
else base = 10;
STIX_ASSERT (ptr < end);
STIX_ASSERT (stix, ptr < end);
value = old_value = 0;
while (ptr < end && (v = CHAR_TO_NUM(*ptr, base)) < base)
@ -452,7 +452,7 @@ static int string_to_smooi (stix_t* stix, stix_oocs_t* str, int radixed, stix_oo
return -1;
}
STIX_ASSERT (-STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (stix, -STIX_SMOOI_MAX == STIX_SMOOI_MIN);
if (value > STIX_SMOOI_MAX)
{
stix->errnum = STIX_ERANGE;
@ -474,7 +474,7 @@ static stix_oop_t string_to_num (stix_t* stix, stix_oocs_t* str, int radixed)
ptr = str->ptr,
end = str->ptr + str->len;
STIX_ASSERT (ptr < end);
STIX_ASSERT (stix, ptr < end);
if (*ptr == '+' || *ptr == '-')
{
@ -484,7 +484,7 @@ static stix_oop_t string_to_num (stix_t* stix, stix_oocs_t* str, int radixed)
if (radixed)
{
STIX_ASSERT (ptr < end);
STIX_ASSERT (stix, ptr < end);
base = 0;
do
@ -588,7 +588,7 @@ static STIX_INLINE int add_token_char (stix_t* stix, stix_ooch_t c)
static STIX_INLINE void unget_char (stix_t* stix, const stix_iolxc_t* c)
{
/* Make sure that the unget buffer is large enough */
STIX_ASSERT (stix->c->nungots < STIX_COUNTOF(stix->c->ungot));
STIX_ASSERT (stix, stix->c->nungots < STIX_COUNTOF(stix->c->ungot));
stix->c->ungot[stix->c->nungots++] = *c;
}
@ -937,7 +937,7 @@ static int get_numlit (stix_t* stix, int negated)
{
/* collect the potential radix specifier */
r = CHAR_TO_NUM (c, 10);
STIX_ASSERT (r < 10);
STIX_ASSERT (stix, r < 10);
radix = radix * 10 + r;
}
@ -1570,7 +1570,7 @@ static void clear_io_names (stix_t* stix)
{
stix_iolink_t* cur;
STIX_ASSERT (stix->c != STIX_NULL);
STIX_ASSERT (stix, stix->c != STIX_NULL);
while (stix->c->io_names)
{
@ -1673,7 +1673,7 @@ static int end_include (stix_t* stix)
cur = stix->c->curinp;
stix->c->curinp = stix->c->curinp->includer;
STIX_ASSERT (cur->name != STIX_NULL);
STIX_ASSERT (stix, cur->name != STIX_NULL);
stix_freemem (stix, cur);
/* stix->parse.depth.incl--; */
@ -2047,7 +2047,7 @@ static stix_ooi_t find_class_level_variable (stix_t* stix, stix_oop_class_t self
if (self)
{
STIX_ASSERT (STIX_CLASSOF(stix, self) == stix->_class);
STIX_ASSERT (stix, STIX_CLASSOF(stix, self) == stix->_class);
/* [NOTE]
* the loop here assumes that the class has the following
@ -2095,7 +2095,7 @@ static stix_ooi_t find_class_level_variable (stix_t* stix, stix_oop_class_t self
while (super != stix->_nil)
{
STIX_ASSERT (STIX_CLASSOF(stix, super) == stix->_class);
STIX_ASSERT (stix, STIX_CLASSOF(stix, super) == stix->_class);
/* [NOTE]
* the loop here assumes that the class has the following
@ -2138,7 +2138,7 @@ done:
/* the class being compiled has a superclass */
STIX_ASSERT (STIX_CLASSOF(stix, super) == stix->_class);
STIX_ASSERT (stix, STIX_CLASSOF(stix, super) == stix->_class);
switch (index)
{
case VAR_INSTANCE:
@ -2562,8 +2562,8 @@ if super is variable-nonpointer, no instance variable is allowed.
static int compile_unary_method_name (stix_t* stix)
{
STIX_ASSERT (stix->c->mth.name.len == 0);
STIX_ASSERT (stix->c->mth.tmpr_nargs == 0);
STIX_ASSERT (stix, stix->c->mth.name.len == 0);
STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 0);
if (add_method_name_fragment(stix, TOKEN_NAME(stix)) <= -1) return -1;
GET_TOKEN (stix);
@ -2571,7 +2571,7 @@ static int compile_unary_method_name (stix_t* stix)
if (TOKEN_TYPE(stix) == STIX_IOTOK_LPAREN)
{
/* this is a procedural style method */
STIX_ASSERT (stix->c->mth.tmpr_nargs == 0);
STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 0);
GET_TOKEN (stix);
if (TOKEN_TYPE(stix) != STIX_IOTOK_RPAREN)
@ -2618,8 +2618,8 @@ static int compile_unary_method_name (stix_t* stix)
static int compile_binary_method_name (stix_t* stix)
{
STIX_ASSERT (stix->c->mth.name.len == 0);
STIX_ASSERT (stix->c->mth.tmpr_nargs == 0);
STIX_ASSERT (stix, stix->c->mth.name.len == 0);
STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 0);
if (add_method_name_fragment(stix, TOKEN_NAME(stix)) <= -1) return -1;
GET_TOKEN (stix);
@ -2632,14 +2632,14 @@ static int compile_binary_method_name (stix_t* stix)
return -1;
}
STIX_ASSERT (stix->c->mth.tmpr_nargs == 0);
STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 0);
/* no duplication check is performed against class-level variable names.
* a duplcate name will shade a previsouly defined variable. */
if (add_temporary_variable(stix, TOKEN_NAME(stix)) <= -1) return -1;
stix->c->mth.tmpr_nargs++;
STIX_ASSERT (stix->c->mth.tmpr_nargs == 1);
STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 1);
/* this check should not be not necessary
if (stix->c->mth.tmpr_nargs > MAX_CODE_NARGS)
{
@ -2654,8 +2654,8 @@ static int compile_binary_method_name (stix_t* stix)
static int compile_keyword_method_name (stix_t* stix)
{
STIX_ASSERT (stix->c->mth.name.len == 0);
STIX_ASSERT (stix->c->mth.tmpr_nargs == 0);
STIX_ASSERT (stix, stix->c->mth.name.len == 0);
STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 0);
do
{
@ -2697,7 +2697,7 @@ static int compile_method_name (stix_t* stix)
*/
int n;
STIX_ASSERT (stix->c->mth.tmpr_count == 0);
STIX_ASSERT (stix, stix->c->mth.tmpr_count == 0);
stix->c->mth.name_loc = stix->c->tok.loc;
switch (TOKEN_TYPE(stix))
@ -2729,7 +2729,7 @@ static int compile_method_name (stix_t* stix)
}
}
STIX_ASSERT (stix->c->mth.tmpr_nargs < MAX_CODE_NARGS);
STIX_ASSERT (stix, stix->c->mth.tmpr_nargs < MAX_CODE_NARGS);
/* the total number of temporaries is equal to the number of
* arguments after having processed the message pattern. it's because
* stix treats arguments the same as temporaries */
@ -2936,7 +2936,7 @@ static int get_variable_info (stix_t* stix, const stix_oocs_t* name, const stix_
const stix_ooch_t* dot;
dot = stix_findoochar (name->ptr, name->len, '.');
STIX_ASSERT (dot != STIX_NULL);
STIX_ASSERT (stix, dot != STIX_NULL);
if (dot - (const stix_ooch_t*)name->ptr == 4 &&
stix_equaloochars(name->ptr, vocas[VOCA_SELF].str, 4))
{
@ -3004,8 +3004,8 @@ static int get_variable_info (stix_t* stix, const stix_oocs_t* name, const stix_
case VAR_CLASS:
/* a class variable can be access by both instance methods and class methods */
STIX_ASSERT (var->cls != STIX_NULL);
STIX_ASSERT (STIX_CLASSOF(stix, var->cls) == stix->_class);
STIX_ASSERT (stix, var->cls != STIX_NULL);
STIX_ASSERT (stix, STIX_CLASSOF(stix, var->cls) == stix->_class);
/* increment the position by the number of class instance variables
* as the class variables are placed after the class instance variables */
@ -3175,14 +3175,14 @@ static int compile_block_expression (stix_t* stix)
*/
/* this function expects [ not to be consumed away */
STIX_ASSERT (TOKEN_TYPE(stix) == STIX_IOTOK_LBRACK);
STIX_ASSERT (stix, TOKEN_TYPE(stix) == STIX_IOTOK_LBRACK);
block_loc = stix->c->tok.loc;
GET_TOKEN (stix);
saved_tmprs_len = stix->c->mth.tmprs.len;
saved_tmpr_count = stix->c->mth.tmpr_count;
STIX_ASSERT (stix->c->mth.blk_depth > 0);
STIX_ASSERT (stix->c->mth.blk_tmprcnt[stix->c->mth.blk_depth - 1] == saved_tmpr_count);
STIX_ASSERT (stix, stix->c->mth.blk_depth > 0);
STIX_ASSERT (stix, stix->c->mth.blk_tmprcnt[stix->c->mth.blk_depth - 1] == saved_tmpr_count);
if (TOKEN_TYPE(stix) == STIX_IOTOK_COLON)
{
@ -3395,7 +3395,7 @@ static int __read_byte_array_literal (stix_t* stix, stix_oop_t* xlit)
{
/* the token reader reads a valid token. no other errors
* than the range error must not occur */
STIX_ASSERT (stix->errnum == STIX_ERANGE);
STIX_ASSERT (stix, stix->errnum == STIX_ERANGE);
/* if the token is out of the SMOOI range, it's too big or
* to small to be a byte */
@ -3454,7 +3454,7 @@ static int __read_array_literal (stix_t* stix, stix_oop_t* xlit)
break;
case STIX_IOTOK_CHARLIT:
STIX_ASSERT (TOKEN_NAME_LEN(stix) == 1);
STIX_ASSERT (stix, TOKEN_NAME_LEN(stix) == 1);
lit = STIX_CHAR_TO_OOP(TOKEN_NAME_PTR(stix)[0]);
break;
@ -3578,7 +3578,7 @@ static int compile_array_literal (stix_t* stix)
stix_oop_t lit;
stix_oow_t index;
STIX_ASSERT (stix->c->mth.arlit_count == 0);
STIX_ASSERT (stix, stix->c->mth.arlit_count == 0);
if (read_array_literal(stix, &lit) <= -1 ||
add_literal(stix, lit, &index) <= -1 ||
@ -3618,7 +3618,7 @@ static int compile_expression_primary (stix_t* stix, const stix_oocs_t* ident, c
/* if a temporary variable is accessed inside a block,
* use a special instruction to indicate it */
STIX_ASSERT (var.pos < stix->c->mth.blk_tmprcnt[stix->c->mth.blk_depth]);
STIX_ASSERT (stix, var.pos < stix->c->mth.blk_tmprcnt[stix->c->mth.blk_depth]);
for (i = stix->c->mth.blk_depth; i > 0; i--)
{
if (var.pos >= stix->c->mth.blk_tmprcnt[i - 1])
@ -3715,7 +3715,7 @@ static int compile_expression_primary (stix_t* stix, const stix_oocs_t* ident, c
break;
case STIX_IOTOK_CHARLIT:
STIX_ASSERT (TOKEN_NAME_LEN(stix) == 1);
STIX_ASSERT (stix, TOKEN_NAME_LEN(stix) == 1);
if (emit_push_character_literal(stix, TOKEN_NAME_PTR(stix)[0]) <= -1) return -1;
GET_TOKEN (stix);
break;
@ -3818,7 +3818,7 @@ static int compile_unary_message (stix_t* stix, int to_super)
stix_oow_t index;
stix_oow_t nargs;
STIX_ASSERT (TOKEN_TYPE(stix) == STIX_IOTOK_IDENT);
STIX_ASSERT (stix, TOKEN_TYPE(stix) == STIX_IOTOK_IDENT);
do
{
@ -3875,7 +3875,7 @@ static int compile_binary_message (stix_t* stix, int to_super)
stix_oocs_t binsel;
stix_oow_t saved_binsels_len, binsel_offset;
STIX_ASSERT (TOKEN_TYPE(stix) == STIX_IOTOK_BINSEL);
STIX_ASSERT (stix, TOKEN_TYPE(stix) == STIX_IOTOK_BINSEL);
do
{
@ -3999,7 +3999,7 @@ static int compile_message_expression (stix_t* stix, int to_super)
if (TOKEN_TYPE(stix) == STIX_IOTOK_BINSEL)
{
STIX_ASSERT (stix->c->mth.code.len > noop_pos);
STIX_ASSERT (stix, stix->c->mth.code.len > noop_pos);
STIX_MEMMOVE (&stix->c->mth.code.ptr[noop_pos], &stix->c->mth.code.ptr[noop_pos + 1], stix->c->mth.code.len - noop_pos - 1);
stix->c->mth.code.len--;
@ -4010,7 +4010,7 @@ static int compile_message_expression (stix_t* stix, int to_super)
if (TOKEN_TYPE(stix) == STIX_IOTOK_KEYWORD)
{
STIX_ASSERT (stix->c->mth.code.len > noop_pos);
STIX_ASSERT (stix, stix->c->mth.code.len > noop_pos);
STIX_MEMMOVE (&stix->c->mth.code.ptr[noop_pos], &stix->c->mth.code.ptr[noop_pos + 1], stix->c->mth.code.len - noop_pos - 1);
stix->c->mth.code.len--;
@ -4027,7 +4027,7 @@ static int compile_message_expression (stix_t* stix, int to_super)
if (compile_binary_message(stix, to_super) <= -1) return -1;
if (TOKEN_TYPE(stix) == STIX_IOTOK_KEYWORD)
{
STIX_ASSERT (stix->c->mth.code.len > noop_pos);
STIX_ASSERT (stix, stix->c->mth.code.len > noop_pos);
STIX_MEMMOVE (&stix->c->mth.code.ptr[noop_pos], &stix->c->mth.code.ptr[noop_pos + 1], stix->c->mth.code.len - noop_pos - 1);
stix->c->mth.code.len--;
@ -4058,7 +4058,7 @@ static int compile_message_expression (stix_t* stix, int to_super)
else
{
/* delete the NOOP instruction inserted */
STIX_ASSERT (stix->c->mth.code.len > noop_pos);
STIX_ASSERT (stix, stix->c->mth.code.len > noop_pos);
STIX_MEMMOVE (&stix->c->mth.code.ptr[noop_pos], &stix->c->mth.code.ptr[noop_pos + 1], stix->c->mth.code.len - noop_pos - 1);
stix->c->mth.code.len--;
goto done;
@ -4110,7 +4110,7 @@ static int compile_method_expression (stix_t* stix, int pop)
stix_oow_t index;
int ret = 0;
STIX_ASSERT (pop == 0 || pop == 1);
STIX_ASSERT (stix, pop == 0 || pop == 1);
STIX_MEMSET (&assignee, 0, STIX_SIZEOF(assignee));
if (TOKEN_TYPE(stix) == STIX_IOTOK_IDENT ||
@ -4164,7 +4164,7 @@ static int compile_method_expression (stix_t* stix, int pop)
/* if a temporary variable is accessed inside a block,
* use a special instruction to indicate it */
STIX_ASSERT (var.pos < stix->c->mth.blk_tmprcnt[stix->c->mth.blk_depth]);
STIX_ASSERT (stix, var.pos < stix->c->mth.blk_tmprcnt[stix->c->mth.blk_depth]);
for (i = stix->c->mth.blk_depth; i > 0; i--)
{
if (var.pos >= stix->c->mth.blk_tmprcnt[i - 1])
@ -4485,7 +4485,7 @@ static int add_compiled_method (stix_t* stix)
}
else
{
STIX_ASSERT (stix->c->mth.pftype == 4);
STIX_ASSERT (stix, stix->c->mth.pftype == 4);
preamble_code = STIX_METHOD_PREAMBLE_ENSURE;
preamble_index = 0;
}
@ -4493,7 +4493,7 @@ static int add_compiled_method (stix_t* stix)
if (stix->c->mth.variadic /*&& stix->c->mth.tmpr_nargs > 0*/)
preamble_flags |= STIX_METHOD_PREAMBLE_FLAG_VARIADIC;
STIX_ASSERT (STIX_OOI_IN_METHOD_PREAMBLE_INDEX_RANGE(preamble_index));
STIX_ASSERT (stix, STIX_OOI_IN_METHOD_PREAMBLE_INDEX_RANGE(preamble_index));
mth->owner = stix->c->cls.self_oop;
mth->name = name;
@ -4625,8 +4625,8 @@ static int make_defined_class (stix_t* stix)
{
/* this is an internally created class object being defined. */
STIX_ASSERT (STIX_CLASSOF(stix, stix->c->cls.self_oop) == stix->_class);
STIX_ASSERT (STIX_OBJ_GET_FLAGS_KERNEL (stix->c->cls.self_oop) == 1);
STIX_ASSERT (stix, STIX_CLASSOF(stix, stix->c->cls.self_oop) == stix->_class);
STIX_ASSERT (stix, STIX_OBJ_GET_FLAGS_KERNEL (stix->c->cls.self_oop) == 1);
if (spec != STIX_OOP_TO_SMOOI(stix->c->cls.self_oop->spec) ||
self_spec != STIX_OOP_TO_SMOOI(stix->c->cls.self_oop->selfspec))
@ -4647,7 +4647,7 @@ static int make_defined_class (stix_t* stix)
just_made = 1;
stix->c->cls.self_oop = (stix_oop_class_t)tmp;
STIX_ASSERT (STIX_CLASSOF(stix, stix->c->cls.self_oop) == stix->_class);
STIX_ASSERT (stix, STIX_CLASSOF(stix, stix->c->cls.self_oop) == stix->_class);
stix->c->cls.self_oop->spec = STIX_SMOOI_TO_OOP(spec);
stix->c->cls.self_oop->selfspec = STIX_SMOOI_TO_OOP(self_spec);
@ -4818,7 +4818,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
if (extend)
{
/* extending class */
STIX_ASSERT (stix->c->cls.flags == 0);
STIX_ASSERT (stix, stix->c->cls.flags == 0);
/*ass = stix_lookupsysdic(stix, &stix->c->cls.name);*/
ass = stix_lookupdic(stix, stix->c->cls.ns_oop, &stix->c->cls.name);
@ -4842,7 +4842,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
stix->c->cls.super_oop = stix->c->cls.self_oop->superclass;
STIX_ASSERT ((stix_oop_t)stix->c->cls.super_oop == stix->_nil ||
STIX_ASSERT (stix, (stix_oop_t)stix->c->cls.super_oop == stix->_nil ||
STIX_CLASSOF(stix, stix->c->cls.super_oop) == stix->_class);
}
else
@ -4921,7 +4921,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
{
/* no class of such a name is found. it's a new definition,
* which is normal for most new classes. */
STIX_ASSERT (stix->c->cls.self_oop == STIX_NULL);
STIX_ASSERT (stix, stix->c->cls.self_oop == STIX_NULL);
}
if (super_is_nil)
@ -5023,7 +5023,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
{
stix_ooch_t* ptr, * end;
STIX_ASSERT (STIX_CLASSOF(stix, pds) == stix->_string);
STIX_ASSERT (stix, STIX_CLASSOF(stix, pds) == stix->_string);
ptr = pds->slot;
end = pds->slot + STIX_OBJ_GET_SIZE(pds);
@ -5049,7 +5049,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
ptr++;
}
tok.len = ptr - tok.ptr;
STIX_ASSERT (tok.len > 0);
STIX_ASSERT (stix, tok.len > 0);
if (dotted)
{
@ -5127,7 +5127,7 @@ static int compile_class_definition (stix_t* stix, int extend)
STIX_MEMSET (&stix->c->cls.fqn_loc, 0, STIX_SIZEOF(stix->c->cls.fqn_loc));
STIX_MEMSET (&stix->c->cls.superfqn_loc, 0, STIX_SIZEOF(stix->c->cls.superfqn_loc));
STIX_ASSERT (STIX_COUNTOF(stix->c->cls.var_count) == STIX_COUNTOF(stix->c->cls.vars));
STIX_ASSERT (stix, STIX_COUNTOF(stix->c->cls.var_count) == STIX_COUNTOF(stix->c->cls.vars));
for (i = 0; i < STIX_COUNTOF(stix->c->cls.var_count); i++)
{
stix->c->cls.var_count[i] = 0;
@ -5246,7 +5246,7 @@ static int __compile_pooldic_definition (stix_t* stix)
goto add_literal;
case STIX_IOTOK_CHARLIT:
STIX_ASSERT (TOKEN_NAME_LEN(stix) == 1);
STIX_ASSERT (stix, TOKEN_NAME_LEN(stix) == 1);
lit = STIX_CHAR_TO_OOP(TOKEN_NAME_PTR(stix)[0]);
goto add_literal;
@ -5549,7 +5549,7 @@ int stix_compile (stix_t* stix, stix_ioimpl_t io)
if (compile_stream (stix) <= -1) goto oops;
/* close the stream */
STIX_ASSERT (stix->c->curinp == &stix->c->arg);
STIX_ASSERT (stix, stix->c->curinp == &stix->c->arg);
stix->c->impl (stix, STIX_IO_CLOSE, stix->c->curinp);
return 0;
@ -5566,7 +5566,7 @@ oops:
stix->c->impl (stix, STIX_IO_CLOSE, stix->c->curinp);
prev = stix->c->curinp->includer;
STIX_ASSERT (stix->c->curinp->name != STIX_NULL);
STIX_ASSERT (stix, stix->c->curinp->name != STIX_NULL);
STIX_MMGR_FREE (stix->mmgr, stix->c->curinp);
stix->c->curinp = prev;
}
@ -5577,6 +5577,6 @@ oops:
void stix_getsynerr (stix_t* stix, stix_synerr_t* synerr)
{
STIX_ASSERT (stix->c != STIX_NULL);
STIX_ASSERT (stix, stix->c != STIX_NULL);
if (synerr) *synerr = stix->c->synerr;
}

4
stix/lib/decode.c
View File

@ -481,8 +481,8 @@ return -1;
LOG_INST_2 (stix, "make_block %zu %zu", b1, b2);
STIX_ASSERT (b1 >= 0);
STIX_ASSERT (b2 >= b1);
STIX_ASSERT (stix, b1 >= 0);
STIX_ASSERT (stix, b2 >= b1);
break;
case BCODE_SEND_BLOCK_COPY:

42
stix/lib/dic.c
View File

@ -71,10 +71,10 @@ static stix_oop_oop_t expand_bucket (stix_t* stix, stix_oop_oop_t oldbuc)
ass = (stix_oop_association_t)oldbuc->slot[--oldsz];
if ((stix_oop_t)ass != stix->_nil)
{
STIX_ASSERT (STIX_CLASSOF(stix,ass) == stix->_association);
STIX_ASSERT (stix, STIX_CLASSOF(stix,ass) == stix->_association);
key = (stix_oop_char_t)ass->key;
STIX_ASSERT (STIX_CLASSOF(stix,key) == (stix_oop_t)stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,key) == (stix_oop_t)stix->_symbol);
index = stix_hashchars(key->slot, STIX_OBJ_GET_SIZE(key)) % newsz;
while (newbuc->slot[index] != stix->_nil) index = (index + 1) % newsz;
@ -94,9 +94,9 @@ static stix_oop_association_t find_or_upsert (stix_t* stix, stix_oop_set_t dic,
/* the system dictionary is not a generic dictionary.
* it accepts only a symbol as a key. */
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
STIX_ASSERT (STIX_CLASSOF(stix,dic->tally) == stix->_small_integer);
STIX_ASSERT (STIX_CLASSOF(stix,dic->bucket) == stix->_array);
STIX_ASSERT (stix, STIX_CLASSOF(stix,key) == stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,dic->tally) == stix->_small_integer);
STIX_ASSERT (stix, STIX_CLASSOF(stix,dic->bucket) == stix->_array);
index = stix_hashchars(key->slot, STIX_OBJ_GET_SIZE(key)) % STIX_OBJ_GET_SIZE(dic->bucket);
@ -105,8 +105,8 @@ static stix_oop_association_t find_or_upsert (stix_t* stix, stix_oop_set_t dic,
{
ass = (stix_oop_association_t)dic->bucket->slot[index];
STIX_ASSERT (STIX_CLASSOF(stix,ass) == stix->_association);
STIX_ASSERT (STIX_CLASSOF(stix,ass->key) == stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,ass) == stix->_association);
STIX_ASSERT (stix, STIX_CLASSOF(stix,ass->key) == stix->_symbol);
if (STIX_OBJ_GET_SIZE(key) == STIX_OBJ_GET_SIZE(ass->key) &&
stix_equaloochars (key->slot, ((stix_oop_char_t)ass->key)->slot, STIX_OBJ_GET_SIZE(key)))
@ -128,7 +128,7 @@ static stix_oop_association_t find_or_upsert (stix_t* stix, stix_oop_set_t dic,
}
/* the key is not found. insert it. */
STIX_ASSERT (STIX_OOP_IS_SMOOI(dic->tally));
STIX_ASSERT (stix, STIX_OOP_IS_SMOOI(dic->tally));
tally = STIX_OOP_TO_SMOOI(dic->tally);
if (tally >= STIX_SMOOI_MAX)
{
@ -180,7 +180,7 @@ static stix_oop_association_t find_or_upsert (stix_t* stix, stix_oop_set_t dic,
/* the current tally must be less than the maximum value. otherwise,
* it overflows after increment below */
STIX_ASSERT (tally < STIX_SMOOI_MAX);
STIX_ASSERT (stix, tally < STIX_SMOOI_MAX);
dic->tally = STIX_SMOOI_TO_OOP(tally + 1);
dic->bucket->slot[index] = (stix_oop_t)ass;
@ -200,8 +200,8 @@ static stix_oop_association_t lookup (stix_t* stix, stix_oop_set_t dic, const st
stix_oow_t index;
stix_oop_association_t ass;
STIX_ASSERT (STIX_CLASSOF(stix,dic->tally) == stix->_small_integer);
STIX_ASSERT (STIX_CLASSOF(stix,dic->bucket) == stix->_array);
STIX_ASSERT (stix, STIX_CLASSOF(stix,dic->tally) == stix->_small_integer);
STIX_ASSERT (stix, STIX_CLASSOF(stix,dic->bucket) == stix->_array);
index = stix_hashchars(name->ptr, name->len) % STIX_OBJ_GET_SIZE(dic->bucket);
@ -209,8 +209,8 @@ static stix_oop_association_t lookup (stix_t* stix, stix_oop_set_t dic, const st
{
ass = (stix_oop_association_t)dic->bucket->slot[index];
STIX_ASSERT (STIX_CLASSOF(stix,ass) == stix->_association);
STIX_ASSERT (STIX_CLASSOF(stix,ass->key) == stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,ass) == stix->_association);
STIX_ASSERT (stix, STIX_CLASSOF(stix,ass->key) == stix->_symbol);
if (name->len == STIX_OBJ_GET_SIZE(ass->key) &&
stix_equaloochars(name->ptr, ((stix_oop_char_t)ass->key)->slot, name->len))
@ -228,13 +228,13 @@ static stix_oop_association_t lookup (stix_t* stix, stix_oop_set_t dic, const st
stix_oop_association_t stix_putatsysdic (stix_t* stix, stix_oop_t key, stix_oop_t value)
{
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,key) == stix->_symbol);
return find_or_upsert (stix, stix->sysdic, (stix_oop_char_t)key, value);
}
stix_oop_association_t stix_getatsysdic (stix_t* stix, stix_oop_t key)
{
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,key) == stix->_symbol);
return find_or_upsert (stix, stix->sysdic, (stix_oop_char_t)key, STIX_NULL);
}
@ -245,13 +245,13 @@ stix_oop_association_t stix_lookupsysdic (stix_t* stix, const stix_oocs_t* name)
stix_oop_association_t stix_putatdic (stix_t* stix, stix_oop_set_t dic, stix_oop_t key, stix_oop_t value)
{
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,key) == stix->_symbol);
return find_or_upsert (stix, dic, (stix_oop_char_t)key, value);
}
stix_oop_association_t stix_getatdic (stix_t* stix, stix_oop_set_t dic, stix_oop_t key)
{
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,key) == stix->_symbol);
return find_or_upsert (stix, dic, (stix_oop_char_t)key, STIX_NULL);
}
@ -265,12 +265,12 @@ stix_oop_set_t stix_makedic (stix_t* stix, stix_oop_t cls, stix_oow_t size)
stix_oop_set_t dic;
stix_oop_t tmp;
STIX_ASSERT (STIX_CLASSOF(stix,cls) == stix->_class);
STIX_ASSERT (stix, STIX_CLASSOF(stix,cls) == stix->_class);
dic = (stix_oop_set_t)stix_instantiate (stix, cls, STIX_NULL, 0);
if (!dic) return STIX_NULL;
STIX_ASSERT (STIX_OBJ_GET_SIZE(dic) == STIX_SET_NAMED_INSTVARS);
STIX_ASSERT (stix, STIX_OBJ_GET_SIZE(dic) == STIX_SET_NAMED_INSTVARS);
stix_pushtmp (stix, (stix_oop_t*)&dic);
tmp = stix_instantiate (stix, stix->_array, STIX_NULL, size);
@ -280,8 +280,8 @@ stix_oop_set_t stix_makedic (stix_t* stix, stix_oop_t cls, stix_oow_t size)
dic->tally = STIX_SMOOI_TO_OOP(0);
dic->bucket = (stix_oop_oop_t)tmp;
STIX_ASSERT (STIX_OBJ_GET_SIZE(dic) == STIX_SET_NAMED_INSTVARS);
STIX_ASSERT (STIX_OBJ_GET_SIZE(dic->bucket) == size);
STIX_ASSERT (stix, STIX_OBJ_GET_SIZE(dic) == STIX_SET_NAMED_INSTVARS);
STIX_ASSERT (stix, STIX_OBJ_GET_SIZE(dic->bucket) == size);
return dic;
}

370
stix/lib/exec.c
View File

File diff suppressed because it is too large Load Diff

372
stix/lib/gc.c
View File

@ -26,6 +26,305 @@
#include "stix-prv.h"
/*
* Stix .....................
* ^ ^ ^ : .......
* | | | v v :
* | | +------------------- Class .....
* | | ^ ^
* | +-------- NilObject ......: :
* | ^........ nil :
* Object ...........................:
* ^
* |
*
* The class hierarchy is roughly as follows:
*
* Stix
* Class
* NilObject
* Object
* Collection
* IndexedCollection
* FixedSizedCollection
* Array
* ByteArray
* String
* Symbol
* Set
* Dictionary
* SystemDictionary
* SymbolSet
* Magnitude
* Association
* Character
* Number
* Integer
* SmallInteger
* LargeInteger
* LargePositiveInteger
* LargeNegativeInteger
*
* Stix has no instance variables.
* Stix has 1 class variable: Sysdic
*
*/
struct kernel_class_info_t
{
stix_oow_t len;
stix_ooch_t name[20];
stix_oow_t offset;
};
typedef struct kernel_class_info_t kernel_class_info_t;
static kernel_class_info_t kernel_classes[] =
{
{ 4, { 'A','p','e','x' }, STIX_OFFSETOF(stix_t,_apex) },
{ 15, { 'U','n','d','e','f','i','n','e','d','O','b','j','e','c','t' }, STIX_OFFSETOF(stix_t,_undefined_object) },
{ 5, { 'C','l','a','s','s' }, STIX_OFFSETOF(stix_t,_class) },
{ 6, { 'O','b','j','e','c','t' }, STIX_OFFSETOF(stix_t,_object) },
{ 6, { 'S','t','r','i','n','g' }, STIX_OFFSETOF(stix_t,_string) },
{ 6, { 'S','y','m','b','o','l' }, STIX_OFFSETOF(stix_t,_symbol) },
{ 5, { 'A','r','r','a','y' }, STIX_OFFSETOF(stix_t,_array) },
{ 9, { 'B','y','t','e','A','r','r','a','y' }, STIX_OFFSETOF(stix_t,_byte_array) },
{ 9, { 'S','y','m','b','o','l','S','e','t' }, STIX_OFFSETOF(stix_t,_symbol_set) },
{ 16, { 'S','y','s','t','e','m','D','i','c','t','i','o','n','a','r','y' }, STIX_OFFSETOF(stix_t, _system_dictionary) },
{ 9, { 'N','a','m','e','s','p','a','c','e' }, STIX_OFFSETOF(stix_t, _namespace) },
{ 14, { 'P','o','o','l','D','i','c','t','i','o','n','a','r','y' }, STIX_OFFSETOF(stix_t, _pool_dictionary) },
{ 16, { 'M','e','t','h','o','d','D','i','c','t','i','o','n','a','r','y' }, STIX_OFFSETOF(stix_t, _method_dictionary) },
{ 14, { 'C','o','m','p','i','l','e','d','M','e','t','h','o','d' }, STIX_OFFSETOF(stix_t, _method) },
{ 11, { 'A','s','s','o','c','i','a','t','i','o','n' }, STIX_OFFSETOF(stix_t, _association) },
{ 13, { 'M','e','t','h','o','d','C','o','n','t','e','x','t' }, STIX_OFFSETOF(stix_t, _method_context) },
{ 12, { 'B','l','o','c','k','C','o','n','t','e','x','t' }, STIX_OFFSETOF(stix_t, _block_context) },
{ 7, { 'P','r','o','c','e','s','s' }, STIX_OFFSETOF(stix_t, _process) },
{ 9, { 'S','e','m','a','p','h','o','r','e' }, STIX_OFFSETOF(stix_t, _semaphore) },
{ 16, { 'P','r','o','c','e','s','s','S','c','h','e','d','u','l','e','r' }, STIX_OFFSETOF(stix_t, _process_scheduler) },
{ 5, { 'E','r','r','o','r' }, STIX_OFFSETOF(stix_t, _error_class) },
{ 4, { 'T','r','u','e' }, STIX_OFFSETOF(stix_t, _true_class) },
{ 5, { 'F','a','l','s','e' }, STIX_OFFSETOF(stix_t, _false_class) },
{ 9, { 'C','h','a','r','a','c','t','e','r' }, STIX_OFFSETOF(stix_t, _character) },
{ 12, { 'S','m','a','l','l','I','n','t','e','g','e','r' }, STIX_OFFSETOF(stix_t, _small_integer) },
{ 20, { 'L','a','r','g','e','P','o','s','i','t','i','v','e','I','n','t','e','g','e','r' }, STIX_OFFSETOF(stix_t, _large_positive_integer) },
{ 20, { 'L','a','r','g','e','N','e','g','a','t','i','v','e','I','n','t','e','g','e','r' }, STIX_OFFSETOF(stix_t, _large_negative_integer) }
};
/* -----------------------------------------------------------------------
* BOOTSTRAPPER
* ----------------------------------------------------------------------- */
static stix_oop_t alloc_kernel_class (stix_t* stix, stix_oow_t indexed_classvars, stix_oow_t spec)
{
stix_oop_class_t c;
c = (stix_oop_class_t)stix_allocoopobj (stix, STIX_CLASS_NAMED_INSTVARS + indexed_classvars);
if (!c) return STIX_NULL;
STIX_OBJ_SET_FLAGS_KERNEL (c, 1);
STIX_OBJ_SET_CLASS (c, stix->_class);
c->spec = STIX_SMOOI_TO_OOP(spec);
c->selfspec = STIX_SMOOI_TO_OOP(STIX_CLASS_SELFSPEC_MAKE(indexed_classvars, 0));
return (stix_oop_t)c;
}
static int ignite_1 (stix_t* stix)
{
/*
* Create fundamental class objects with some fields mis-initialized yet.
* Such fields include 'superclass', 'subclasses', 'name', etc.
*/
STIX_ASSERT (stix, stix->_nil != STIX_NULL);
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(stix->_nil) == STIX_NULL);
STIX_ASSERT (stix, stix->_class == STIX_NULL);
/* --------------------------------------------------------------
* Class
* The instance of Class can have indexed instance variables
* which are actually class variables.
* -------------------------------------------------------------- */
stix->_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CLASS_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
if (!stix->_class) return -1;
STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(stix->_class) == STIX_NULL);
STIX_OBJ_SET_CLASS (stix->_class, stix->_class);
/* --------------------------------------------------------------
* Apex - proto-object with 1 class variable.
* UndefinedObject - class for the nil object.
* Object - top of all ordinary objects.
* String
* Symbol
* Array
* ByteArray
* SymbolSet
* Character
* SmallIntger
* -------------------------------------------------------------- */
stix->_apex = alloc_kernel_class (stix, 1, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_undefined_object = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_object = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_string = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_CHAR));
stix->_symbol = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_CHAR));
stix->_array = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_OOP));
stix->_byte_array = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_BYTE));
stix->_symbol_set = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_system_dictionary = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_namespace = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_pool_dictionary = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_method_dictionary = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_method = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_METHOD_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
stix->_association = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_ASSOCIATION_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_method_context = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CONTEXT_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
stix->_block_context = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CONTEXT_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
stix->_process = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_PROCESS_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
stix->_semaphore = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SEMAPHORE_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_process_scheduler = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_PROCESS_SCHEDULER_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_error_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_true_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_false_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
/* TOOD: what is a proper spec for Character and SmallInteger?
* If the fixed part is 0, its instance must be an object of 0 payload fields.
* Does this make sense? */
stix->_character = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_small_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_large_positive_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_LIWORD));
stix->_large_negative_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_LIWORD));
if (!stix->_apex || !stix->_undefined_object ||
!stix->_object || !stix->_string ||
!stix->_symbol || !stix->_array ||
!stix->_byte_array || !stix->_symbol_set || !stix->_system_dictionary ||
!stix->_namespace || !stix->_pool_dictionary ||
!stix->_method_dictionary || !stix->_method || !stix->_association ||
!stix->_method_context || !stix->_block_context ||
!stix->_process || !stix->_semaphore || !stix->_process_scheduler ||
!stix->_true_class || !stix->_false_class ||
!stix->_character || !stix->_small_integer ||
!stix->_large_positive_integer || !stix->_large_negative_integer) return -1;
STIX_OBJ_SET_CLASS (stix->_nil, stix->_undefined_object);
return 0;
}
static int ignite_2 (stix_t* stix)
{
stix_oop_t tmp;
/* Create 'true' and 'false objects */
stix->_true = stix_instantiate (stix, stix->_true_class, STIX_NULL, 0);
stix->_false = stix_instantiate (stix, stix->_false_class, STIX_NULL, 0);
if (!stix->_true || !stix->_false) return -1;
/* Create the symbol table */
tmp = stix_instantiate (stix, stix->_symbol_set, STIX_NULL, 0);
if (!tmp) return -1;
stix->symtab = (stix_oop_set_t)tmp;
stix->symtab->tally = STIX_SMOOI_TO_OOP(0);
/* It's important to assign the result of stix_instantiate() to a temporary
* variable first and then assign it to stix->symtab->bucket.
* The pointer 'stix->symtab; can change in stix_instantiate() and the
* target address of assignment may get set before stix_instantiate()
* is called. */
tmp = stix_instantiate (stix, stix->_array, STIX_NULL, stix->option.dfl_symtab_size);
if (!tmp) return -1;
stix->symtab->bucket = (stix_oop_oop_t)tmp;
/* Create the system dictionary */
tmp = (stix_oop_t)stix_makedic (stix, stix->_system_dictionary, stix->option.dfl_sysdic_size);
if (!tmp) return -1;
stix->sysdic = (stix_oop_set_t)tmp;
/* Create a nil process used to simplify nil check in GC.
* only accessible by VM. not exported via the global dictionary. */
tmp = (stix_oop_t)stix_instantiate (stix, stix->_process, STIX_NULL, 0);
if (!tmp) return -1;
stix->nil_process = (stix_oop_process_t)tmp;
stix->nil_process->sp = STIX_SMOOI_TO_OOP(-1);
/* Create a process scheduler */
tmp = (stix_oop_t)stix_instantiate (stix, stix->_process_scheduler, STIX_NULL, 0);
if (!tmp) return -1;
stix->processor = (stix_oop_process_scheduler_t)tmp;
stix->processor->tally = STIX_SMOOI_TO_OOP(0);
stix->processor->active = stix->nil_process;
/* Export the system dictionary via the first class variable of the Stix class */
((stix_oop_class_t)stix->_apex)->slot[0] = (stix_oop_t)stix->sysdic;
return 0;
}
static int ignite_3 (stix_t* stix)
{
/* Register kernel classes manually created so far to the system dictionary */
static stix_ooch_t str_system[] = { 'S','y','s','t','e', 'm' };
static stix_ooch_t str_processor[] = { 'P', 'r', 'o', 'c', 'e', 's', 's', 'o', 'r' };
stix_oow_t i;
stix_oop_t sym, cls;
stix_oop_t* stix_ptr;
for (i = 0; i < STIX_COUNTOF(kernel_classes); i++)
{
sym = stix_makesymbol (stix, kernel_classes[i].name, kernel_classes[i].len);
if (!sym) return -1;
cls = *(stix_oop_t*)((stix_uint8_t*)stix + kernel_classes[i].offset);
if (!stix_putatsysdic(stix, sym, cls)) return -1;
stix_ptr++;
}
/* Make the system dictionary available as the global name 'Stix' */
sym = stix_makesymbol (stix, str_system, 6);
if (!sym) return -1;
if (!stix_putatsysdic(stix, sym, (stix_oop_t)stix->sysdic)) return -1;
/* Make the process scheduler avaialble as the global name 'Processor' */
sym = stix_makesymbol (stix, str_processor, 9);
if (!sym) return -1;
if (!stix_putatsysdic(stix, sym, (stix_oop_t)stix->processor)) return -1;
return 0;
}
int stix_ignite (stix_t* stix)
{
STIX_ASSERT (stix, stix->_nil == STIX_NULL);
stix->_nil = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t));
if (!stix->_nil) return -1;
stix->_nil->_flags = STIX_OBJ_MAKE_FLAGS (STIX_OBJ_TYPE_OOP, STIX_SIZEOF(stix_oop_t), 0, 1, 0, 0, 0);
stix->_nil->_size = 0;
if (ignite_1(stix) <= -1 || ignite_2(stix) <= -1 || ignite_3(stix)) return -1;
return 0;
}
/* -----------------------------------------------------------------------
* GARBAGE COLLECTOR
* ----------------------------------------------------------------------- */
static void compact_symbol_table (stix_t* stix, stix_oop_t _nil)
{
stix_oop_char_t symbol;
@ -39,9 +338,9 @@ static void compact_symbol_table (stix_t* stix, stix_oop_t _nil)
/* the symbol table doesn't allow more data items than STIX_SMOOI_MAX.
* so stix->symtab->tally must always be a small integer */
STIX_ASSERT (STIX_OOP_IS_SMOOI(stix->symtab->tally));
STIX_ASSERT (stix, STIX_OOP_IS_SMOOI(stix->symtab->tally));
tally = STIX_OOP_TO_SMOOI(stix->symtab->tally);
STIX_ASSERT (tally >= 0); /* it must not be less than 0 */
STIX_ASSERT (stix, tally >= 0); /* it must not be less than 0 */
if (tally <= 0) return;
/* NOTE: in theory, the bucket size can be greater than STIX_SMOOI_MAX
@ -56,7 +355,7 @@ static void compact_symbol_table (stix_t* stix, stix_oop_t _nil)
continue;
}
STIX_ASSERT (stix->symtab->bucket->slot[index] != _nil);
STIX_ASSERT (stix, stix->symtab->bucket->slot[index] != _nil);
for (i = 0, x = index, y = index; i < bucket_size; i++)
{
@ -69,7 +368,7 @@ static void compact_symbol_table (stix_t* stix, stix_oop_t _nil)
* at the current hash index */
symbol = (stix_oop_char_t)stix->symtab->bucket->slot[y];
STIX_ASSERT (STIX_CLASSOF(stix,symbol) == stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,symbol) == stix->_symbol);
z = stix_hashchars(symbol->slot, STIX_OBJ_GET_SIZE(symbol)) % bucket_size;
@ -86,8 +385,8 @@ static void compact_symbol_table (stix_t* stix, stix_oop_t _nil)
tally--;
}
STIX_ASSERT (tally >= 0);
STIX_ASSERT (tally <= STIX_SMOOI_MAX);
STIX_ASSERT (stix, tally >= 0);
STIX_ASSERT (stix, tally <= STIX_SMOOI_MAX);
stix->symtab->tally = STIX_SMOOI_TO_OOP(tally);
}
@ -113,9 +412,9 @@ static STIX_INLINE stix_oow_t get_payload_bytes (stix_t* stix, stix_oop_t oop)
* | Z | <-- if TRAILER is set, it is the number of bytes in the trailer
* | | | | |
*/
STIX_ASSERT (STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_OOP);
STIX_ASSERT (STIX_OBJ_GET_FLAGS_UNIT(oop) == STIX_SIZEOF(stix_oow_t));
STIX_ASSERT (STIX_OBJ_GET_FLAGS_EXTRA(oop) == 0); /* no 'extra' for an OOP object */
STIX_ASSERT (stix, STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_OOP);
STIX_ASSERT (stix, STIX_OBJ_GET_FLAGS_UNIT(oop) == STIX_SIZEOF(stix_oow_t));
STIX_ASSERT (stix, STIX_OBJ_GET_FLAGS_EXTRA(oop) == 0); /* no 'extra' for an OOP object */
nbytes = STIX_OBJ_BYTESOF(oop) + STIX_SIZEOF(stix_oow_t) + \
(stix_oow_t)((stix_oop_oop_t)oop)->slot[STIX_OBJ_GET_SIZE(oop)];
@ -166,7 +465,7 @@ stix_oop_t stix_moveoop (stix_t* stix, stix_oop_t oop)
* assuming the new heap is as large as the old heap,
* and garbage collection doesn't allocate more objects
* than in the old heap, it must not fail. */
STIX_ASSERT (tmp != STIX_NULL);
STIX_ASSERT (stix, tmp != STIX_NULL);
/* copy the payload to the new object */
STIX_MEMCPY (tmp, oop, STIX_SIZEOF(stix_obj_t) + nbytes_aligned);
@ -199,9 +498,9 @@ static stix_uint8_t* scan_new_heap (stix_t* stix, stix_uint8_t* ptr)
{
stix_oow_t nbytes;
STIX_ASSERT (STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_OOP);
STIX_ASSERT (STIX_OBJ_GET_FLAGS_UNIT(oop) == STIX_SIZEOF(stix_oow_t));
STIX_ASSERT (STIX_OBJ_GET_FLAGS_EXTRA(oop) == 0); /* no 'extra' for an OOP object */
STIX_ASSERT (stix, STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_OOP);
STIX_ASSERT (stix, STIX_OBJ_GET_FLAGS_UNIT(oop) == STIX_SIZEOF(stix_oow_t));
STIX_ASSERT (stix, STIX_OBJ_GET_FLAGS_EXTRA(oop) == 0); /* no 'extra' for an OOP object */
nbytes = STIX_OBJ_BYTESOF(oop) + STIX_SIZEOF(stix_oow_t) + \
(stix_oow_t)((stix_oop_oop_t)oop)->slot[STIX_OBJ_GET_SIZE(oop)];
@ -228,7 +527,7 @@ static stix_uint8_t* scan_new_heap (stix_t* stix, stix_uint8_t* ptr)
* are garbages. */
size = STIX_PROCESS_NAMED_INSTVARS +
STIX_OOP_TO_SMOOI(((stix_oop_process_t)oop)->sp) + 1;
STIX_ASSERT (size <= STIX_OBJ_GET_SIZE(oop));
STIX_ASSERT (stix, size <= STIX_OBJ_GET_SIZE(oop));
}
else
{
@ -268,8 +567,8 @@ void stix_gc (stix_t* stix)
{
/* TODO: verify if this is correct */
STIX_ASSERT ((stix_oop_t)stix->processor != stix->_nil);
STIX_ASSERT ((stix_oop_t)stix->processor->active != stix->_nil);
STIX_ASSERT (stix, (stix_oop_t)stix->processor != stix->_nil);
STIX_ASSERT (stix, (stix_oop_t)stix->processor->active != stix->_nil);
/* store the stack pointer to the active process */
stix->processor->active->sp = STIX_SMOOI_TO_OOP(stix->sp);
@ -290,34 +589,13 @@ void stix_gc (stix_t* stix)
stix->_true = stix_moveoop (stix, stix->_true);
stix->_false = stix_moveoop (stix, stix->_false);
stix->_apex = stix_moveoop (stix, stix->_apex);
stix->_class = stix_moveoop (stix, stix->_class);
stix->_undefined_object = stix_moveoop (stix, stix->_undefined_object);
stix->_object = stix_moveoop (stix, stix->_object);
stix->_array = stix_moveoop (stix, stix->_array);
stix->_byte_array = stix_moveoop (stix, stix->_byte_array);
stix->_string = stix_moveoop (stix, stix->_string);
stix->_symbol = stix_moveoop (stix, stix->_symbol);
stix->_symbol_set = stix_moveoop (stix, stix->_symbol_set);
stix->_system_dictionary = stix_moveoop (stix, stix->_system_dictionary);
stix->_namespace = stix_moveoop (stix, stix->_namespace);
stix->_pool_dictionary = stix_moveoop (stix, stix->_pool_dictionary);
stix->_method_dictionary = stix_moveoop (stix, stix->_method_dictionary);
stix->_method = stix_moveoop (stix, stix->_method);
stix->_association = stix_moveoop (stix, stix->_association);
stix->_method_context = stix_moveoop (stix, stix->_method_context);
stix->_block_context = stix_moveoop (stix, stix->_block_context);
stix->_semaphore = stix_moveoop (stix, stix->_semaphore);
stix->_process = stix_moveoop (stix, stix->_process);
stix->_process_scheduler = stix_moveoop (stix, stix->_process_scheduler);
stix->_true_class = stix_moveoop (stix, stix->_true_class);
stix->_false_class = stix_moveoop (stix, stix->_false_class);
stix->_character = stix_moveoop (stix, stix->_character);
stix->_small_integer = stix_moveoop (stix, stix->_small_integer);
stix->_large_positive_integer = stix_moveoop (stix, stix->_large_positive_integer);
stix->_large_negative_integer = stix_moveoop (stix, stix->_large_negative_integer);
for (i = 0; i < STIX_COUNTOF(kernel_classes); i++)
{
stix_oop_t tmp;
tmp = *(stix_oop_t*)((stix_uint8_t*)stix + kernel_classes[i].offset);
tmp = stix_moveoop (stix, tmp);
*(stix_oop_t*)((stix_uint8_t*)stix + kernel_classes[i].offset) = tmp;
}
stix->sysdic = (stix_oop_set_t) stix_moveoop (stix, (stix_oop_t)stix->sysdic);
stix->processor = (stix_oop_process_scheduler_t) stix_moveoop (stix, (stix_oop_t)stix->processor);
@ -409,19 +687,19 @@ void stix_pushtmp (stix_t* stix, stix_oop_t* oop_ptr)
{
/* if you have too many temporaries pushed, something must be wrong.
* change your code not to exceede the stack limit */
STIX_ASSERT (stix->tmp_count < STIX_COUNTOF(stix->tmp_stack));
STIX_ASSERT (stix, stix->tmp_count < STIX_COUNTOF(stix->tmp_stack));
stix->tmp_stack[stix->tmp_count++] = oop_ptr;
}
void stix_poptmp (stix_t* stix)
{
STIX_ASSERT (stix->tmp_count > 0);
STIX_ASSERT (stix, stix->tmp_count > 0);
stix->tmp_count--;
}
void stix_poptmps (stix_t* stix, stix_oow_t count)
{
STIX_ASSERT (stix->tmp_count >= count);
STIX_ASSERT (stix, stix->tmp_count >= count);
stix->tmp_count -= count;
}

6
stix/lib/heap.c
View File

@ -44,9 +44,9 @@ stix_heap_t* stix_makeheap (stix_t* stix, stix_oow_t size)
heap->ptr = (stix_uint8_t*)STIX_ALIGN(((stix_uintptr_t)heap->base), STIX_SIZEOF(stix_oop_t));
heap->limit = heap->base + size;
STIX_ASSERT (heap->ptr >= heap->base);
STIX_ASSERT (heap->limit >= heap->base );
STIX_ASSERT (heap->limit - heap->base == size);
STIX_ASSERT (stix, heap->ptr >= heap->base);
STIX_ASSERT (stix, heap->limit >= heap->base );
STIX_ASSERT (stix, heap->limit - heap->base == size);
/* if size is too small, heap->ptr may go past heap->limit even at
* this moment depending on the alignment of heap->base. subsequent

310
stix/lib/ignite.c
View File

@ -1,310 +0,0 @@
/*
* $Id$
*
Copyright (c) 2014-2016 Chung, Hyung-Hwan. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "stix-prv.h"
/*
* Stix .....................
* ^ ^ ^ : .......
* | | | v v :
* | | +------------------- Class .....
* | | ^ ^
* | +-------- NilObject ......: :
* | ^........ nil :
* Object ...........................:
* ^
* |
*
* The class hierarchy is roughly as follows:
*
* Stix
* Class
* NilObject
* Object
* Collection
* IndexedCollection
* FixedSizedCollection
* Array
* ByteArray
* String
* Symbol
* Set
* Dictionary
* SystemDictionary
* SymbolSet
* Magnitude
* Association
* Character
* Number
* Integer
* SmallInteger
* LargeInteger
* LargePositiveInteger
* LargeNegativeInteger
*
* Stix has no instance variables.
* Stix has 1 class variable: Sysdic
*
*/
static stix_oop_t alloc_kernel_class (stix_t* stix, stix_oow_t indexed, stix_oow_t spec)
{
stix_oop_class_t c;
c = (stix_oop_class_t)stix_allocoopobj (stix, STIX_CLASS_NAMED_INSTVARS + indexed);
if (!c) return STIX_NULL;
STIX_OBJ_SET_FLAGS_KERNEL (c, 1);
STIX_OBJ_SET_CLASS (c, stix->_class);
c->spec = STIX_SMOOI_TO_OOP(spec);
c->selfspec = STIX_SMOOI_TO_OOP(STIX_CLASS_SELFSPEC_MAKE(indexed, 0));
return (stix_oop_t)c;
}
static int ignite_1 (stix_t* stix)
{
/*
* Create fundamental class objects with some fields mis-initialized yet.
* Such fields include 'superclass', 'subclasses', 'name', etc.
*/
STIX_ASSERT (stix->_nil != STIX_NULL);
STIX_ASSERT (STIX_OBJ_GET_CLASS(stix->_nil) == STIX_NULL);
STIX_ASSERT (stix->_class == STIX_NULL);
/* --------------------------------------------------------------
* Class
* The instance of Class can have indexed instance variables
* which are actually class variables.
* -------------------------------------------------------------- */
stix->_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CLASS_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
if (!stix->_class) return -1;
STIX_ASSERT (STIX_OBJ_GET_CLASS(stix->_class) == STIX_NULL);
STIX_OBJ_SET_CLASS (stix->_class, stix->_class);
/* --------------------------------------------------------------
* Apex - proto-object with 1 class variable.
* UndefinedObject - class for the nil object.
* Object - top of all ordinary objects.
* String
* Symbol
* Array
* ByteArray
* SymbolSet
* Character
* SmallIntger
* -------------------------------------------------------------- */
stix->_apex = alloc_kernel_class (stix, 1, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_undefined_object = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_object = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_string = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_CHAR));
stix->_symbol = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_CHAR));
stix->_array = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_OOP));
stix->_byte_array = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_BYTE));
stix->_symbol_set = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_system_dictionary = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_namespace = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_pool_dictionary = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_method_dictionary = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_method = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_METHOD_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
stix->_association = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_ASSOCIATION_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_method_context = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CONTEXT_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
stix->_block_context = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CONTEXT_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
stix->_process = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_PROCESS_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP));
stix->_semaphore = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SEMAPHORE_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_process_scheduler = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_PROCESS_SCHEDULER_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP));
stix->_true_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_false_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
/* TOOD: what is a proper spec for Character and SmallInteger?
* If the fixed part is 0, its instance must be an object of 0 payload fields.
* Does this make sense? */
stix->_character = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_small_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_large_positive_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_LIWORD));
stix->_large_negative_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_LIWORD));
stix->_resource = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
if (!stix->_apex || !stix->_undefined_object ||
!stix->_object || !stix->_string ||
!stix->_symbol || !stix->_array ||
!stix->_byte_array || !stix->_symbol_set || !stix->_system_dictionary ||
!stix->_namespace || !stix->_pool_dictionary ||
!stix->_method_dictionary || !stix->_method || !stix->_association ||
!stix->_method_context || !stix->_block_context ||
!stix->_process || !stix->_semaphore || !stix->_process_scheduler ||
!stix->_true_class || !stix->_false_class ||
!stix->_character || !stix->_small_integer ||
!stix->_large_positive_integer || !stix->_large_negative_integer || !stix->_resource) return -1;
STIX_OBJ_SET_CLASS (stix->_nil, stix->_undefined_object);
return 0;
}
static int ignite_2 (stix_t* stix)
{
stix_oop_t tmp;
/* Create 'true' and 'false objects */
stix->_true = stix_instantiate (stix, stix->_true_class, STIX_NULL, 0);
stix->_false = stix_instantiate (stix, stix->_false_class, STIX_NULL, 0);
if (!stix->_true || !stix->_false) return -1;
/* Create the symbol table */
tmp = stix_instantiate (stix, stix->_symbol_set, STIX_NULL, 0);
if (!tmp) return -1;
stix->symtab = (stix_oop_set_t)tmp;
stix->symtab->tally = STIX_SMOOI_TO_OOP(0);
/* It's important to assign the result of stix_instantiate() to a temporary
* variable first and then assign it to stix->symtab->bucket.
* The pointer 'stix->symtab; can change in stix_instantiate() and the
* target address of assignment may get set before stix_instantiate()
* is called. */
tmp = stix_instantiate (stix, stix->_array, STIX_NULL, stix->option.dfl_symtab_size);
if (!tmp) return -1;
stix->symtab->bucket = (stix_oop_oop_t)tmp;
/* Create the system dictionary */
tmp = (stix_oop_t)stix_makedic (stix, stix->_system_dictionary, stix->option.dfl_sysdic_size);
if (!tmp) return -1;
stix->sysdic = (stix_oop_set_t)tmp;
/* Create a nil process used to simplify nil check in GC.
* only accessible by VM. not exported via the global dictionary. */
tmp = (stix_oop_t)stix_instantiate (stix, stix->_process, STIX_NULL, 0);
if (!tmp) return -1;
stix->nil_process = (stix_oop_process_t)tmp;
stix->nil_process->sp = STIX_SMOOI_TO_OOP(-1);
/* Create a process scheduler */
tmp = (stix_oop_t)stix_instantiate (stix, stix->_process_scheduler, STIX_NULL, 0);
if (!tmp) return -1;
stix->processor = (stix_oop_process_scheduler_t)tmp;
stix->processor->tally = STIX_SMOOI_TO_OOP(0);
stix->processor->active = stix->nil_process;
/* Export the system dictionary via the first class variable of the Stix class */
((stix_oop_class_t)stix->_apex)->slot[0] = (stix_oop_t)stix->sysdic;
return 0;
}
static int ignite_3 (stix_t* stix)
{
/* Register kernel classes manually created so far to the system dictionary */
static struct symbol_name_t
{
stix_oow_t len;
stix_ooch_t str[20];
} symnames[] = {
{ 4, { 'A','p','e','x' } },
{ 15, { 'U','n','d','e','f','i','n','e','d','O','b','j','e','c','t' } },
{ 5, { 'C','l','a','s','s' } },
{ 6, { 'O','b','j','e','c','t' } },
{ 6, { 'S','t','r','i','n','g' } },
{ 6, { 'S','y','m','b','o','l' } },
{ 5, { 'A','r','r','a','y' } },
{ 9, { 'B','y','t','e','A','r','r','a','y' } },
{ 9, { 'S','y','m','b','o','l','S','e','t' } },
{ 16, { 'S','y','s','t','e','m','D','i','c','t','i','o','n','a','r','y' } },
{ 9, { 'N','a','m','e','s','p','a','c','e' } },
{ 14, { 'P','o','o','l','D','i','c','t','i','o','n','a','r','y' } },
{ 16, { 'M','e','t','h','o','d','D','i','c','t','i','o','n','a','r','y' } },
{ 14, { 'C','o','m','p','i','l','e','d','M','e','t','h','o','d' } },
{ 11, { 'A','s','s','o','c','i','a','t','i','o','n' } },
{ 13, { 'M','e','t','h','o','d','C','o','n','t','e','x','t' } },
{ 12, { 'B','l','o','c','k','C','o','n','t','e','x','t' } },
{ 7, { 'P','r','o','c','e','s','s' } },
{ 9, { 'S','e','m','a','p','h','o','r','e' } },
{ 16, { 'P','r','o','c','e','s','s','S','c','h','e','d','u','l','e','r' } },
{ 4, { 'T','r','u','e' } },
{ 5, { 'F','a','l','s','e' } },
{ 9, { 'C','h','a','r','a','c','t','e','r' } },
{ 12, { 'S','m','a','l','l','I','n','t','e','g','e','r' } },
{ 20, { 'L','a','r','g','e','P','o','s','i','t','i','v','e','I','n','t','e','g','e','r' } },
{ 20, { 'L','a','r','g','e','N','e','g','a','t','i','v','e','I','n','t','e','g','e','r' } }
};
static stix_ooch_t str_system[] = { 'S','y','s','t','e', 'm' };
static stix_ooch_t str_processor[] = { 'P', 'r', 'o', 'c', 'e', 's', 's', 'o', 'r' };
stix_oow_t i;
stix_oop_t sym;
stix_oop_t* stix_ptr;
stix_ptr = &stix->_apex;
/* [NOTE]
* The loop here repies on the proper order of fields in stix_t.
* Be sure to keep in sync the order of items in symnames and
* the releated fields of stix_t */
for (i = 0; i < STIX_COUNTOF(symnames); i++)
{
sym = stix_makesymbol (stix, symnames[i].str, symnames[i].len);
if (!sym) return -1;
if (!stix_putatsysdic(stix, sym, *stix_ptr)) return -1;
stix_ptr++;
}
/* Make the system dictionary available as the global name 'Stix' */
sym = stix_makesymbol (stix, str_system, 6);
if (!sym) return -1;
if (!stix_putatsysdic(stix, sym, (stix_oop_t)stix->sysdic)) return -1;
/* Make the process scheduler avaialble as the global name 'Processor' */
sym = stix_makesymbol (stix, str_processor, 9);
if (!sym) return -1;
if (!stix_putatsysdic(stix, sym, (stix_oop_t)stix->processor)) return -1;
return 0;
}
int stix_ignite (stix_t* stix)
{
STIX_ASSERT (stix->_nil == STIX_NULL);
stix->_nil = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t));
if (!stix->_nil) return -1;
stix->_nil->_flags = STIX_OBJ_MAKE_FLAGS (STIX_OBJ_TYPE_OOP, STIX_SIZEOF(stix_oop_t), 0, 1, 0, 0, 0);
stix->_nil->_size = 0;
if (ignite_1(stix) <= -1 || ignite_2(stix) <= -1 || ignite_3(stix)) return -1;
return 0;
}

6
stix/lib/logfmt.c
View File

@ -316,16 +316,16 @@ static void print_object (stix_t* stix, stix_oow_t mask, stix_oop_t oop)
{
stix_logbfmt (stix, mask, "$%.1C", STIX_OOP_TO_CHAR(oop));
}
else if (STIX_OOP_IS_RSRC(oop))
else if (STIX_OOP_IS_ERROR(oop))
{
stix_logbfmt (stix, mask, "%zX", stix->rsrc.ptr[STIX_OOP_TO_RSRC(oop)]);
stix_logbfmt (stix, mask, "E%08zd", STIX_OOP_TO_ERROR(oop));
}
else
{
stix_oop_class_t c;
stix_oow_t i;
STIX_ASSERT (STIX_OOP_IS_POINTER(oop));
STIX_ASSERT (stix, STIX_OOP_IS_POINTER(oop));
c = (stix_oop_class_t)STIX_OBJ_GET_CLASS(oop); /*STIX_CLASSOF(stix, oop);*/
if ((stix_oop_t)c == stix->_large_negative_integer)

14
stix/lib/logfmtv.h
View File

@ -112,11 +112,11 @@ int logfmtv (stix_t* stix, const fmtchar_t* fmt, stix_fmtout_t* data, va_list ap
fltfmt = &stix->d->fltfmt;
fltout = &stix->d->fltout;
fltfmt->ptr = fltfmt->sbuf;
fltfmt->capa = STIX_COUNTOF(fltfmt->sbuf) - 1;
fltfmt->ptr = fltfmt->buf;
fltfmt->capa = STIX_COUNTOF(fltfmt->buf) - 1;
fltout->ptr = fltout->sbuf;
fltout->capa = STIX_COUNTOF(fltout->sbuf) - 1;
fltout->ptr = fltout->buf;
fltout->capa = STIX_COUNTOF(fltout->buf) - 1;
#endif
while (1)
@ -444,7 +444,7 @@ reswitch:
stix_oow_t conv_len, src_len, tot_len = 0;
while (n > 0)
{
STIX_ASSERT (bslen > tot_len);
STIX_ASSERT (stix, bslen > tot_len);
src_len = bslen - tot_len;
conv_len = STIX_COUNTOF(conv_buf);
@ -575,7 +575,7 @@ reswitch:
fmtlen = fmt - percent;
if (fmtlen > fltfmt->capa)
{
if (fltfmt->ptr == fltfmt->sbuf)
if (fltfmt->ptr == fltfmt->buf)
{
fltfmt->ptr = STIX_MMGR_ALLOC (STIX_MMGR_GETDFL(), STIX_SIZEOF(*fltfmt->ptr) * (fmtlen + 1));
if (fltfmt->ptr == STIX_NULL) goto oops;
@ -635,7 +635,7 @@ reswitch:
newcapa = precision + width + 32;
if (fltout->capa < newcapa)
{
STIX_ASSERT (fltout->ptr == fltout->sbuf);
STIX_ASSERT (stix, fltout->ptr == fltout->buf);
fltout->ptr = STIX_MMGR_ALLOC (STIX_MMGR_GETDFL(), STIX_SIZEOF(char_t) * (newcapa + 1));
if (fltout->ptr == STIX_NULL) goto oops;

6
stix/lib/main.c
View File

@ -192,7 +192,7 @@ static STIX_INLINE stix_ooi_t close_input (stix_t* stix, stix_ioarg_t* arg)
bb_t* bb;
bb = (bb_t*)arg->handle;
STIX_ASSERT (bb != STIX_NULL && bb->fp != STIX_NULL);
STIX_ASSERT (stix, bb != STIX_NULL && bb->fp != STIX_NULL);
fclose (bb->fp);
stix_freemem (stix, bb);
@ -211,7 +211,7 @@ static STIX_INLINE stix_ooi_t read_input (stix_t* stix, stix_ioarg_t* arg)
bb = (bb_t*)arg->handle;
STIX_ASSERT (bb != STIX_NULL && bb->fp != STIX_NULL);
STIX_ASSERT (stix, bb != STIX_NULL && bb->fp != STIX_NULL);
do
{
x = fgetc (bb->fp);
@ -445,7 +445,7 @@ if (mask & STIX_LOG_GC) return; /* don't show gc logs */
* buffer not sufficient. not all got converted yet.
* write what have been converted this round. */
STIX_ASSERT (ucslen > 0); /* if this fails, the buffer size must be increased */
STIX_ASSERT (stix, ucslen > 0); /* if this fails, the buffer size must be increased */
/* attempt to write all converted characters */
if (write_all (1, buf, bcslen) <= -1) break;

18
stix/lib/obj.c
View File

@ -175,10 +175,10 @@ static STIX_INLINE int decode_spec (stix_t* stix, stix_oop_t _class, stix_oow_t
stix_oow_t named_instvar;
stix_obj_type_t indexed_type;
STIX_ASSERT (STIX_OOP_IS_POINTER(_class));
STIX_ASSERT (STIX_CLASSOF(stix, _class) == stix->_class);
STIX_ASSERT (stix, STIX_OOP_IS_POINTER(_class));
STIX_ASSERT (stix, STIX_CLASSOF(stix, _class) == stix->_class);
STIX_ASSERT (STIX_OOP_IS_SMOOI(((stix_oop_class_t)_class)->spec));
STIX_ASSERT (stix, STIX_OOP_IS_SMOOI(((stix_oop_class_t)_class)->spec));
spec = STIX_OOP_TO_SMOOI(((stix_oop_class_t)_class)->spec);
named_instvar = STIX_CLASS_SPEC_NAMED_INSTVAR(spec); /* size of the named_instvar part */
@ -200,7 +200,7 @@ static STIX_INLINE int decode_spec (stix_t* stix, stix_oop_t _class, stix_oow_t
return -1;
}
STIX_ASSERT (named_instvar + vlen <= STIX_OBJ_SIZE_MAX);
STIX_ASSERT (stix, named_instvar + vlen <= STIX_OBJ_SIZE_MAX);
}
else
{
@ -235,7 +235,7 @@ static STIX_INLINE int decode_spec (stix_t* stix, stix_oop_t _class, stix_oow_t
STIX_DEBUG3 (stix, "Too many named instance variables for a fixed class %O - %zu/%zu\n", _class, named_instvar, (stix_oow_t)STIX_MAX_NAMED_INSTVARS);
return -1;
}
STIX_ASSERT (named_instvar <= STIX_OBJ_SIZE_MAX);
STIX_ASSERT (stix, named_instvar <= STIX_OBJ_SIZE_MAX);
}
*type = indexed_type;
@ -250,7 +250,7 @@ stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr,
stix_oow_t alloclen;
stix_oow_t tmp_count = 0;
STIX_ASSERT (stix->_nil != STIX_NULL);
STIX_ASSERT (stix, stix->_nil != STIX_NULL);
if (decode_spec (stix, _class, vlen, &type, &alloclen) <= -1)
{
@ -267,7 +267,7 @@ stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr,
* the variable part(indexed instance variables) are allowed. */
oop = stix_allocoopobj (stix, alloclen);
STIX_ASSERT (vptr == STIX_NULL);
STIX_ASSERT (stix, vptr == STIX_NULL);
/*
This function is not GC-safe. so i don't want to initialize
the payload of a pointer object. The caller can call this
@ -319,7 +319,7 @@ stix_oop_t stix_instantiate2 (stix_t* stix, stix_oop_t _class, const void* vptr,
stix_oow_t alloclen;
stix_oow_t tmp_count = 0;
STIX_ASSERT (stix->_nil != STIX_NULL);
STIX_ASSERT (stix, stix->_nil != STIX_NULL);
if (decode_spec (stix, _class, vlen, &type, &alloclen) <= -1)
{
@ -374,7 +374,7 @@ stix_oop_t stix_instantiatewithtrailer (stix_t* stix, stix_oop_t _class, stix_oo
stix_oow_t alloclen;
stix_oow_t tmp_count = 0;
STIX_ASSERT (stix->_nil != STIX_NULL);
STIX_ASSERT (stix, stix->_nil != STIX_NULL);
if (decode_spec (stix, _class, vlen, &type, &alloclen) <= -1)
{

4
stix/lib/proc.c
View File

@ -27,8 +27,6 @@
#include "stix-prv.h"
stix_oop_process_t stix_addnewproc (stix_t* stix)
{
stix_oop_process_t proc;
@ -38,7 +36,7 @@ stix_oop_process_t stix_addnewproc (stix_t* stix)
proc->state = STIX_SMOOI_TO_OOP(0);
STIX_ASSERT (STIX_OBJ_GET_SIZE(proc) == STIX_PROCESS_NAMED_INSTVARS + stix->option.dfl_procstk_size);
STIX_ASSERT (stix, STIX_OBJ_GET_SIZE(proc) == STIX_PROCESS_NAMED_INSTVARS + stix->option.dfl_procstk_size);
return proc;
}

59
stix/lib/rbt.c
View File

@ -67,7 +67,7 @@ STIX_INLINE stix_rbt_pair_t* stix_rbt_allocpair (
if (kcop == STIX_RBT_COPIER_INLINE) as += KTOB(rbt,klen);
if (vcop == STIX_RBT_COPIER_INLINE) as += VTOB(rbt,vlen);
n = (stix_rbt_pair_t*) STIX_MMGR_ALLOC (rbt->mmgr, as);
n = (stix_rbt_pair_t*) STIX_MMGR_ALLOC (rbt->stix->mmgr, as);
if (n == STIX_NULL) return STIX_NULL;
n->color = STIX_RBT_RED;
@ -90,7 +90,7 @@ STIX_INLINE stix_rbt_pair_t* stix_rbt_allocpair (
KPTR(n) = kcop (rbt, kptr, klen);
if (KPTR(n) == STIX_NULL)
{
STIX_MMGR_FREE (rbt->mmgr, n);
STIX_MMGR_FREE (rbt->stix->mmgr, n);
return STIX_NULL;
}
}
@ -114,7 +114,7 @@ STIX_INLINE stix_rbt_pair_t* stix_rbt_allocpair (
{
if (rbt->style->freeer[STIX_RBT_KEY] != STIX_NULL)
rbt->style->freeer[STIX_RBT_KEY] (rbt, KPTR(n), KLEN(n));
STIX_MMGR_FREE (rbt->mmgr, n);
STIX_MMGR_FREE (rbt->stix->mmgr, n);
return STIX_NULL;
}
}
@ -128,7 +128,7 @@ STIX_INLINE void stix_rbt_freepair (stix_rbt_t* rbt, stix_rbt_pair_t* pair)
rbt->style->freeer[STIX_RBT_KEY] (rbt, KPTR(pair), KLEN(pair));
if (rbt->style->freeer[STIX_RBT_VAL] != STIX_NULL)
rbt->style->freeer[STIX_RBT_VAL] (rbt, VPTR(pair), VLEN(pair));
STIX_MMGR_FREE (rbt->mmgr, pair);
STIX_MMGR_FREE (rbt->stix->mmgr, pair);
}
static stix_rbt_style_t style[] =
@ -191,16 +191,16 @@ const stix_rbt_style_t* stix_getrbtstyle (stix_rbt_style_kind_t kind)
return &style[kind];
}
stix_rbt_t* stix_rbt_open (stix_mmgr_t* mmgr, stix_oow_t xtnsize, int kscale, int vscale)
stix_rbt_t* stix_rbt_open (stix_t* stix, stix_oow_t xtnsize, int kscale, int vscale)
{
stix_rbt_t* rbt;
rbt = (stix_rbt_t*) STIX_MMGR_ALLOC (mmgr, STIX_SIZEOF(stix_rbt_t) + xtnsize);
rbt = (stix_rbt_t*) STIX_MMGR_ALLOC (stix->mmgr, STIX_SIZEOF(stix_rbt_t) + xtnsize);
if (rbt == STIX_NULL) return STIX_NULL;
if (stix_rbt_init (rbt, mmgr, kscale, vscale) <= -1)
if (stix_rbt_init (rbt, stix, kscale, vscale) <= -1)
{
STIX_MMGR_FREE (mmgr, rbt);
STIX_MMGR_FREE (stix->mmgr, rbt);
return STIX_NULL;
}
@ -211,14 +211,14 @@ stix_rbt_t* stix_rbt_open (stix_mmgr_t* mmgr, stix_oow_t xtnsize, int kscale, in
void stix_rbt_close (stix_rbt_t* rbt)
{
stix_rbt_fini (rbt);
STIX_MMGR_FREE (rbt->mmgr, rbt);
STIX_MMGR_FREE (rbt->stix->mmgr, rbt);
}
int stix_rbt_init (stix_rbt_t* rbt, stix_mmgr_t* mmgr, int kscale, int vscale)
int stix_rbt_init (stix_rbt_t* rbt, stix_t* stix, int kscale, int vscale)
{
/* do not zero out the extension */
STIX_MEMSET (rbt, 0, STIX_SIZEOF(*rbt));
rbt->mmgr = mmgr;
rbt->stix = stix;
rbt->scale[STIX_RBT_KEY] = (kscale < 1)? 1: kscale;
rbt->scale[STIX_RBT_VAL] = (vscale < 1)? 1: vscale;
@ -243,11 +243,6 @@ void stix_rbt_fini (stix_rbt_t* rbt)
stix_rbt_clear (rbt);
}
stix_mmgr_t* stix_rbt_getmmgr (stix_rbt_t* rbt)
{
return rbt->mmgr;
}
void* stix_rbt_getxtn (stix_rbt_t* rbt)
{
return (void*)(rbt + 1);
@ -260,7 +255,7 @@ const stix_rbt_style_t* stix_rbt_getstyle (const stix_rbt_t* rbt)
void stix_rbt_setstyle (stix_rbt_t* rbt, const stix_rbt_style_t* style)
{
STIX_ASSERT (style != STIX_NULL);
STIX_ASSERT (rbt->stix, style != STIX_NULL);
rbt->style = style;
}
@ -324,7 +319,7 @@ static void rotate (stix_rbt_t* rbt, stix_rbt_pair_t* pivot, int leftwise)
stix_rbt_pair_t* parent, * z, * c;
int cid1, cid2;
STIX_ASSERT (pivot != STIX_NULL);
STIX_ASSERT (rbt->stix, pivot != STIX_NULL);
if (leftwise)
{
@ -352,13 +347,13 @@ static void rotate (stix_rbt_t* rbt, stix_rbt_pair_t* pivot, int leftwise)
}
else
{
STIX_ASSERT (parent->right == pivot);
STIX_ASSERT (rbt->stix, parent->right == pivot);
parent->right = z;
}
}
else
{
STIX_ASSERT (rbt->root == pivot);
STIX_ASSERT (rbt->stix, rbt->root == pivot);
rbt->root = z;
}
@ -379,7 +374,7 @@ static void adjust (stix_rbt_t* rbt, stix_rbt_pair_t* pair)
x_par = pair->parent;
if (x_par->color == STIX_RBT_BLACK) break;
STIX_ASSERT (x_par->parent != STIX_NULL);
STIX_ASSERT (rbt->stix, x_par->parent != STIX_NULL);
if (x_par == x_par->parent->child[LEFT])
{
@ -469,7 +464,7 @@ static stix_rbt_pair_t* change_pair_val (
}
else
{
STIX_ASSERT (pair->parent->right == pair);
STIX_ASSERT (rbt->stix, pair->parent->right == pair);
pair->parent->right = p;
}
}
@ -542,7 +537,7 @@ static stix_rbt_pair_t* insert (
if (x_par == STIX_NULL)
{
/* the tree contains no pair */
STIX_ASSERT (rbt->root == &rbt->xnil);
STIX_ASSERT (rbt->stix, rbt->root == &rbt->xnil);
rbt->root = x_new;
}
else
@ -551,12 +546,12 @@ static stix_rbt_pair_t* insert (
int n = rbt->style->comper (rbt, kptr, klen, KPTR(x_par), KLEN(x_par));
if (n > 0)
{
STIX_ASSERT (x_par->right == &rbt->xnil);
STIX_ASSERT (rbt->stix, x_par->right == &rbt->xnil);
x_par->right = x_new;
}
else
{
STIX_ASSERT (x_par->left == &rbt->xnil);
STIX_ASSERT (rbt->stix, x_par->left == &rbt->xnil);
x_par->left = x_new;
}
@ -639,7 +634,7 @@ stix_rbt_pair_t* stix_rbt_cbsert (
}
else
{
STIX_ASSERT (tmp.parent->right == x_cur);
STIX_ASSERT (rbt->stix, tmp.parent->right == x_cur);
tmp.parent->right = x_new;
}
}
@ -664,7 +659,7 @@ stix_rbt_pair_t* stix_rbt_cbsert (
if (x_par == STIX_NULL)
{
/* the tree contains no pair */
STIX_ASSERT (rbt->root == &rbt->xnil);
STIX_ASSERT (rbt->stix, rbt->root == &rbt->xnil);
rbt->root = x_new;
}
else
@ -673,12 +668,12 @@ stix_rbt_pair_t* stix_rbt_cbsert (
int n = rbt->style->comper (rbt, kptr, klen, KPTR(x_par), KLEN(x_par));
if (n > 0)
{
STIX_ASSERT (x_par->right == &rbt->xnil);
STIX_ASSERT (rbt->stix, x_par->right == &rbt->xnil);
x_par->right = x_new;
}
else
{
STIX_ASSERT (x_par->left == &rbt->xnil);
STIX_ASSERT (rbt->stix, x_par->left == &rbt->xnil);
x_par->left = x_new;
}
@ -738,7 +733,7 @@ static void adjust_for_delete (stix_rbt_t* rbt, stix_rbt_pair_t* pair, stix_rbt_
}
else
{
STIX_ASSERT (pair == par->right);
STIX_ASSERT (rbt->stix, pair == par->right);
tmp = par->left;
if (tmp->color == STIX_RBT_RED)
{
@ -783,7 +778,7 @@ static void delete_pair (stix_rbt_t* rbt, stix_rbt_pair_t* pair)
{
stix_rbt_pair_t* x, * y, * par;
STIX_ASSERT (pair && !IS_NIL(rbt,pair));
STIX_ASSERT (rbt->stix, pair && !IS_NIL(rbt,pair));
if (IS_NIL(rbt,pair->left) || IS_NIL(rbt,pair->right))
{
@ -961,7 +956,7 @@ static STIX_INLINE void walk (stix_rbt_t* rbt, walker_t walker, void* ctx, int l
else
{
/* both the left child and the right child have been traversed */
STIX_ASSERT (prev == x_cur->child[r]);
STIX_ASSERT (rbt->stix, prev == x_cur->child[r]);
/* just move up to the parent */
prev = x_cur;
x_cur = x_cur->parent;

5
stix/lib/stix-cmn.h
View File

@ -548,6 +548,11 @@ struct stix_cmgr_t
stix_cmgr_uctobc_t uctobc;
};
/* =========================================================================
* FORWARD DECLARATION FOR MAIN STIX STRUCTURE
* =========================================================================*/
typedef struct stix_t stix_t;
/* =========================================================================
* MACROS THAT CHANGES THE BEHAVIORS OF THE C COMPILER/LINKER
* =========================================================================*/

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

@ -65,7 +65,6 @@
/* TODO: delete these header inclusion lines */
#include <string.h>
#include <assert.h>
#if defined(__has_builtin)
# if __has_builtin(__builtin_memset)
@ -101,8 +100,6 @@
# define STIX_MEMCMP(dst,src,size) memcmp(dst,src,size)
#endif
#define STIX_ASSERT(x) assert(x)
#define STIX_ALIGN(x,y) ((((x) + (y) - 1) / (y)) * (y))
@ -583,10 +580,13 @@ struct stix_compiler_t
} mth;
};
/*
typedef struct stix_bchbuf_t stix_bchbuf_t;
struct stix_bchbuf_t
{
stix_bch_t sbuf[128];
stix_bch_t buf[128];
stix_bch_t* ptr;
stix_oow_t capa;
};
@ -594,10 +594,11 @@ struct stix_bchbuf_t
typedef struct stix_oochbuf_t stix_oochbuf_t;
struct stix_oochbuf_t
{
stix_ooch_t sbuf[128];
stix_ooch_t buf[128];
stix_ooch_t* ptr;
stix_oow_t capa;
};
*/
#endif

10
stix/lib/stix-rbt.h
View File

@ -234,7 +234,7 @@ typedef enum stix_rbt_style_kind_t stix_rbt_style_kind_t;
*/
struct stix_rbt_t
{
stix_mmgr_t* mmgr;
stix_t* stix;
const stix_rbt_style_t* style;
stix_oob_t scale[2]; /**< length scale */
stix_rbt_pair_t xnil; /**< internal nil node */
@ -293,7 +293,7 @@ STIX_EXPORT const stix_rbt_style_t* stix_getrbtstyle (
* @return stix_rbt_t pointer on success, STIX_NULL on failure.
*/
STIX_EXPORT stix_rbt_t* stix_rbt_open (
stix_mmgr_t* mmgr, /**< memory manager */
stix_t* stix,
stix_oow_t xtnsize, /**< extension size in bytes */
int kscale, /**< key scale */
int vscale /**< value scale */
@ -311,7 +311,7 @@ STIX_EXPORT void stix_rbt_close (
*/
STIX_EXPORT int stix_rbt_init (
stix_rbt_t* rbt, /**< red-black tree */
stix_mmgr_t* mmgr, /**< memory manager */
stix_t* stix,
int kscale, /**< key scale */
int vscale /**< value scale */
);
@ -323,10 +323,6 @@ STIX_EXPORT void stix_rbt_fini (
stix_rbt_t* rbt /**< red-black tree */
);
STIX_EXPORT stix_mmgr_t* stix_rbt_getmmgr (
stix_rbt_t* rbt
);
STIX_EXPORT void* stix_rbt_getxtn (
stix_rbt_t* rbt
);

152
stix/lib/stix.c
View File

@ -31,7 +31,7 @@ stix_t* stix_open (stix_mmgr_t* mmgr, stix_oow_t xtnsize, stix_oow_t heapsize, c
stix_t* stix;
/* if this assertion fails, correct the type definition in stix.h */
STIX_ASSERT (STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_oop_t));
STIX_ASSERT (stix, STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_oop_t));
stix = STIX_MMGR_ALLOC (mmgr, STIX_SIZEOF(*stix) + xtnsize);
if (stix)
@ -84,6 +84,8 @@ static void fill_bigint_tables (stix_t* stix)
int stix_init (stix_t* stix, stix_mmgr_t* mmgr, stix_oow_t heapsz, const stix_vmprim_t* vmprim)
{
int modtab_inited = 0;
STIX_MEMSET (stix, 0, STIX_SIZEOF(*stix));
stix->mmgr = mmgr;
stix->cmgr = stix_getutf8cmgr ();
@ -102,18 +104,20 @@ int stix_init (stix_t* stix, stix_mmgr_t* mmgr, stix_oow_t heapsz, const stix_vm
stix->newheap = stix_makeheap (stix, heapsz);
if (!stix->newheap) goto oops;
if (stix_rbt_init (&stix->modtab, mmgr, STIX_SIZEOF(stix_ooch_t), 1) <= -1) goto oops;
if (stix_rbt_init (&stix->modtab, stix, STIX_SIZEOF(stix_ooch_t), 1) <= -1) goto oops;
modtab_inited = 1;
stix_rbt_setstyle (&stix->modtab, stix_getrbtstyle(STIX_RBT_STYLE_INLINE_COPIERS));
fill_bigint_tables (stix);
stix->tagged_classes[STIX_OOP_TAG_SMINT] = &stix->_small_integer;
stix->tagged_classes[STIX_OOP_TAG_CHAR] = &stix->_character;
stix->tagged_classes[STIX_OOP_TAG_RSRC] = &stix->_resource;
stix->tagged_classes[STIX_OOP_TAG_ERROR] = &stix->_error_class;
return 0;
oops:
if (modtab_inited) stix_rbt_fini (&stix->modtab);
if (stix->newheap) stix_killheap (stix, stix->newheap);
if (stix->curheap) stix_killheap (stix, stix->curheap);
if (stix->permheap) stix_killheap (stix, stix->permheap);
@ -126,7 +130,7 @@ static stix_rbt_walk_t unload_module (stix_rbt_t* rbt, stix_rbt_pair_t* pair, vo
stix_mod_data_t* mdp;
mdp = STIX_RBT_VPTR(pair);
STIX_ASSERT (mdp != STIX_NULL);
STIX_ASSERT (stix, mdp != STIX_NULL);
mdp->pair = STIX_NULL; /* to prevent stix_closemod() from calling stix_rbt_delete() */
stix_closemod (stix, mdp);
@ -166,14 +170,6 @@ void stix_fini (stix_t* stix)
stix_killheap (stix, stix->curheap);
stix_killheap (stix, stix->permheap);
if (stix->rsrc.ptr)
{
stix_freemem (stix, stix->rsrc.ptr);
stix->rsrc.free = 0;
stix->rsrc.capa = 0;
stix->rsrc.ptr = STIX_NULL;
}
/* deregister all callbacks */
while (stix->cblist) stix_deregcb (stix, stix->cblist);
@ -374,65 +370,6 @@ void stix_freemem (stix_t* stix, void* ptr)
/* -------------------------------------------------------------------------- */
/* TODO: remove RSRS code. so far, i find this not useful */
stix_oop_t stix_makersrc (stix_t* stix, stix_oow_t v)
{
stix_oop_t imm;
stix_oow_t avail;
if (stix->rsrc.free >= stix->rsrc.capa)
{
stix_oow_t* tmp;
stix_ooi_t newcapa, i;
newcapa = stix->rsrc.capa + 256;
tmp = stix_reallocmem (stix, stix->rsrc.ptr, STIX_SIZEOF(*tmp) * newcapa);
if (!tmp) return STIX_NULL;
for (i = stix->rsrc.capa; i < newcapa; i++) tmp[i] = i + 1;
stix->rsrc.free = i;
stix->rsrc.ptr = tmp;
stix->rsrc.capa = newcapa;
}
avail = stix->rsrc.free;
stix->rsrc.free = stix->rsrc.ptr[stix->rsrc.free];
stix->rsrc.ptr[avail] = v;
/* there must not be too many immedates in the whole system. */
STIX_ASSERT (STIX_IN_SMOOI_RANGE(avail));
return STIX_RSRC_TO_OOP(avail);
return imm;
}
void stix_killrsrc (stix_t* stix, stix_oop_t imm)
{
if (STIX_OOP_IS_RSRC(stix))
{
stix_ooi_t v;
v = STIX_OOP_TO_RSRC(stix);
/* the value of v, if properly created by stix_makeimm(), must
* fall in the following range. when storing and loading the values
* from an image file, you must take extra care not to break this
* assertion */
STIX_ASSERT (v >= 0 && v < stix->rsrc.capa);
stix->rsrc.ptr[v] = stix->rsrc.free;
stix->rsrc.free = v;
}
}
stix_oow_t stix_getrsrcval (stix_t* stix, stix_oop_t imm)
{
STIX_ASSERT (STIX_OOP_IS_RSRC(imm));
return stix->rsrc.ptr[STIX_OOP_TO_RSRC(imm)];
}
/* -------------------------------------------------------------------------- */
#define MOD_PREFIX "stix_mod_"
#define MOD_PREFIX_LEN 9
@ -566,7 +503,7 @@ stix_mod_data_t* stix_openmod (stix_t* stix, const stix_ooch_t* name, stix_oow_t
STIX_DEBUG2 (stix, "Opened a module [%S] - %p\n", mdp->mod.name, mdp->handle);
/* the module loader must ensure to set a proper query handler */
STIX_ASSERT (mdp->mod.query != STIX_NULL);
STIX_ASSERT (stix, mdp->mod.query != STIX_NULL);
return mdp;
}
@ -604,7 +541,7 @@ int stix_importmod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, st
if (pair)
{
mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
STIX_ASSERT (mdp != STIX_NULL);
STIX_ASSERT (stix, mdp != STIX_NULL);
}
else
{
@ -673,7 +610,7 @@ stix_pfimpl_t stix_querymod (stix_t* stix, const stix_ooch_t* pfid, stix_oow_t p
if (pair)
{
mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
STIX_ASSERT (mdp != STIX_NULL);
STIX_ASSERT (stix, mdp != STIX_NULL);
}
else
{
@ -709,13 +646,13 @@ int stix_genpfmethod (stix_t* stix, stix_mod_t* mod, stix_oop_t _class, stix_met
stix_ooi_t preamble_flags = 0;
static stix_ooch_t dot[] = { '.', '\0' };
STIX_ASSERT (STIX_CLASSOF(stix, _class) == stix->_class);
STIX_ASSERT (stix, STIX_CLASSOF(stix, _class) == stix->_class);
if (!pfname) pfname = mthname;
cls = (stix_oop_class_t)_class;
stix_pushtmp (stix, (stix_oop_t*)&cls); tmp_count++;
STIX_ASSERT (STIX_CLASSOF(stix, (stix_oop_t)cls->mthdic[type]) == stix->_method_dictionary);
STIX_ASSERT (stix, STIX_CLASSOF(stix, (stix_oop_t)cls->mthdic[type]) == stix->_method_dictionary);
for (i = 0; mthname[i]; i++)
{
@ -808,3 +745,66 @@ oops:
return -1;
}
/* --------------------------------------------------------------------------
* SYSTEM DEPENDENT FUNCTIONS - TODO: MOVE THESE ELSE WHERE..........
* -------------------------------------------------------------------------- */
#include <errno.h>
#include <unistd.h>
#include <signal.h>
stix_errnum_t stix_syserrtoerrnum (int e)
{
switch (e)
{
case ENOMEM: return STIX_ESYSMEM;
case EINVAL: return STIX_EINVAL;
case EBUSY: return STIX_EBUSY;
case EACCES: return STIX_EACCES;
case EPERM: return STIX_EPERM;
case ENOTDIR: return STIX_ENOTDIR;
case ENOENT: return STIX_ENOENT;
case EEXIST: return STIX_EEXIST;
case EINTR: return STIX_EINTR;
case EPIPE: return STIX_EPIPE;
#if defined(EAGAIN) && defined(EWOULDBLOCK) && (EAGAIN != EWOULDBLOCK)
case EAGAIN:
case EWOULDBLOCK: return STIX_EAGAIN;
#elif defined(EAGAIN)
case EAGAIN: return STIX_EAGAIN;
#elif defined(EWOULDBLOCK)
case EWOULDBLOCK: return STIX_EAGAIN;
#endif
default: return STIX_ESYSERR;
}
}
void stix_assertfailed (stix_t* stix, const stix_bch_t* expr, const stix_bch_t* file, stix_oow_t line)
{
stix_logbfmt (stix, STIX_LOG_DEBUG, "ASSERTION FAILURE: %s at %s:%zu\n", expr, file, line);
#if defined(_WIN32)
ExitProcess (249);
#elif defined(__OS2__)
DosExit (EXIT_PROCESS, 249);
#elif defined(__DOS__)
{
union REGS regs;
regs.h.ah = DOS_EXIT;
regs.h.al = 249;
intdos (&regs, &regs);
}
#elif defined(vms) || defined(__vms)
lib$stop (SS$_ABORT); /* use SS$_OPCCUS instead? */
/* this won't be reached since lib$stop() terminates the process */
sys$exit (SS$_ABORT); /* this condition code can be shown with
* 'show symbol $status' from the command-line. */
#elif defined(macintosh)
ExitToShell ();
#else
kill (getpid(), SIGABRT);
_exit (1);
#endif
}

115
stix/lib/stix.h
View File

@ -51,8 +51,17 @@ enum stix_errnum_t
STIX_EINTERN, /**< internal error */
STIX_ESYSMEM, /**< insufficient system memory */
STIX_EOOMEM, /**< insufficient object memory */
STIX_EINVAL, /**< invalid parameter or data */
STIX_EEXIST, /**< existing/duplicate data */
STIX_EBUSY,
STIX_EACCES,
STIX_EPERM,
STIX_ENOTDIR,
STIX_EINTR,
STIX_EPIPE,
STIX_EAGAIN,
STIX_ETOOBIG, /**< data too large */
STIX_EMSGSND, /**< message sending error. even doesNotUnderstand: is not found */
STIX_ERANGE, /**< range error. overflow and underflow */
@ -188,7 +197,7 @@ typedef enum stix_method_type_t stix_method_type_t;
#define STIX_OOP_TAG_BITS 2
#define STIX_OOP_TAG_SMINT 1
#define STIX_OOP_TAG_CHAR 2
#define STIX_OOP_TAG_RSRC 3
#define STIX_OOP_TAG_ERROR 3
#define STIX_OOP_GET_TAG(oop) (((stix_oow_t)oop) & STIX_LBMASK(stix_oow_t, STIX_OOP_TAG_BITS))
#define STIX_OOP_IS_NUMERIC(oop) (STIX_OOP_GET_TAG(oop) != 0)
@ -196,16 +205,14 @@ typedef enum stix_method_type_t stix_method_type_t;
#define STIX_OOP_IS_SMOOI(oop) (STIX_OOP_GET_TAG(oop) == STIX_OOP_TAG_SMINT)
#define STIX_OOP_IS_CHAR(oop) (STIX_OOP_GET_TAG(oop) == STIX_OOP_TAG_CHAR)
#define STIX_OOP_IS_RSRC(oop) (STIX_OOP_GET_TAG(oop) == STIX_OOP_TAG_RSRC)
#define STIX_OOP_IS_ERROR(oop) (STIX_OOP_GET_TAG(oop) == STIX_OOP_TAG_ERROR)
#define STIX_SMOOI_TO_OOP(num) ((stix_oop_t)((((stix_ooi_t)(num)) << STIX_OOP_TAG_BITS) | STIX_OOP_TAG_SMINT))
#define STIX_OOP_TO_SMOOI(oop) (((stix_ooi_t)oop) >> STIX_OOP_TAG_BITS)
#define STIX_CHAR_TO_OOP(num) ((stix_oop_t)((((stix_oow_t)(num)) << STIX_OOP_TAG_BITS) | STIX_OOP_TAG_CHAR))
#define STIX_OOP_TO_CHAR(oop) (((stix_oow_t)oop) >> STIX_OOP_TAG_BITS)
/* RSRC(resurce) is a index to the VM's resource table(stix->rsrc.ptr) */
#define STIX_RSRC_TO_OOP(num) ((stix_oop_t)((((stix_oow_t)(num)) << STIX_OOP_TAG_BITS) | STIX_OOP_TAG_RSRC))
#define STIX_OOP_TO_RSRC(oop) (((stix_oow_t)oop) >> STIX_OOP_TAG_BITS)
#define STIX_ERROR_TO_OOP(num) ((stix_oop_t)((((stix_oow_t)(num)) << STIX_OOP_TAG_BITS) | STIX_OOP_TAG_ERROR))
#define STIX_OOP_TO_ERROR(oop) (((stix_oow_t)oop) >> STIX_OOP_TAG_BITS)
/* SMOOI takes up 62 bits on a 64-bit architecture and 30 bits
* on a 32-bit architecture. The absolute value takes up 61 bits and 29 bits
@ -660,14 +667,8 @@ struct stix_process_scheduler_t
* The STIX_CLASSOF() macro return the class of an object including a numeric
* object encoded into a pointer.
*/
/*
#define STIX_CLASSOF(stix,oop) ( \
STIX_OOP_IS_SMOOI(oop)? (stix)->_small_integer: \
STIX_OOP_IS_CHAR(oop)? (stix)->_character: STIX_OBJ_GET_CLASS(oop) \
)
* */
#define STIX_CLASSOF(stix,oop) \
(STIX_OOP_GET_TAG(oop)? *stix->tagged_classes[STIX_OOP_GET_TAG(oop)]: STIX_OBJ_GET_CLASS(oop))
(STIX_OOP_GET_TAG(oop)? (*stix->tagged_classes[STIX_OOP_GET_TAG(oop)]): STIX_OBJ_GET_CLASS(oop))
/**
* The STIX_BYTESOF() macro returns the size of the payload of
@ -692,8 +693,6 @@ struct stix_heap_t
stix_uint8_t* ptr; /* next allocation pointer */
};
typedef struct stix_t stix_t;
/* =========================================================================
* VIRTUAL MACHINE PRIMITIVES
* ========================================================================= */
@ -788,6 +787,8 @@ struct stix_mod_data_t
};
typedef struct stix_mod_data_t stix_mod_data_t;
struct stix_sbuf_t
{
stix_ooch_t* ptr;
@ -837,13 +838,18 @@ struct stix_t
stix_heap_t* curheap;
stix_heap_t* newheap;
/* ========================= */
/* =============================================================
* nil, true, false
* ============================================================= */
stix_oop_t _nil; /* pointer to the nil object */
stix_oop_t _true;
stix_oop_t _false;
/* == NEVER CHANGE THE ORDER OF FIELDS BELOW == */
/* stix_ignite() assumes this order. make sure to update symnames in ignite_3() */
/* =============================================================
* KERNEL CLASSES
* Be sure to Keep these kernel class pointers registered in the
* kernel_classes table in gc.c
* ============================================================= */
stix_oop_t _apex; /* Apex */
stix_oop_t _undefined_object; /* UndefinedObject */
stix_oop_t _class; /* Class */
@ -867,17 +873,22 @@ struct stix_t
stix_oop_t _process; /* Process */
stix_oop_t _semaphore; /* Semaphore */
stix_oop_t _process_scheduler; /* ProcessScheduler */
stix_oop_t _error_class; /* Error */
stix_oop_t _true_class; /* True */
stix_oop_t _false_class; /* False */
stix_oop_t _character; /* Character */
stix_oop_t _small_integer; /* SmallInteger */
stix_oop_t _large_positive_integer; /* LargePositiveInteger */
stix_oop_t _large_negative_integer; /* LargeNegativeInteger */
/* =============================================================
* END KERNEL CLASSES
* ============================================================= */
stix_oop_t _resource;
/* == NEVER CHANGE THE ORDER OF FIELDS ABOVE == */
/* =============================================================
* KEY SYSTEM DICTIONARIES
* ============================================================= */
stix_oop_t* tagged_classes[4];
stix_oop_set_t symtab; /* system-wide symbol table. instance of SymbolSet */
stix_oop_set_t sysdic; /* system dictionary. instance of SystemDictionary */
@ -897,7 +908,9 @@ struct stix_t
stix_oop_t* tmp_stack[256]; /* stack for temporaries */
stix_oow_t tmp_count;
/* == EXECUTION REGISTERS == */
/* =============================================================
* EXECUTION REGISTERS
* ============================================================= */
stix_oop_context_t initial_context; /* fake initial context */
stix_oop_context_t active_context;
stix_oop_method_t active_method;
@ -907,7 +920,9 @@ struct stix_t
int proc_switched; /* TODO: this is temporary. implement something else to skip immediate context switching */
int switch_proc;
stix_ntime_t vm_time_offset;
/* == END EXECUTION REGISTERS == */
/* =============================================================
* END EXECUTION REGISTERS
* ============================================================= */
/* == BIGINT CONVERSION == */
struct
@ -917,15 +932,6 @@ struct stix_t
} bigint[37];
/* == END BIGINT CONVERSION == */
/* == RSRC MANAGEMENT == */
struct
{
stix_oow_t* ptr;
stix_oow_t free;
stix_oow_t capa;
} rsrc;
/* == END RSRC MANAGEMENT == */
stix_sbuf_t sbuf[64];
#if defined(STIX_INCLUDE_COMPILER)
@ -958,7 +964,7 @@ struct stix_t
* also you must not call this macro more than once */
#define STIX_STACK_SETRET(stix,nargs,retv) (STIX_STACK_POPS(stix, nargs), STIX_STACK_SETTOP(stix, retv))
#define STIX_STACK_SETRETTORCV(stix,nargs) (STIX_STACK_POPS(stix, nargs))
#define STIX_STACK_SETRETTOERROR(stix,nargs,ec) (STIX_STACK_POPS(stix, nargs), STIX_STACK_SETTOP(stix, STIX_ERROR_TO_OOP(ec)))
/* =========================================================================
* STIX VM LOGGING
@ -1010,15 +1016,13 @@ typedef enum stix_log_mask_t stix_log_mask_t;
/* =========================================================================
* STIX ASSERTION
* ========================================================================= */
#if 0
#if defined(NDEBUG)
# define STIX_ASSERT(expr) ((void)0)
# define STIX_ASSERT(stix,expr) ((void)0)
#else
# define STIX_ASSERT(expr) (void)((expr) || \
(stix_logbfmt ("%s at %s:%d", #expr, __FILE__, (int)__LINE__), 0))
#endif
# define STIX_ASSERT(stix,expr) ((void)((expr) || (stix_assertfailed (stix, #expr, __FILE__, __LINE__), 0)))
#endif
#if defined(__cplusplus)
extern "C" {
#endif
@ -1181,14 +1185,9 @@ STIX_EXPORT void stix_poptmps (
stix_oow_t count
);
STIX_EXPORT int stix_decode (
stix_t* stix,
stix_oop_method_t mth,
const stix_oocs_t* classfqn
);
/* Memory allocation/deallocation functions using stix's MMGR */
/* =========================================================================
* SYSTEM MEMORY MANAGEMENT FUCNTIONS VIA MMGR
* ========================================================================= */
STIX_EXPORT void* stix_allocmem (
stix_t* stix,
stix_oow_t size
@ -1272,6 +1271,28 @@ STIX_EXPORT stix_ooi_t stix_logoofmt (
...
);
/* =========================================================================
* MISCELLANEOUS HELPER FUNCTIONS
* ========================================================================= */
STIX_EXPORT int stix_decode (
stix_t* stix,
stix_oop_method_t mth,
const stix_oocs_t* classfqn
);
STIX_EXPORT void stix_assertfailed (
stix_t* stix,
const stix_bch_t* expr,
const stix_bch_t* file,
stix_oow_t line
);
STIX_EXPORT stix_errnum_t stix_syserrtoerrnum (
int e
);
#if defined(__cplusplus)
}
#endif

14
stix/lib/sym.c
View File

@ -70,8 +70,8 @@ static stix_oop_oop_t expand_bucket (stix_t* stix, stix_oop_oop_t oldbuc)
symbol = (stix_oop_char_t)oldbuc->slot[--oldsz];
if ((stix_oop_t)symbol != stix->_nil)
{
STIX_ASSERT (STIX_CLASSOF(stix,symbol) == stix->_symbol);
/*STIX_ASSERT (sym->size > 0);*/
STIX_ASSERT (stix, STIX_CLASSOF(stix,symbol) == stix->_symbol);
/*STIX_ASSERT (stix, sym->size > 0);*/
index = stix_hashchars(symbol->slot, STIX_OBJ_GET_SIZE(symbol)) % newsz;
while (newbuc->slot[index] != stix->_nil) index = (index + 1) % newsz;
@ -88,7 +88,7 @@ static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_ooch_t* ptr, sti
stix_oow_t index;
stix_oop_char_t symbol;
STIX_ASSERT (len > 0);
STIX_ASSERT (stix, len > 0);
if (len <= 0)
{
/* i don't allow an empty symbol name */
@ -96,14 +96,14 @@ static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_ooch_t* ptr, sti
return STIX_NULL;
}
STIX_ASSERT (STIX_CLASSOF(stix,stix->symtab->bucket) == stix->_array);
STIX_ASSERT (stix, STIX_CLASSOF(stix,stix->symtab->bucket) == stix->_array);
index = stix_hashchars(ptr, len) % STIX_OBJ_GET_SIZE(stix->symtab->bucket);
/* find a matching symbol in the open-addressed symbol table */
while (stix->symtab->bucket->slot[index] != stix->_nil)
{
symbol = (stix_oop_char_t)stix->symtab->bucket->slot[index];
STIX_ASSERT (STIX_CLASSOF(stix,symbol) == (stix_oop_t)stix->_symbol);
STIX_ASSERT (stix, STIX_CLASSOF(stix,symbol) == (stix_oop_t)stix->_symbol);
if (len == STIX_OBJ_GET_SIZE(symbol) &&
stix_equaloochars (ptr, symbol->slot, len))
@ -121,7 +121,7 @@ static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_ooch_t* ptr, sti
}
/* make a new symbol and insert it */
STIX_ASSERT (STIX_OOP_IS_SMOOI(stix->symtab->tally));
STIX_ASSERT (stix, STIX_OOP_IS_SMOOI(stix->symtab->tally));
tally = STIX_OOP_TO_SMOOI(stix->symtab->tally);
if (tally >= STIX_SMOOI_MAX)
{
@ -163,7 +163,7 @@ static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_ooch_t* ptr, sti
symbol = (stix_oop_char_t)stix_instantiate(stix, stix->_symbol, ptr, len);
if (symbol)
{
STIX_ASSERT (tally < STIX_SMOOI_MAX);
STIX_ASSERT (stix, tally < STIX_SMOOI_MAX);
stix->symtab->tally = STIX_SMOOI_TO_OOP(tally + 1);
stix->symtab->bucket->slot[index] = (stix_oop_t)symbol;
}

13
stix/lib/utf8.c
View File

@ -64,8 +64,8 @@ static STIX_INLINE __utf8_t* get_utf8_slot (stix_uch_t uc)
{
__utf8_t* cur, * end;
STIX_ASSERT (STIX_SIZEOF(stix_bch_t) == 1);
STIX_ASSERT (STIX_SIZEOF(stix_uch_t) >= 2);
/*STIX_ASSERT (stix, STIX_SIZEOF(stix_bch_t) == 1);
STIX_ASSERT (stix, STIX_SIZEOF(stix_uch_t) >= 2);*/
end = utf8_table + STIX_COUNTOF(utf8_table);
cur = utf8_table;
@ -110,10 +110,10 @@ stix_oow_t stix_utf8touc (const stix_bch_t* utf8, stix_oow_t size, stix_uch_t* u
{
__utf8_t* cur, * end;
STIX_ASSERT (utf8 != STIX_NULL);
STIX_ASSERT (size > 0);
STIX_ASSERT (STIX_SIZEOF(stix_bch_t) == 1);
STIX_ASSERT (STIX_SIZEOF(stix_uch_t) >= 2);
/*STIX_ASSERT (stix, utf8 != STIX_NULL);
STIX_ASSERT (stix, size > 0);
STIX_ASSERT (stix, STIX_SIZEOF(stix_bch_t) == 1);
STIX_ASSERT (stix, STIX_SIZEOF(stix_uch_t) >= 2);*/
end = utf8_table + STIX_COUNTOF(utf8_table);
cur = utf8_table;
@ -176,4 +176,3 @@ stix_oow_t stix_utf8touc (const stix_bch_t* utf8, stix_oow_t size, stix_uch_t* u
return 0; /* error - invalid sequence */
}

6
stix/lib/utl.c
View File

@ -275,7 +275,6 @@ int stix_copyoocstrtosbuf (stix_t* stix, const stix_ooch_t* str, int id)
}
/* ----------------------------------------------------------------------- */
static STIX_INLINE int bcsn_to_ucsn_with_cmgr (
@ -477,7 +476,7 @@ static STIX_INLINE int ucsn_to_bcsn_with_cmgr (
}
/* it assumes that bcsbuf is large enough to hold a character */
STIX_ASSERT (n <= STIX_COUNTOF(bcsbuf));
/*STIX_ASSERT (stix, n <= STIX_COUNTOF(bcsbuf));*/
p++; mlen += n;
}
@ -559,7 +558,7 @@ static int ucs_to_bcs_with_cmgr (
}
/* it assumes that bcs is large enough to hold a character */
STIX_ASSERT (n <= STIX_COUNTOF(bcs));
/*STIX_ASSERT (stix, n <= STIX_COUNTOF(bcs));*/
p++; mlen += n;
}
@ -639,4 +638,3 @@ int stix_ucstobcs (stix_t* stix, const stix_uch_t* ucs, stix_oow_t* ucslen, stix
return ucsn_to_bcsn_with_cmgr (ucs, ucslen, bcs, bcslen, stix->cmgr);
}
}

1
stix/mod/console.c
View File

@ -66,7 +66,6 @@ static int pf_open (stix_t* stix, stix_ooi_t nargs)
/* error */
}
rsrc = stix_makersrc (stix, h);
#else

12
stix/mod/stdio.c
View File

@ -29,12 +29,9 @@
#include <stix-utl.h>
#include <stdio.h>
#include <errno.h>
#include <limits.h>
/* TODO: remvoe this assert use one defined in stix.h */
#include <assert.h>
#define STIX_ASSERT(x) assert(x)
typedef struct stdio_t stdio_t;
struct stdio_t
{
@ -84,7 +81,8 @@ static int pf_open (stix_t* stix, stix_ooi_t nargs)
if (!rcv->fp)
{
STIX_DEBUG2 (stix, "cannot open %s for %s\n", namebuf, modebuf);
return -1; /* TODO: return success with an object instead... */
STIX_STACK_SETRETTOERROR (stix, nargs, stix_syserrtoerrnum(errno));
return 1;
}
STIX_DEBUG3 (stix, "opened %s for %s - %p\n", namebuf, modebuf, rcv->fp);
@ -120,8 +118,6 @@ static int pf_puts (stix_t* stix, stix_ooi_t nargs)
stdio_t* rcv;
stix_ooi_t i;
rcv = (stdio_t*)STIX_STACK_GETRCV(stix, nargs);
for (i = 0; i < nargs; i++)
@ -133,7 +129,7 @@ static int pf_puts (stix_t* stix, stix_ooi_t nargs)
if (STIX_OOP_IS_CHAR(x))
{
/* do some faking. */
STIX_ASSERT (STIX_SIZEOF(tmpc) >= STIX_SIZEOF(stix_obj_t) + STIX_SIZEOF(stix_ooch_t));
STIX_ASSERT (stix, STIX_SIZEOF(tmpc) >= STIX_SIZEOF(stix_obj_t) + STIX_SIZEOF(stix_ooch_t));
tmpc.slot[0] = STIX_OOP_TO_CHAR(x);
x = (stix_oop_char_t)&tmpc;