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' #class(#byte) Stdio(Object) from 'stdio'
{ {
#dcl(#class) in out err.
(* (*
* The following methods are generated by the module. * The following methods are generated by the module.
* #method(#class) _newInstSize { <primitive: #stdio._newInstSize> } * #method(#class) _newInstSize { <primitive: #stdio._newInstSize> }
@ -9,15 +11,12 @@
#method(#class) new: size #method(#class) new: size
{ {
##self prohibited ## ignore the specified size
##raise exception. prohibited...
^(super new: (self _newInstSize)) ^(super new: (self _newInstSize))
} }
#method(#class) new #method(#class) new
{ {
##self prohibited
##raise exception. prohibited...
^(super new: (self _newInstSize)) ^(super new: (self _newInstSize))
} }
@ -30,17 +29,20 @@
(* --------------------- (* ---------------------
#method(#class) input #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 #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 #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) #class Magnitude(Object)
{ {

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

@ -126,26 +126,23 @@
##v1 := Stdio2 open: '/tmp/1.txt' for: 'w+'. ##v1 := Stdio2 open: '/tmp/1.txt' for: 'w+'.
v1 := Stdio2 new open: '/tmp/1.txt' for: 'w+'. v1 := Stdio2 new open: '/tmp/1.txt' for: 'w+'.
## v1 puts: 'hello'. (v1 isError)
v1 puts ('hello', 'world', 'good', C'\n', C'\t', 'under my umbrella.', C'\n'). ifTrue: [
v1 close. 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. ]. nil isNil ifTrue: [ 'NIL NIL NIL' dump. ].
(Apex new) notNil ifTrue: [ 'APEX 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_test (10, 20, 30, 40, 50) dump.
self varg_test2 (10, 20, 30, 40, 50) dump. self varg_test2 (10, 20, 30, 40, 50) dump.
self varg_test3 (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. thisContext vargCount dump.
} }
#method(#class) varg_test() #method(#class) varg_test()
{ {
0 to: (thisContext vargCount - 1) do: [:k | 0 to: (thisContext vargCount - 1) do: [:k |

1
stix/lib/Makefile.am
View File

@ -47,7 +47,6 @@ libstix_la_SOURCES = \
logfmt.c \ logfmt.c \
gc.c \ gc.c \
heap.c \ heap.c \
ignite.c \
obj.c \ obj.c \
proc.c \ proc.c \
rbt.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 \ 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-debug.lo libstix_la-decode.lo libstix_la-dic.lo \
libstix_la-exec.lo libstix_la-logfmt.lo libstix_la-gc.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-heap.lo libstix_la-obj.lo libstix_la-proc.lo \
libstix_la-proc.lo libstix_la-rbt.lo libstix_la-stix.lo \ libstix_la-rbt.lo libstix_la-stix.lo libstix_la-sym.lo \
libstix_la-sym.lo libstix_la-utf8.lo libstix_la-utl.lo libstix_la-utf8.lo libstix_la-utl.lo
libstix_la_OBJECTS = $(am_libstix_la_OBJECTS) libstix_la_OBJECTS = $(am_libstix_la_OBJECTS)
AM_V_lt = $(am__v_lt_@AM_V@) AM_V_lt = $(am__v_lt_@AM_V@)
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
@ -414,7 +414,6 @@ libstix_la_SOURCES = \
logfmt.c \ logfmt.c \
gc.c \ gc.c \
heap.c \ heap.c \
ignite.c \
obj.c \ obj.c \
proc.c \ proc.c \
rbt.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-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-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-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-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-obj.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstix_la-proc.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@ @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 @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 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_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 @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 #endif
#if (STIX_SIZEOF_OOI_T == STIX_SIZEOF_INT) && defined(STIX_HAVE_BUILTIN_SMUL_OVERFLOW) #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) #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) #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 #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 /* take note that this function is not supposed to handle
* the whole stix_ooi_t range. it handles the smooi subrange */ * 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) #if (STIX_SIZEOF_UINTMAX_T > STIX_SIZEOF_OOI_T)
stix_intmax_t k; stix_intmax_t k;
STIX_ASSERT (STIX_IN_SMOOI_RANGE(a)); STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(a));
STIX_ASSERT (STIX_IN_SMOOI_RANGE(b)); STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(b));
k = (stix_intmax_t)a * (stix_intmax_t)b; k = (stix_intmax_t)a * (stix_intmax_t)b;
*c = (stix_ooi_t)k; *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_ooi_t ua, ub;
STIX_ASSERT (STIX_IN_SMOOI_RANGE(a)); STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(a));
STIX_ASSERT (STIX_IN_SMOOI_RANGE(b)); STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(b));
*c = a * b; *c = a * b;
@ -220,7 +220,7 @@ static int is_normalized_integer (stix_t* stix, stix_oop_t oop)
stix_oow_t sz; stix_oow_t sz;
sz = STIX_OBJ_GET_SIZE(oop); 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; 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_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: 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? */ /* 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) 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, STIX_OOP_IS_POINTER(num));
STIX_ASSERT (STIX_OBJ_GET_CLASS(num) == stix->_large_positive_integer || STIX_ASSERT (stix, STIX_OBJ_GET_CLASS(num) == stix->_large_positive_integer ||
STIX_OBJ_GET_CLASS(num) == stix->_large_negative_integer); STIX_OBJ_GET_CLASS(num) == stix->_large_negative_integer);
#if (STIX_LIW_BITS == STIX_OOW_BITS) #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) if (STIX_OBJ_GET_SIZE(num) == 1)
{ {
*w = ((stix_oop_word_t)num)->slot[0]; *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 * you must not call this function with an unnormalized
* large integer. */ * 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) if (STIX_OBJ_GET_SIZE(num) == 2)
{ {
*w = MAKE_WORD (((stix_oop_halfword_t)num)->slot[0], ((stix_oop_halfword_t)num)->slot[1]); *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); 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) static STIX_INLINE stix_oop_t make_bigint_with_oow (stix_t* stix, stix_oow_t w)
{ {
#if (STIX_LIW_BITS == STIX_OOW_BITS) #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); return stix_instantiate (stix, stix->_large_positive_integer, &w, 1);
#elif (STIX_LIW_BITS == STIX_OOHW_BITS) #elif (STIX_LIW_BITS == STIX_OOHW_BITS)
stix_liw_t hw[2]; 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) #if (STIX_LIW_BITS == STIX_OOW_BITS)
stix_oow_t w; 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) if (i >= 0)
{ {
w = i; 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 /* The caller must ensure that i is greater than the smallest value
* that stix_ooi_t can represent. otherwise, the absolute value * that stix_ooi_t can represent. otherwise, the absolute value
* cannot be held in stix_ooi_t. */ * 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; w = -i;
return stix_instantiate (stix, stix->_large_negative_integer, &w, 1); 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 else
{ {
STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t)); STIX_ASSERT (stix, i > STIX_TYPE_MIN(stix_ooi_t));
w = -i; w = -i;
hw[0] = w /*& STIX_LBMASK(stix_oow_t,STIX_LIW_BITS)*/; hw[0] = w /*& STIX_LBMASK(stix_oow_t,STIX_LIW_BITS)*/;
hw[1] = w >> 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_oow_t w;
stix_oop_t z; stix_oop_t z;
STIX_ASSERT (extra <= STIX_OBJ_SIZE_MAX - 1); STIX_ASSERT (stix, extra <= STIX_OBJ_SIZE_MAX - 1);
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) if (i >= 0)
{ {
w = i; w = i;
@ -412,7 +412,7 @@ static STIX_INLINE stix_oop_t make_bloated_bigint_with_ooi (stix_t* stix, stix_o
} }
else else
{ {
STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t)); STIX_ASSERT (stix, i > STIX_TYPE_MIN(stix_ooi_t));
w = -i; w = -i;
z = stix_instantiate (stix, stix->_large_negative_integer, STIX_NULL, 1 + extra); 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_oow_t w;
stix_oop_t z; stix_oop_t z;
STIX_ASSERT (extra <= STIX_OBJ_SIZE_MAX - 2); STIX_ASSERT (stix, extra <= STIX_OBJ_SIZE_MAX - 2);
if (i >= 0) if (i >= 0)
{ {
w = i; w = i;
@ -436,7 +436,7 @@ static STIX_INLINE stix_oop_t make_bloated_bigint_with_ooi (stix_t* stix, stix_o
} }
else else
{ {
STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t)); STIX_ASSERT (stix, i > STIX_TYPE_MIN(stix_ooi_t));
w = -i; w = -i;
hw[0] = w /*& STIX_LBMASK(stix_oow_t,STIX_LIW_BITS)*/; hw[0] = w /*& STIX_LBMASK(stix_oow_t,STIX_LIW_BITS)*/;
hw[1] = w >> 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 /* this is not a generic function. it can't handle v
* if it's STIX_TYPE_MIN(stix_intmax_t) */ * 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; ui = (v >= 0)? v: -v;
len = 0; 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_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 (STIX_IN_SMOOI_RANGE(w))*/
if (w <= STIX_SMOOI_MAX) 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 i;
stix_oow_t count; 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); count = STIX_OBJ_GET_SIZE(oop);
if (inc > STIX_OBJ_SIZE_MAX - count) 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_oop_t z;
stix_oow_t i; 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); if (count <= 0) count = STIX_OBJ_GET_SIZE(oop);
stix_pushtmp (stix, &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_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) if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer)
{ {
c = stix->_large_negative_integer; c = stix->_large_negative_integer;
} }
else 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; 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_oow_t count;
STIX_ASSERT (STIX_OOP_IS_POINTER(oop)); STIX_ASSERT (stix, STIX_OOP_IS_POINTER(oop));
count = count_effective_digits (oop); count = count_effective_digits (oop);
#if (STIX_LIW_BITS == STIX_OOW_BITS) #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 else
{ {
STIX_ASSERT (-STIX_SMOOI_MAX == STIX_SMOOI_MIN); STIX_ASSERT (stix, -STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer); 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); 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 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]); 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 else
{ {
STIX_ASSERT (-STIX_SMOOI_MAX == STIX_SMOOI_MIN); STIX_ASSERT (stix, -STIX_SMOOI_MAX == STIX_SMOOI_MIN);
STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer); 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); 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; 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_oow_t i;
stix_lidw_t w; 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. * this function is not designed to handle such a case.
* in fact, 0 is a small integer and it must not stand a change * in fact, 0 is a small integer and it must not stand a change
* to be given to this function */ * 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) 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 #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 #if 1
stix_oow_t i; 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) if (x == y)
{ {
STIX_ASSERT (xs == ys); STIX_ASSERT (stix, xs == ys);
z[0] = 0; z[0] = 0;
return 1; 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++) 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) if (x == y)
{ {
STIX_ASSERT (xs == ys); STIX_ASSERT (stix, xs == ys);
z[0] = 0; z[0] = 0;
return 1; 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; borrowed_word = (stix_lidw_t)1 << STIX_LIW_BITS;
for (i = 0; i < ys; i++) 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--; while (i > 1 && z[i - 1] == 0) i--;
return i; /* the number of effective digits in the result */ 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_yl = nshifts; /* ndigits of lower part of y */
ndigits_yh = ys - nshifts; /* ndigits of uppoer part of y */ ndigits_yh = ys - nshifts; /* ndigits of uppoer part of y */
STIX_ASSERT (ndigits_xl >= ndigits_xh); STIX_ASSERT (stix, ndigits_xl >= ndigits_xh);
STIX_ASSERT (ndigits_yl >= ndigits_yh); STIX_ASSERT (stix, ndigits_yl >= ndigits_yh);
/* make a temporary buffer for (b0 + b1) and (a1 * b1) */ /* make a temporary buffer for (b0 + b1) and (a1 * b1) */
tmplen[0] = ndigits_xh + ndigits_yh; 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) */ /* (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) */ /* (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' */ /* a1b1 is in tmp[1]. add (a1b1 * B^2n) to the high part of 'z' */
zsp = z + (nshifts * 2); /* emulate shifting for "* B^2n". */ zsp = z + (nshifts * 2); /* emulate shifting for "* B^2n". */
xlen = zcapa - (nshifts * 2); xlen = zcapa - (nshifts * 2);
@ -1240,8 +1240,8 @@ oops:
ndigits_yl = nshifts; /* ndigits of lower part of y */ ndigits_yl = nshifts; /* ndigits of lower part of y */
ndigits_yh = ys - nshifts; /* ndigits of uppoer part of y */ ndigits_yh = ys - nshifts; /* ndigits of uppoer part of y */
STIX_ASSERT (ndigits_xl >= ndigits_xh); STIX_ASSERT (stix, ndigits_xl >= ndigits_xh);
STIX_ASSERT (ndigits_yl >= ndigits_yh); STIX_ASSERT (stix, ndigits_yl >= ndigits_yh);
/* make a temporary buffer for (b0 + b1) and (a1 * b1) */ /* make a temporary buffer for (b0 + b1) and (a1 * b1) */
tmplen[0] = ndigits_yl + ndigits_yh + 1; tmplen[0] = ndigits_yl + ndigits_yh + 1;
@ -1305,11 +1305,11 @@ oops:
} }
/* w = w - tmp[0] */ /* 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] */ /* r = w - tmp[1] */
zsp = z + nshifts; /* emulate shifting for "* B^n" */ 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' */ /* a1b1 is in tmp[1]. add (a1b1 * B^2n) to the high part of 'z' */
zsp = z + (nshifts * 2); /* emulate shifting for "* B^2n". */ 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)); STIX_MEMSET (&x[xs - word_shifts], 0, word_shifts * STIX_SIZEOF(stix_liw_t));
} }
static void divide_unsigned_array ( 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)
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. /* TODO: this function needs to be rewritten for performance improvement.
* the binary long division is extremely slow for a big number */ * 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_oow_t rs, i , j;
STIX_ASSERT (xs >= ys); STIX_ASSERT (stix, xs >= ys);
STIX_MEMSET (q, 0, STIX_SIZEOF(*q) * xs); STIX_MEMSET (q, 0, STIX_SIZEOF(*q) * xs);
STIX_MEMSET (r, 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); rs = count_effective (r, xs);
if (!is_less_unsigned_array (r, rs, y, ys)) 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); 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_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, &x);
stix_pushtmp (stix, &y); 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); stix_poptmps (stix, 2);
if (!z) return STIX_NULL; 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)x)->slot, STIX_OBJ_GET_SIZE(x),
((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y), ((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y),
((stix_oop_liword_t)z)->slot); ((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; stix_oop_t qq, rr;
/* the caller must ensure that x >= y */ /* 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, &x);
stix_pushtmp (stix, &y); stix_pushtmp (stix, &y);
qq = stix_instantiate (stix, stix->_large_positive_integer, STIX_NULL, STIX_OBJ_GET_SIZE(x)); 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); stix_poptmps (stix, 3);
if (!rr) return STIX_NULL; 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)x)->slot, STIX_OBJ_GET_SIZE(x),
((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y), ((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y),
((stix_oop_liword_t)qq)->slot, ((stix_oop_liword_t)rr)->slot); ((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 /* no integer overflow/underflow must occur as the possible integer
* range is narrowed by the tag bits used */ * 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, 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_MIN + STIX_SMOOI_MIN > STIX_TYPE_MIN(stix_ooi_t));
i = STIX_OOP_TO_SMOOI(x) + STIX_OOP_TO_SMOOI(y); i = STIX_OOP_TO_SMOOI(x) + STIX_OOP_TO_SMOOI(y);
if (STIX_IN_SMOOI_RANGE(i)) return STIX_SMOOI_TO_OOP(i); 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 /* no integer overflow/underflow must occur as the possible integer
* range is narrowed by the tag bits used */ * 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, 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_MIN - STIX_SMOOI_MAX > STIX_TYPE_MIN(stix_ooi_t));
i = STIX_OOP_TO_SMOOI(x) - STIX_OOP_TO_SMOOI(y); i = STIX_OOP_TO_SMOOI(x) - STIX_OOP_TO_SMOOI(y);
if (STIX_IN_SMOOI_RANGE(i)) return STIX_SMOOI_TO_OOP(i); 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); xv = STIX_OOP_TO_SMOOI(x);
yv = STIX_OOP_TO_SMOOI(y); 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 */ /* 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; q = xv / yv;
STIX_ASSERT (STIX_IN_SMOOI_RANGE(q)); STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(q));
r = xv - yv * q; /* xv % yv; */ r = xv - yv * q; /* xv % yv; */
if (r) 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 */ * change the sign of r to the divisor's sign */
r += yv; r += yv;
--q; --q;
STIX_ASSERT (r && !IS_SIGN_DIFF(yv, r)); STIX_ASSERT (stix, r && !IS_SIGN_DIFF(yv, r));
} }
} }
else 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. */ * architecture. */
r -= yv; r -= yv;
++q; ++q;
STIX_ASSERT (xv && !IS_SIGN_DIFF(xv, r)); STIX_ASSERT (stix, xv && !IS_SIGN_DIFF(xv, r));
} }
} }
} }
if (rem) if (rem)
{ {
STIX_ASSERT (STIX_IN_SMOOI_RANGE(r)); STIX_ASSERT (stix, STIX_IN_SMOOI_RANGE(r));
*rem = STIX_SMOOI_TO_OOP(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 defined(STIX_LIMIT_OBJ_SIZE)
if (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer) return STIX_SMOOI_TO_OOP(0); 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) if (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer)
{ {
return STIX_SMOOI_TO_OOP (0); 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); if (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer) return STIX_SMOOI_TO_OOP(0);
sign = bigint_to_oow (stix, y, &w); sign = bigint_to_oow (stix, y, &w);
STIX_ASSERT (sign >= 0); STIX_ASSERT (stix, sign >= 0);
if (sign >= 1) if (sign >= 1)
{ {
wp = (w - 1) / STIX_LIW_BITS; 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_oop_t quo, rem;
STIX_ASSERT (sign == 0); STIX_ASSERT (stix, sign == 0);
stix_pushtmp (stix, &x); stix_pushtmp (stix, &x);
y = stix_subints (stix, y, STIX_SMOOI_TO_OOP(1)); 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; if (!quo) return STIX_NULL;
sign = integer_to_oow (stix, quo, &wp); sign = integer_to_oow (stix, quo, &wp);
STIX_ASSERT (sign >= 0); STIX_ASSERT (stix, sign >= 0);
if (sign == 0) if (sign == 0)
{ {
/* too large. set it to xs so that it gets out of /* 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; wp = xs;
} }
STIX_ASSERT (STIX_OOP_IS_SMOOI(rem)); STIX_ASSERT (stix, STIX_OOP_IS_SMOOI(rem));
bp = STIX_OOP_TO_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) 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_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 /* 2's complement on the remaining part of x. the lacking part
* in y is treated as if they are all 1s. */ * 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; carry[0] = w[0] >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0]; ((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 */ /* 2's complement on the final result */
((stix_oop_liword_t)z)->slot[zs] = ~(stix_liw_t)0; ((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; carry[0] = w[0] >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0]; ((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); 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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] & (stix_liw_t)w; ((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 /* 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_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 /* 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 * 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; carry[0] = w[0] >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0]; ((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); 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_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
} }
STIX_ASSERT (carry == 0); STIX_ASSERT (stix, carry == 0);
goto adjust_to_negative; goto adjust_to_negative;
} }
else if (negy) 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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] | (stix_liw_t)w; ((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] /* [NOTE]
* in theory, the lacking part in ys is all 1s when y is * 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_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 */ /* treat the lacking part in y as all 1s */
for (; i < xs; i++) 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; carry[0] = w[0] >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] ^ (~(stix_liw_t)0); ((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) 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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w; ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
} }
STIX_ASSERT (carry == 0); STIX_ASSERT (stix, carry == 0);
adjust_to_negative: adjust_to_negative:
/* 2's complement on the final result */ /* 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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w; ((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); 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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] ^ (stix_liw_t)w; ((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 */ /* treat the lacking part in y as all 1s */
for (; i < xs; i++) 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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ~(stix_liw_t)w; ((stix_oop_liword_t)z)->slot[i] = ~(stix_liw_t)w;
} }
STIX_ASSERT (carry == 0); STIX_ASSERT (stix, carry == 0);
} }
else else
{ {
@ -3037,7 +3034,7 @@ stix_oop_t stix_bitinvint (stix_t* stix, stix_oop_t x)
carry = w >> STIX_LIW_BITS; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w; ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
} }
STIX_ASSERT (carry == 0); STIX_ASSERT (stix, carry == 0);
#else #else
carry = 1; carry = 1;
for (i = 0; i < xs; i++) 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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w; ((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_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 #endif
STIX_OBJ_SET_CLASS (z, stix->_large_negative_integer); 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_lidw_t carry;
stix_oow_t i, xs; 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); xs = STIX_OBJ_GET_SIZE(x);
stix_pushtmp (stix, &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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = ~(stix_liw_t)w; ((stix_oop_liword_t)z)->slot[i] = ~(stix_liw_t)w;
} }
STIX_ASSERT (carry == 0); STIX_ASSERT (stix, carry == 0);
/* shift to the right */ /* shift to the right */
rshift_unsigned_array (((stix_oop_liword_t)z)->slot, xs, shift); 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; carry = w >> STIX_LIW_BITS;
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w; ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w;
} }
STIX_ASSERT (carry == 0); STIX_ASSERT (stix, carry == 0);
#else #else
carry = 1; carry = 1;
for (i = 0; i < xs; i++) 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)w;
} }
((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)carry; ((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 #endif
return z; /* z is not normalized */ 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; stix_oow_t shift;
int sign; int sign;
STIX_ASSERT (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer); STIX_ASSERT (stix, 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(y) == stix->_large_negative_integer);
/* for convenience in subtraction below. /* for convenience in subtraction below.
* it could be STIX_TYPE_MAX(stix_oow_t) * 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 */ /* no more shift */
return normalize_bigint (stix, z); return normalize_bigint (stix, z);
} }
STIX_ASSERT (sign <= -1); STIX_ASSERT (stix, sign <= -1);
} }
stix_pushtmp (stix, &y); 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; stix_ooi_t v;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
STIX_ASSERT (v < 0); STIX_ASSERT (stix, v < 0);
/* normal right shift of a small negative integer */ /* normal right shift of a small negative integer */
if (shift >= STIX_OOI_BITS - 1) 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); while (1);
/* this part must not be reached */ /* 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; stix->errnum = STIX_EINTERN;
return STIX_NULL; 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; stix_oow_t zs, shift;
int sign; int sign;
STIX_ASSERT (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer); STIX_ASSERT (stix, 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(y) == stix->_large_negative_integer);
zs = STIX_OBJ_GET_SIZE(x); 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 else
{ {
if (shift == 0) break; if (shift == 0) break;
STIX_ASSERT (sign <= -1); STIX_ASSERT (stix, sign <= -1);
} }
} }
while (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; stix_oow_t wshift, shift;
int sign; 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 /* this loop is very inefficient as shifting is repeated
* with lshift_unsigned_array(). however, this part of the * 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) if (shift == 0)
{ {
STIX_ASSERT (is_normalized_integer (stix, x)); STIX_ASSERT (stix, is_normalized_integer (stix, x));
return x; return x;
} }
STIX_ASSERT (sign >= 1); STIX_ASSERT (stix, sign >= 1);
} }
} }
while (1); while (1);
/* this part must not be reached */ /* 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; stix->errnum = STIX_EINTERN;
return STIX_NULL; 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 /* the maximum number of bit shifts are guaranteed to be
* small enough to fit into the stix_oow_t type. so i can * small enough to fit into the stix_oow_t type. so i can
* easily assume that all bits are shifted out */ * 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); return (negx)? STIX_SMOOI_TO_OOP(-1): STIX_SMOOI_TO_OOP(0);
#else #else
if (negx) 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 * small enough to fit into the stix_oow_t type. so i can
* simply return a failure here becuase it's surely too * simply return a failure here becuase it's surely too
* large after shifting */ * 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? */ stix->errnum = STIX_EOOMEM; /* is it a soft failure or a hard failure? is this error code proper? */
return STIX_NULL; return STIX_NULL;
#else #else
@ -3510,7 +3507,7 @@ stix_oop_t stix_bitshiftint (stix_t* stix, stix_oop_t x, stix_oop_t y)
/* right shift */ /* right shift */
bigint_and_negative_oow: bigint_and_negative_oow:
STIX_ASSERT (sign <= -1); STIX_ASSERT (stix, sign <= -1);
if (negx) 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; radix = -radix;
} }
STIX_ASSERT (radix >= 2 && radix <= 36); STIX_ASSERT (stix, radix >= 2 && radix <= 36);
ptr = str; ptr = str;
end = str + len; 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--; 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; if (hwlen == 0 || w > 0) hwp[hwlen++] = w;
} }
else else
@ -3693,7 +3690,7 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
hwp = hw; hwp = hw;
} }
STIX_ASSERT (ptr < end); STIX_ASSERT (stix, ptr < end);
do do
{ {
r1 = 0; 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); while (ptr < end);
} }
STIX_ASSERT (hwlen >= 1); STIX_ASSERT (stix, hwlen >= 1);
#if (STIX_LIW_BITS == STIX_OOW_BITS) #if (STIX_LIW_BITS == STIX_OOW_BITS)
if (hwlen == 1) if (hwlen == 1)
{ {
w = hwp[0]; 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); if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP((stix_ooi_t)w * sign);
} }
#elif (STIX_LIW_BITS == STIX_OOHW_BITS) #elif (STIX_LIW_BITS == STIX_OOHW_BITS)
if (hwlen == 1) 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); return STIX_SMOOI_TO_OOP((stix_ooi_t)hwp[0] * sign);
} }
else if (hwlen == 2) else if (hwlen == 2)
{ {
w = MAKE_WORD(hwp[0], hwp[1]); 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); if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP((stix_ooi_t)w * sign);
} }
#else #else
@ -3776,10 +3773,10 @@ oops_einval:
return STIX_NULL; 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_ooch_t* ptr;
STIX_ASSERT (radix >= 2 && radix <= 36); STIX_ASSERT (stix, radix >= 2 && radix <= 36);
ptr = buf; ptr = buf;
do 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_oow_t xlen = 0, seglen;
stix_oop_t s; 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; if (!stix_isint(stix,num)) goto oops_einval;
v = integer_to_oow (stix, num, &w); 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_ooch_t buf[STIX_OOW_BITS + 1];
stix_oow_t len; stix_oow_t len;
len = oow_to_text (w, radix, buf); len = oow_to_text (stix, w, radix, buf);
if (v < 0) buf[len++] = '-'; if (v < 0) buf[len++] = '-';
reverse_string (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); while (1);
} }
STIX_ASSERT (xpos >= 1); STIX_ASSERT (stix, xpos >= 1);
if (STIX_OBJ_GET_CLASS(num) == stix->_large_negative_integer) xbuf[--xpos] = '-'; if (STIX_OBJ_GET_CLASS(num) == stix->_large_negative_integer) xbuf[--xpos] = '-';
s = stix_makestring (stix, &xbuf[xpos], xlen - 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; 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 */ /* get 'rs' before 'as' gets changed */
rs = count_effective (r, as); 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) #if (STIX_LIW_BITS == STIX_OOW_BITS)
STIX_ASSERT (rs == 1); STIX_ASSERT (stix, rs == 1);
w = r[0]; w = r[0];
#elif (STIX_LIW_BITS == STIX_OOHW_BITS) #elif (STIX_LIW_BITS == STIX_OOHW_BITS)
if (rs == 1) w = r[0]; if (rs == 1) w = r[0];
else else
{ {
STIX_ASSERT (rs == 2); STIX_ASSERT (stix, rs == 2);
w = MAKE_WORD (r[0], r[1]); w = MAKE_WORD (r[0], r[1]);
} }
#else #else
# error UNSUPPORTED LIW BIT SIZE # error UNSUPPORTED LIW BIT SIZE
#endif #endif
seglen = oow_to_text (w, radix, &xbuf[xlen]); seglen = oow_to_text (stix, w, radix, &xbuf[xlen]);
xlen += seglen; xlen += seglen;
if (r == a) break; /* reached the last block */ 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, ptr = str->ptr,
end = str->ptr + str->len; end = str->ptr + str->len;
STIX_ASSERT (ptr < end); STIX_ASSERT (stix, ptr < end);
if (*ptr == '+' || *ptr == '-') 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) if (radixed)
{ {
STIX_ASSERT (ptr < end); STIX_ASSERT (stix, ptr < end);
base = 0; base = 0;
do do
@ -429,7 +429,7 @@ static int string_to_smooi (stix_t* stix, stix_oocs_t* str, int radixed, stix_oo
} }
else base = 10; else base = 10;
STIX_ASSERT (ptr < end); STIX_ASSERT (stix, ptr < end);
value = old_value = 0; value = old_value = 0;
while (ptr < end && (v = CHAR_TO_NUM(*ptr, base)) < base) 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; return -1;
} }
STIX_ASSERT (-STIX_SMOOI_MAX == STIX_SMOOI_MIN); STIX_ASSERT (stix, -STIX_SMOOI_MAX == STIX_SMOOI_MIN);
if (value > STIX_SMOOI_MAX) if (value > STIX_SMOOI_MAX)
{ {
stix->errnum = STIX_ERANGE; 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, ptr = str->ptr,
end = str->ptr + str->len; end = str->ptr + str->len;
STIX_ASSERT (ptr < end); STIX_ASSERT (stix, ptr < end);
if (*ptr == '+' || *ptr == '-') 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) if (radixed)
{ {
STIX_ASSERT (ptr < end); STIX_ASSERT (stix, ptr < end);
base = 0; base = 0;
do 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) static STIX_INLINE void unget_char (stix_t* stix, const stix_iolxc_t* c)
{ {
/* Make sure that the unget buffer is large enough */ /* 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; 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 */ /* collect the potential radix specifier */
r = CHAR_TO_NUM (c, 10); r = CHAR_TO_NUM (c, 10);
STIX_ASSERT (r < 10); STIX_ASSERT (stix, r < 10);
radix = radix * 10 + r; radix = radix * 10 + r;
} }
@ -1570,7 +1570,7 @@ static void clear_io_names (stix_t* stix)
{ {
stix_iolink_t* cur; stix_iolink_t* cur;
STIX_ASSERT (stix->c != STIX_NULL); STIX_ASSERT (stix, stix->c != STIX_NULL);
while (stix->c->io_names) while (stix->c->io_names)
{ {
@ -1673,7 +1673,7 @@ static int end_include (stix_t* stix)
cur = stix->c->curinp; cur = stix->c->curinp;
stix->c->curinp = stix->c->curinp->includer; 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_freemem (stix, cur);
/* stix->parse.depth.incl--; */ /* 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) if (self)
{ {
STIX_ASSERT (STIX_CLASSOF(stix, self) == stix->_class); STIX_ASSERT (stix, STIX_CLASSOF(stix, self) == stix->_class);
/* [NOTE] /* [NOTE]
* the loop here assumes that the class has the following * 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) while (super != stix->_nil)
{ {
STIX_ASSERT (STIX_CLASSOF(stix, super) == stix->_class); STIX_ASSERT (stix, STIX_CLASSOF(stix, super) == stix->_class);
/* [NOTE] /* [NOTE]
* the loop here assumes that the class has the following * the loop here assumes that the class has the following
@ -2138,7 +2138,7 @@ done:
/* the class being compiled has a superclass */ /* 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) switch (index)
{ {
case VAR_INSTANCE: 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) static int compile_unary_method_name (stix_t* stix)
{ {
STIX_ASSERT (stix->c->mth.name.len == 0); STIX_ASSERT (stix, stix->c->mth.name.len == 0);
STIX_ASSERT (stix->c->mth.tmpr_nargs == 0); STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 0);
if (add_method_name_fragment(stix, TOKEN_NAME(stix)) <= -1) return -1; if (add_method_name_fragment(stix, TOKEN_NAME(stix)) <= -1) return -1;
GET_TOKEN (stix); GET_TOKEN (stix);
@ -2571,7 +2571,7 @@ static int compile_unary_method_name (stix_t* stix)
if (TOKEN_TYPE(stix) == STIX_IOTOK_LPAREN) if (TOKEN_TYPE(stix) == STIX_IOTOK_LPAREN)
{ {
/* this is a procedural style method */ /* 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); GET_TOKEN (stix);
if (TOKEN_TYPE(stix) != STIX_IOTOK_RPAREN) 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) static int compile_binary_method_name (stix_t* stix)
{ {
STIX_ASSERT (stix->c->mth.name.len == 0); STIX_ASSERT (stix, stix->c->mth.name.len == 0);
STIX_ASSERT (stix->c->mth.tmpr_nargs == 0); STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 0);
if (add_method_name_fragment(stix, TOKEN_NAME(stix)) <= -1) return -1; if (add_method_name_fragment(stix, TOKEN_NAME(stix)) <= -1) return -1;
GET_TOKEN (stix); GET_TOKEN (stix);
@ -2632,14 +2632,14 @@ static int compile_binary_method_name (stix_t* stix)
return -1; 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. /* no duplication check is performed against class-level variable names.
* a duplcate name will shade a previsouly defined variable. */ * a duplcate name will shade a previsouly defined variable. */
if (add_temporary_variable(stix, TOKEN_NAME(stix)) <= -1) return -1; if (add_temporary_variable(stix, TOKEN_NAME(stix)) <= -1) return -1;
stix->c->mth.tmpr_nargs++; 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 /* this check should not be not necessary
if (stix->c->mth.tmpr_nargs > MAX_CODE_NARGS) 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) static int compile_keyword_method_name (stix_t* stix)
{ {
STIX_ASSERT (stix->c->mth.name.len == 0); STIX_ASSERT (stix, stix->c->mth.name.len == 0);
STIX_ASSERT (stix->c->mth.tmpr_nargs == 0); STIX_ASSERT (stix, stix->c->mth.tmpr_nargs == 0);
do do
{ {
@ -2697,7 +2697,7 @@ static int compile_method_name (stix_t* stix)
*/ */
int n; 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; stix->c->mth.name_loc = stix->c->tok.loc;
switch (TOKEN_TYPE(stix)) 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 /* the total number of temporaries is equal to the number of
* arguments after having processed the message pattern. it's because * arguments after having processed the message pattern. it's because
* stix treats arguments the same as temporaries */ * 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; const stix_ooch_t* dot;
dot = stix_findoochar (name->ptr, name->len, '.'); 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 && if (dot - (const stix_ooch_t*)name->ptr == 4 &&
stix_equaloochars(name->ptr, vocas[VOCA_SELF].str, 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: case VAR_CLASS:
/* a class variable can be access by both instance methods and class methods */ /* a class variable can be access by both instance methods and class methods */
STIX_ASSERT (var->cls != STIX_NULL); STIX_ASSERT (stix, var->cls != STIX_NULL);
STIX_ASSERT (STIX_CLASSOF(stix, var->cls) == stix->_class); STIX_ASSERT (stix, STIX_CLASSOF(stix, var->cls) == stix->_class);
/* increment the position by the number of class instance variables /* increment the position by the number of class instance variables
* as the class variables are placed after the 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 */ /* 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; block_loc = stix->c->tok.loc;
GET_TOKEN (stix); GET_TOKEN (stix);
saved_tmprs_len = stix->c->mth.tmprs.len; saved_tmprs_len = stix->c->mth.tmprs.len;
saved_tmpr_count = stix->c->mth.tmpr_count; saved_tmpr_count = stix->c->mth.tmpr_count;
STIX_ASSERT (stix->c->mth.blk_depth > 0); STIX_ASSERT (stix, 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_tmprcnt[stix->c->mth.blk_depth - 1] == saved_tmpr_count);
if (TOKEN_TYPE(stix) == STIX_IOTOK_COLON) 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 /* the token reader reads a valid token. no other errors
* than the range error must not occur */ * 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 /* if the token is out of the SMOOI range, it's too big or
* to small to be a byte */ * to small to be a byte */
@ -3454,7 +3454,7 @@ static int __read_array_literal (stix_t* stix, stix_oop_t* xlit)
break; break;
case STIX_IOTOK_CHARLIT: 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]); lit = STIX_CHAR_TO_OOP(TOKEN_NAME_PTR(stix)[0]);
break; break;
@ -3578,7 +3578,7 @@ static int compile_array_literal (stix_t* stix)
stix_oop_t lit; stix_oop_t lit;
stix_oow_t index; 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 || if (read_array_literal(stix, &lit) <= -1 ||
add_literal(stix, lit, &index) <= -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, /* if a temporary variable is accessed inside a block,
* use a special instruction to indicate it */ * 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--) for (i = stix->c->mth.blk_depth; i > 0; i--)
{ {
if (var.pos >= stix->c->mth.blk_tmprcnt[i - 1]) 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; break;
case STIX_IOTOK_CHARLIT: 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; if (emit_push_character_literal(stix, TOKEN_NAME_PTR(stix)[0]) <= -1) return -1;
GET_TOKEN (stix); GET_TOKEN (stix);
break; break;
@ -3818,7 +3818,7 @@ static int compile_unary_message (stix_t* stix, int to_super)
stix_oow_t index; stix_oow_t index;
stix_oow_t nargs; stix_oow_t nargs;
STIX_ASSERT (TOKEN_TYPE(stix) == STIX_IOTOK_IDENT); STIX_ASSERT (stix, TOKEN_TYPE(stix) == STIX_IOTOK_IDENT);
do do
{ {
@ -3875,7 +3875,7 @@ static int compile_binary_message (stix_t* stix, int to_super)
stix_oocs_t binsel; stix_oocs_t binsel;
stix_oow_t saved_binsels_len, binsel_offset; 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 do
{ {
@ -3999,7 +3999,7 @@ static int compile_message_expression (stix_t* stix, int to_super)
if (TOKEN_TYPE(stix) == STIX_IOTOK_BINSEL) 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_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--; 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) 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_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--; 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 (compile_binary_message(stix, to_super) <= -1) return -1;
if (TOKEN_TYPE(stix) == STIX_IOTOK_KEYWORD) 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_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--; stix->c->mth.code.len--;
@ -4058,7 +4058,7 @@ static int compile_message_expression (stix_t* stix, int to_super)
else else
{ {
/* delete the NOOP instruction inserted */ /* 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_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--; stix->c->mth.code.len--;
goto done; goto done;
@ -4110,7 +4110,7 @@ static int compile_method_expression (stix_t* stix, int pop)
stix_oow_t index; stix_oow_t index;
int ret = 0; int ret = 0;
STIX_ASSERT (pop == 0 || pop == 1); STIX_ASSERT (stix, pop == 0 || pop == 1);
STIX_MEMSET (&assignee, 0, STIX_SIZEOF(assignee)); STIX_MEMSET (&assignee, 0, STIX_SIZEOF(assignee));
if (TOKEN_TYPE(stix) == STIX_IOTOK_IDENT || 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, /* if a temporary variable is accessed inside a block,
* use a special instruction to indicate it */ * 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--) for (i = stix->c->mth.blk_depth; i > 0; i--)
{ {
if (var.pos >= stix->c->mth.blk_tmprcnt[i - 1]) if (var.pos >= stix->c->mth.blk_tmprcnt[i - 1])
@ -4485,7 +4485,7 @@ static int add_compiled_method (stix_t* stix)
} }
else else
{ {
STIX_ASSERT (stix->c->mth.pftype == 4); STIX_ASSERT (stix, stix->c->mth.pftype == 4);
preamble_code = STIX_METHOD_PREAMBLE_ENSURE; preamble_code = STIX_METHOD_PREAMBLE_ENSURE;
preamble_index = 0; 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*/) if (stix->c->mth.variadic /*&& stix->c->mth.tmpr_nargs > 0*/)
preamble_flags |= STIX_METHOD_PREAMBLE_FLAG_VARIADIC; 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->owner = stix->c->cls.self_oop;
mth->name = name; mth->name = name;
@ -4625,8 +4625,8 @@ static int make_defined_class (stix_t* stix)
{ {
/* this is an internally created class object being defined. */ /* this is an internally created class object being defined. */
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_ASSERT (STIX_OBJ_GET_FLAGS_KERNEL (stix->c->cls.self_oop) == 1); 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) || if (spec != STIX_OOP_TO_SMOOI(stix->c->cls.self_oop->spec) ||
self_spec != STIX_OOP_TO_SMOOI(stix->c->cls.self_oop->selfspec)) 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; just_made = 1;
stix->c->cls.self_oop = (stix_oop_class_t)tmp; 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->spec = STIX_SMOOI_TO_OOP(spec);
stix->c->cls.self_oop->selfspec = STIX_SMOOI_TO_OOP(self_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) if (extend)
{ {
/* extending class */ /* 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_lookupsysdic(stix, &stix->c->cls.name);*/
ass = stix_lookupdic(stix, stix->c->cls.ns_oop, &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->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); STIX_CLASSOF(stix, stix->c->cls.super_oop) == stix->_class);
} }
else 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, /* no class of such a name is found. it's a new definition,
* which is normal for most new classes. */ * 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) if (super_is_nil)
@ -5023,7 +5023,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
{ {
stix_ooch_t* ptr, * end; 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; ptr = pds->slot;
end = pds->slot + STIX_OBJ_GET_SIZE(pds); end = pds->slot + STIX_OBJ_GET_SIZE(pds);
@ -5049,7 +5049,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
ptr++; ptr++;
} }
tok.len = ptr - tok.ptr; tok.len = ptr - tok.ptr;
STIX_ASSERT (tok.len > 0); STIX_ASSERT (stix, tok.len > 0);
if (dotted) 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.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_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++) for (i = 0; i < STIX_COUNTOF(stix->c->cls.var_count); i++)
{ {
stix->c->cls.var_count[i] = 0; stix->c->cls.var_count[i] = 0;
@ -5246,7 +5246,7 @@ static int __compile_pooldic_definition (stix_t* stix)
goto add_literal; goto add_literal;
case STIX_IOTOK_CHARLIT: 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]); lit = STIX_CHAR_TO_OOP(TOKEN_NAME_PTR(stix)[0]);
goto add_literal; goto add_literal;
@ -5549,7 +5549,7 @@ int stix_compile (stix_t* stix, stix_ioimpl_t io)
if (compile_stream (stix) <= -1) goto oops; if (compile_stream (stix) <= -1) goto oops;
/* close the stream */ /* 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); stix->c->impl (stix, STIX_IO_CLOSE, stix->c->curinp);
return 0; return 0;
@ -5566,7 +5566,7 @@ oops:
stix->c->impl (stix, STIX_IO_CLOSE, stix->c->curinp); stix->c->impl (stix, STIX_IO_CLOSE, stix->c->curinp);
prev = stix->c->curinp->includer; 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_MMGR_FREE (stix->mmgr, stix->c->curinp);
stix->c->curinp = prev; stix->c->curinp = prev;
} }
@ -5577,6 +5577,6 @@ oops:
void stix_getsynerr (stix_t* stix, stix_synerr_t* synerr) 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; 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); LOG_INST_2 (stix, "make_block %zu %zu", b1, b2);
STIX_ASSERT (b1 >= 0); STIX_ASSERT (stix, b1 >= 0);
STIX_ASSERT (b2 >= b1); STIX_ASSERT (stix, b2 >= b1);
break; break;
case BCODE_SEND_BLOCK_COPY: 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]; ass = (stix_oop_association_t)oldbuc->slot[--oldsz];
if ((stix_oop_t)ass != stix->_nil) 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; 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; index = stix_hashchars(key->slot, STIX_OBJ_GET_SIZE(key)) % newsz;
while (newbuc->slot[index] != stix->_nil) index = (index + 1) % 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. /* the system dictionary is not a generic dictionary.
* it accepts only a symbol as a key. */ * it accepts only a symbol as a key. */
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol); STIX_ASSERT (stix, STIX_CLASSOF(stix,key) == stix->_symbol);
STIX_ASSERT (STIX_CLASSOF(stix,dic->tally) == stix->_small_integer); STIX_ASSERT (stix, STIX_CLASSOF(stix,dic->tally) == stix->_small_integer);
STIX_ASSERT (STIX_CLASSOF(stix,dic->bucket) == stix->_array); 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); 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]; ass = (stix_oop_association_t)dic->bucket->slot[index];
STIX_ASSERT (STIX_CLASSOF(stix,ass) == stix->_association); STIX_ASSERT (stix, STIX_CLASSOF(stix,ass) == stix->_association);
STIX_ASSERT (STIX_CLASSOF(stix,ass->key) == stix->_symbol); STIX_ASSERT (stix, STIX_CLASSOF(stix,ass->key) == stix->_symbol);
if (STIX_OBJ_GET_SIZE(key) == STIX_OBJ_GET_SIZE(ass->key) && 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))) 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. */ /* 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); tally = STIX_OOP_TO_SMOOI(dic->tally);
if (tally >= STIX_SMOOI_MAX) 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, /* the current tally must be less than the maximum value. otherwise,
* it overflows after increment below */ * 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->tally = STIX_SMOOI_TO_OOP(tally + 1);
dic->bucket->slot[index] = (stix_oop_t)ass; 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_oow_t index;
stix_oop_association_t ass; stix_oop_association_t ass;
STIX_ASSERT (STIX_CLASSOF(stix,dic->tally) == stix->_small_integer); STIX_ASSERT (stix, STIX_CLASSOF(stix,dic->tally) == stix->_small_integer);
STIX_ASSERT (STIX_CLASSOF(stix,dic->bucket) == stix->_array); STIX_ASSERT (stix, STIX_CLASSOF(stix,dic->bucket) == stix->_array);
index = stix_hashchars(name->ptr, name->len) % STIX_OBJ_GET_SIZE(dic->bucket); 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]; ass = (stix_oop_association_t)dic->bucket->slot[index];
STIX_ASSERT (STIX_CLASSOF(stix,ass) == stix->_association); STIX_ASSERT (stix, STIX_CLASSOF(stix,ass) == stix->_association);
STIX_ASSERT (STIX_CLASSOF(stix,ass->key) == stix->_symbol); STIX_ASSERT (stix, STIX_CLASSOF(stix,ass->key) == stix->_symbol);
if (name->len == STIX_OBJ_GET_SIZE(ass->key) && if (name->len == STIX_OBJ_GET_SIZE(ass->key) &&
stix_equaloochars(name->ptr, ((stix_oop_char_t)ass->key)->slot, name->len)) 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_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); 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_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); 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_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); 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_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); 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_set_t dic;
stix_oop_t tmp; 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); dic = (stix_oop_set_t)stix_instantiate (stix, cls, STIX_NULL, 0);
if (!dic) return STIX_NULL; 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); stix_pushtmp (stix, (stix_oop_t*)&dic);
tmp = stix_instantiate (stix, stix->_array, STIX_NULL, size); 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->tally = STIX_SMOOI_TO_OOP(0);
dic->bucket = (stix_oop_oop_t)tmp; dic->bucket = (stix_oop_oop_t)tmp;
STIX_ASSERT (STIX_OBJ_GET_SIZE(dic) == STIX_SET_NAMED_INSTVARS); STIX_ASSERT (stix, 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->bucket) == size);
return dic; 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" #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) static void compact_symbol_table (stix_t* stix, stix_oop_t _nil)
{ {
stix_oop_char_t symbol; 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. /* the symbol table doesn't allow more data items than STIX_SMOOI_MAX.
* so stix->symtab->tally must always be a small integer */ * 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); 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; if (tally <= 0) return;
/* NOTE: in theory, the bucket size can be greater than STIX_SMOOI_MAX /* 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; 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++) 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 */ * at the current hash index */
symbol = (stix_oop_char_t)stix->symtab->bucket->slot[y]; 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; 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--; tally--;
} }
STIX_ASSERT (tally >= 0); STIX_ASSERT (stix, tally >= 0);
STIX_ASSERT (tally <= STIX_SMOOI_MAX); STIX_ASSERT (stix, tally <= STIX_SMOOI_MAX);
stix->symtab->tally = STIX_SMOOI_TO_OOP(tally); 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 * | 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, 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, 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_EXTRA(oop) == 0); /* no 'extra' for an OOP object */
nbytes = STIX_OBJ_BYTESOF(oop) + STIX_SIZEOF(stix_oow_t) + \ nbytes = STIX_OBJ_BYTESOF(oop) + STIX_SIZEOF(stix_oow_t) + \
(stix_oow_t)((stix_oop_oop_t)oop)->slot[STIX_OBJ_GET_SIZE(oop)]; (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, * assuming the new heap is as large as the old heap,
* and garbage collection doesn't allocate more objects * and garbage collection doesn't allocate more objects
* than in the old heap, it must not fail. */ * 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 */ /* copy the payload to the new object */
STIX_MEMCPY (tmp, oop, STIX_SIZEOF(stix_obj_t) + nbytes_aligned); 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_oow_t nbytes;
STIX_ASSERT (STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_OOP); STIX_ASSERT (stix, 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, 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_EXTRA(oop) == 0); /* no 'extra' for an OOP object */
nbytes = STIX_OBJ_BYTESOF(oop) + STIX_SIZEOF(stix_oow_t) + \ nbytes = STIX_OBJ_BYTESOF(oop) + STIX_SIZEOF(stix_oow_t) + \
(stix_oow_t)((stix_oop_oop_t)oop)->slot[STIX_OBJ_GET_SIZE(oop)]; (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. */ * are garbages. */
size = STIX_PROCESS_NAMED_INSTVARS + size = STIX_PROCESS_NAMED_INSTVARS +
STIX_OOP_TO_SMOOI(((stix_oop_process_t)oop)->sp) + 1; 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 else
{ {
@ -268,8 +567,8 @@ void stix_gc (stix_t* stix)
{ {
/* TODO: verify if this is correct */ /* TODO: verify if this is correct */
STIX_ASSERT ((stix_oop_t)stix->processor != stix->_nil); STIX_ASSERT (stix, (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->active != stix->_nil);
/* store the stack pointer to the active process */ /* store the stack pointer to the active process */
stix->processor->active->sp = STIX_SMOOI_TO_OOP(stix->sp); 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->_true = stix_moveoop (stix, stix->_true);
stix->_false = stix_moveoop (stix, stix->_false); stix->_false = stix_moveoop (stix, stix->_false);
stix->_apex = stix_moveoop (stix, stix->_apex); for (i = 0; i < STIX_COUNTOF(kernel_classes); i++)
stix->_class = stix_moveoop (stix, stix->_class); {
stix->_undefined_object = stix_moveoop (stix, stix->_undefined_object); stix_oop_t tmp;
stix->_object = stix_moveoop (stix, stix->_object); tmp = *(stix_oop_t*)((stix_uint8_t*)stix + kernel_classes[i].offset);
stix->_array = stix_moveoop (stix, stix->_array); tmp = stix_moveoop (stix, tmp);
stix->_byte_array = stix_moveoop (stix, stix->_byte_array); *(stix_oop_t*)((stix_uint8_t*)stix + kernel_classes[i].offset) = tmp;
}
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);
stix->sysdic = (stix_oop_set_t) stix_moveoop (stix, (stix_oop_t)stix->sysdic); 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); 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. /* if you have too many temporaries pushed, something must be wrong.
* change your code not to exceede the stack limit */ * 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; stix->tmp_stack[stix->tmp_count++] = oop_ptr;
} }
void stix_poptmp (stix_t* stix) void stix_poptmp (stix_t* stix)
{ {
STIX_ASSERT (stix->tmp_count > 0); STIX_ASSERT (stix, stix->tmp_count > 0);
stix->tmp_count--; stix->tmp_count--;
} }
void stix_poptmps (stix_t* stix, stix_oow_t 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; 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->ptr = (stix_uint8_t*)STIX_ALIGN(((stix_uintptr_t)heap->base), STIX_SIZEOF(stix_oop_t));
heap->limit = heap->base + size; heap->limit = heap->base + size;
STIX_ASSERT (heap->ptr >= heap->base); STIX_ASSERT (stix, heap->ptr >= heap->base);
STIX_ASSERT (heap->limit >= heap->base ); STIX_ASSERT (stix, heap->limit >= heap->base );
STIX_ASSERT (heap->limit - heap->base == size); STIX_ASSERT (stix, heap->limit - heap->base == size);
/* if size is too small, heap->ptr may go past heap->limit even at /* if size is too small, heap->ptr may go past heap->limit even at
* this moment depending on the alignment of heap->base. subsequent * 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)); 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 else
{ {
stix_oop_class_t c; stix_oop_class_t c;
stix_oow_t i; 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);*/ c = (stix_oop_class_t)STIX_OBJ_GET_CLASS(oop); /*STIX_CLASSOF(stix, oop);*/
if ((stix_oop_t)c == stix->_large_negative_integer) 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; fltfmt = &stix->d->fltfmt;
fltout = &stix->d->fltout; fltout = &stix->d->fltout;
fltfmt->ptr = fltfmt->sbuf; fltfmt->ptr = fltfmt->buf;
fltfmt->capa = STIX_COUNTOF(fltfmt->sbuf) - 1; fltfmt->capa = STIX_COUNTOF(fltfmt->buf) - 1;
fltout->ptr = fltout->sbuf; fltout->ptr = fltout->buf;
fltout->capa = STIX_COUNTOF(fltout->sbuf) - 1; fltout->capa = STIX_COUNTOF(fltout->buf) - 1;
#endif #endif
while (1) while (1)
@ -444,7 +444,7 @@ reswitch:
stix_oow_t conv_len, src_len, tot_len = 0; stix_oow_t conv_len, src_len, tot_len = 0;
while (n > 0) while (n > 0)
{ {
STIX_ASSERT (bslen > tot_len); STIX_ASSERT (stix, bslen > tot_len);
src_len = bslen - tot_len; src_len = bslen - tot_len;
conv_len = STIX_COUNTOF(conv_buf); conv_len = STIX_COUNTOF(conv_buf);
@ -575,7 +575,7 @@ reswitch:
fmtlen = fmt - percent; fmtlen = fmt - percent;
if (fmtlen > fltfmt->capa) 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)); fltfmt->ptr = STIX_MMGR_ALLOC (STIX_MMGR_GETDFL(), STIX_SIZEOF(*fltfmt->ptr) * (fmtlen + 1));
if (fltfmt->ptr == STIX_NULL) goto oops; if (fltfmt->ptr == STIX_NULL) goto oops;
@ -635,7 +635,7 @@ reswitch:
newcapa = precision + width + 32; newcapa = precision + width + 32;
if (fltout->capa < newcapa) 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)); fltout->ptr = STIX_MMGR_ALLOC (STIX_MMGR_GETDFL(), STIX_SIZEOF(char_t) * (newcapa + 1));
if (fltout->ptr == STIX_NULL) goto oops; 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_t* bb;
bb = (bb_t*)arg->handle; 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); fclose (bb->fp);
stix_freemem (stix, bb); 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; 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 do
{ {
x = fgetc (bb->fp); 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. * buffer not sufficient. not all got converted yet.
* write what have been converted this round. */ * 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 */ /* attempt to write all converted characters */
if (write_all (1, buf, bcslen) <= -1) break; 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_oow_t named_instvar;
stix_obj_type_t indexed_type; stix_obj_type_t indexed_type;
STIX_ASSERT (STIX_OOP_IS_POINTER(_class)); STIX_ASSERT (stix, STIX_OOP_IS_POINTER(_class));
STIX_ASSERT (STIX_CLASSOF(stix, _class) == stix->_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); 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 */ 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; return -1;
} }
STIX_ASSERT (named_instvar + vlen <= STIX_OBJ_SIZE_MAX); STIX_ASSERT (stix, named_instvar + vlen <= STIX_OBJ_SIZE_MAX);
} }
else 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); 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; return -1;
} }
STIX_ASSERT (named_instvar <= STIX_OBJ_SIZE_MAX); STIX_ASSERT (stix, named_instvar <= STIX_OBJ_SIZE_MAX);
} }
*type = indexed_type; *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 alloclen;
stix_oow_t tmp_count = 0; 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) 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. */ * the variable part(indexed instance variables) are allowed. */
oop = stix_allocoopobj (stix, alloclen); 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 This function is not GC-safe. so i don't want to initialize
the payload of a pointer object. The caller can call this 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 alloclen;
stix_oow_t tmp_count = 0; 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) 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 alloclen;
stix_oow_t tmp_count = 0; 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) if (decode_spec (stix, _class, vlen, &type, &alloclen) <= -1)
{ {

4
stix/lib/proc.c
View File

@ -27,8 +27,6 @@
#include "stix-prv.h" #include "stix-prv.h"
stix_oop_process_t stix_addnewproc (stix_t* stix) stix_oop_process_t stix_addnewproc (stix_t* stix)
{ {
stix_oop_process_t proc; 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); 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; 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 (kcop == STIX_RBT_COPIER_INLINE) as += KTOB(rbt,klen);
if (vcop == STIX_RBT_COPIER_INLINE) as += VTOB(rbt,vlen); 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; if (n == STIX_NULL) return STIX_NULL;
n->color = STIX_RBT_RED; n->color = STIX_RBT_RED;
@ -90,7 +90,7 @@ STIX_INLINE stix_rbt_pair_t* stix_rbt_allocpair (
KPTR(n) = kcop (rbt, kptr, klen); KPTR(n) = kcop (rbt, kptr, klen);
if (KPTR(n) == STIX_NULL) if (KPTR(n) == STIX_NULL)
{ {
STIX_MMGR_FREE (rbt->mmgr, n); STIX_MMGR_FREE (rbt->stix->mmgr, n);
return STIX_NULL; 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) if (rbt->style->freeer[STIX_RBT_KEY] != STIX_NULL)
rbt->style->freeer[STIX_RBT_KEY] (rbt, KPTR(n), KLEN(n)); 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; 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)); rbt->style->freeer[STIX_RBT_KEY] (rbt, KPTR(pair), KLEN(pair));
if (rbt->style->freeer[STIX_RBT_VAL] != STIX_NULL) if (rbt->style->freeer[STIX_RBT_VAL] != STIX_NULL)
rbt->style->freeer[STIX_RBT_VAL] (rbt, VPTR(pair), VLEN(pair)); 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[] = 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]; 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; 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 (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; 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) void stix_rbt_close (stix_rbt_t* rbt)
{ {
stix_rbt_fini (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 */ /* do not zero out the extension */
STIX_MEMSET (rbt, 0, STIX_SIZEOF(*rbt)); 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_KEY] = (kscale < 1)? 1: kscale;
rbt->scale[STIX_RBT_VAL] = (vscale < 1)? 1: vscale; 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_rbt_clear (rbt);
} }
stix_mmgr_t* stix_rbt_getmmgr (stix_rbt_t* rbt)
{
return rbt->mmgr;
}
void* stix_rbt_getxtn (stix_rbt_t* rbt) void* stix_rbt_getxtn (stix_rbt_t* rbt)
{ {
return (void*)(rbt + 1); 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) 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; 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; stix_rbt_pair_t* parent, * z, * c;
int cid1, cid2; int cid1, cid2;
STIX_ASSERT (pivot != STIX_NULL); STIX_ASSERT (rbt->stix, pivot != STIX_NULL);
if (leftwise) if (leftwise)
{ {
@ -352,13 +347,13 @@ static void rotate (stix_rbt_t* rbt, stix_rbt_pair_t* pivot, int leftwise)
} }
else else
{ {
STIX_ASSERT (parent->right == pivot); STIX_ASSERT (rbt->stix, parent->right == pivot);
parent->right = z; parent->right = z;
} }
} }
else else
{ {
STIX_ASSERT (rbt->root == pivot); STIX_ASSERT (rbt->stix, rbt->root == pivot);
rbt->root = z; rbt->root = z;
} }
@ -379,7 +374,7 @@ static void adjust (stix_rbt_t* rbt, stix_rbt_pair_t* pair)
x_par = pair->parent; x_par = pair->parent;
if (x_par->color == STIX_RBT_BLACK) break; 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]) if (x_par == x_par->parent->child[LEFT])
{ {
@ -469,7 +464,7 @@ static stix_rbt_pair_t* change_pair_val (
} }
else else
{ {
STIX_ASSERT (pair->parent->right == pair); STIX_ASSERT (rbt->stix, pair->parent->right == pair);
pair->parent->right = p; pair->parent->right = p;
} }
} }
@ -542,7 +537,7 @@ static stix_rbt_pair_t* insert (
if (x_par == STIX_NULL) if (x_par == STIX_NULL)
{ {
/* the tree contains no pair */ /* the tree contains no pair */
STIX_ASSERT (rbt->root == &rbt->xnil); STIX_ASSERT (rbt->stix, rbt->root == &rbt->xnil);
rbt->root = x_new; rbt->root = x_new;
} }
else 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)); int n = rbt->style->comper (rbt, kptr, klen, KPTR(x_par), KLEN(x_par));
if (n > 0) if (n > 0)
{ {
STIX_ASSERT (x_par->right == &rbt->xnil); STIX_ASSERT (rbt->stix, x_par->right == &rbt->xnil);
x_par->right = x_new; x_par->right = x_new;
} }
else else
{ {
STIX_ASSERT (x_par->left == &rbt->xnil); STIX_ASSERT (rbt->stix, x_par->left == &rbt->xnil);
x_par->left = x_new; x_par->left = x_new;
} }
@ -639,7 +634,7 @@ stix_rbt_pair_t* stix_rbt_cbsert (
} }
else else
{ {
STIX_ASSERT (tmp.parent->right == x_cur); STIX_ASSERT (rbt->stix, tmp.parent->right == x_cur);
tmp.parent->right = x_new; tmp.parent->right = x_new;
} }
} }
@ -664,7 +659,7 @@ stix_rbt_pair_t* stix_rbt_cbsert (
if (x_par == STIX_NULL) if (x_par == STIX_NULL)
{ {
/* the tree contains no pair */ /* the tree contains no pair */
STIX_ASSERT (rbt->root == &rbt->xnil); STIX_ASSERT (rbt->stix, rbt->root == &rbt->xnil);
rbt->root = x_new; rbt->root = x_new;
} }
else 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)); int n = rbt->style->comper (rbt, kptr, klen, KPTR(x_par), KLEN(x_par));
if (n > 0) if (n > 0)
{ {
STIX_ASSERT (x_par->right == &rbt->xnil); STIX_ASSERT (rbt->stix, x_par->right == &rbt->xnil);
x_par->right = x_new; x_par->right = x_new;
} }
else else
{ {
STIX_ASSERT (x_par->left == &rbt->xnil); STIX_ASSERT (rbt->stix, x_par->left == &rbt->xnil);
x_par->left = x_new; 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 else
{ {
STIX_ASSERT (pair == par->right); STIX_ASSERT (rbt->stix, pair == par->right);
tmp = par->left; tmp = par->left;
if (tmp->color == STIX_RBT_RED) 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_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)) 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 else
{ {
/* both the left child and the right child have been traversed */ /* 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 */ /* just move up to the parent */
prev = x_cur; prev = x_cur;
x_cur = x_cur->parent; 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; 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 * 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 */ /* TODO: delete these header inclusion lines */
#include <string.h> #include <string.h>
#include <assert.h>
#if defined(__has_builtin) #if defined(__has_builtin)
# if __has_builtin(__builtin_memset) # if __has_builtin(__builtin_memset)
@ -101,8 +100,6 @@
# define STIX_MEMCMP(dst,src,size) memcmp(dst,src,size) # define STIX_MEMCMP(dst,src,size) memcmp(dst,src,size)
#endif #endif
#define STIX_ASSERT(x) assert(x)
#define STIX_ALIGN(x,y) ((((x) + (y) - 1) / (y)) * (y)) #define STIX_ALIGN(x,y) ((((x) + (y) - 1) / (y)) * (y))
@ -583,10 +580,13 @@ struct stix_compiler_t
} mth; } mth;
}; };
/*
typedef struct stix_bchbuf_t stix_bchbuf_t; typedef struct stix_bchbuf_t stix_bchbuf_t;
struct stix_bchbuf_t struct stix_bchbuf_t
{ {
stix_bch_t sbuf[128]; stix_bch_t buf[128];
stix_bch_t* ptr; stix_bch_t* ptr;
stix_oow_t capa; stix_oow_t capa;
}; };
@ -594,10 +594,11 @@ struct stix_bchbuf_t
typedef struct stix_oochbuf_t stix_oochbuf_t; typedef struct stix_oochbuf_t stix_oochbuf_t;
struct stix_oochbuf_t struct stix_oochbuf_t
{ {
stix_ooch_t sbuf[128]; stix_ooch_t buf[128];
stix_ooch_t* ptr; stix_ooch_t* ptr;
stix_oow_t capa; stix_oow_t capa;
}; };
*/
#endif #endif

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

@ -101,7 +101,7 @@ typedef enum stix_rbt_id_t stix_rbt_id_t;
typedef void* (*stix_rbt_copier_t) ( typedef void* (*stix_rbt_copier_t) (
stix_rbt_t* rbt /* red-black tree */, stix_rbt_t* rbt /* red-black tree */,
void* dptr /* pointer to a key or a value */, void* dptr /* pointer to a key or a value */,
stix_oow_t dlen /* length of a key or a value */ stix_oow_t dlen /* length of a key or a value */
); );
/** /**
@ -109,8 +109,8 @@ typedef void* (*stix_rbt_copier_t) (
*/ */
typedef void (*stix_rbt_freeer_t) ( typedef void (*stix_rbt_freeer_t) (
stix_rbt_t* rbt, /**< red-black tree */ stix_rbt_t* rbt, /**< red-black tree */
void* dptr, /**< pointer to a key or a value */ void* dptr, /**< pointer to a key or a value */
stix_oow_t dlen /**< length of a key or a value */ stix_oow_t dlen /**< length of a key or a value */
); );
/** /**
@ -234,11 +234,11 @@ typedef enum stix_rbt_style_kind_t stix_rbt_style_kind_t;
*/ */
struct stix_rbt_t struct stix_rbt_t
{ {
stix_mmgr_t* mmgr; stix_t* stix;
const stix_rbt_style_t* style; const stix_rbt_style_t* style;
stix_oob_t scale[2]; /**< length scale */ stix_oob_t scale[2]; /**< length scale */
stix_rbt_pair_t xnil; /**< internal nil node */ stix_rbt_pair_t xnil; /**< internal nil node */
stix_oow_t size; /**< number of pairs */ stix_oow_t size; /**< number of pairs */
stix_rbt_pair_t* root; /**< root pair */ stix_rbt_pair_t* root; /**< root pair */
}; };
@ -293,8 +293,8 @@ STIX_EXPORT const stix_rbt_style_t* stix_getrbtstyle (
* @return stix_rbt_t pointer on success, STIX_NULL on failure. * @return stix_rbt_t pointer on success, STIX_NULL on failure.
*/ */
STIX_EXPORT stix_rbt_t* stix_rbt_open ( 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 */ stix_oow_t xtnsize, /**< extension size in bytes */
int kscale, /**< key scale */ int kscale, /**< key scale */
int vscale /**< value scale */ int vscale /**< value scale */
); );
@ -311,7 +311,7 @@ STIX_EXPORT void stix_rbt_close (
*/ */
STIX_EXPORT int stix_rbt_init ( STIX_EXPORT int stix_rbt_init (
stix_rbt_t* rbt, /**< red-black tree */ stix_rbt_t* rbt, /**< red-black tree */
stix_mmgr_t* mmgr, /**< memory manager */ stix_t* stix,
int kscale, /**< key scale */ int kscale, /**< key scale */
int vscale /**< value scale */ int vscale /**< value scale */
); );
@ -323,10 +323,6 @@ STIX_EXPORT void stix_rbt_fini (
stix_rbt_t* rbt /**< red-black tree */ 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_EXPORT void* stix_rbt_getxtn (
stix_rbt_t* rbt 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; stix_t* stix;
/* if this assertion fails, correct the type definition in stix.h */ /* 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); stix = STIX_MMGR_ALLOC (mmgr, STIX_SIZEOF(*stix) + xtnsize);
if (stix) 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 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_MEMSET (stix, 0, STIX_SIZEOF(*stix));
stix->mmgr = mmgr; stix->mmgr = mmgr;
stix->cmgr = stix_getutf8cmgr (); 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); stix->newheap = stix_makeheap (stix, heapsz);
if (!stix->newheap) goto oops; 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)); stix_rbt_setstyle (&stix->modtab, stix_getrbtstyle(STIX_RBT_STYLE_INLINE_COPIERS));
fill_bigint_tables (stix); fill_bigint_tables (stix);
stix->tagged_classes[STIX_OOP_TAG_SMINT] = &stix->_small_integer; 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_CHAR] = &stix->_character;
stix->tagged_classes[STIX_OOP_TAG_RSRC] = &stix->_resource; stix->tagged_classes[STIX_OOP_TAG_ERROR] = &stix->_error_class;
return 0; return 0;
oops: oops:
if (modtab_inited) stix_rbt_fini (&stix->modtab);
if (stix->newheap) stix_killheap (stix, stix->newheap); if (stix->newheap) stix_killheap (stix, stix->newheap);
if (stix->curheap) stix_killheap (stix, stix->curheap); if (stix->curheap) stix_killheap (stix, stix->curheap);
if (stix->permheap) stix_killheap (stix, stix->permheap); 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; stix_mod_data_t* mdp;
mdp = STIX_RBT_VPTR(pair); 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() */ mdp->pair = STIX_NULL; /* to prevent stix_closemod() from calling stix_rbt_delete() */
stix_closemod (stix, mdp); stix_closemod (stix, mdp);
@ -166,14 +170,6 @@ void stix_fini (stix_t* stix)
stix_killheap (stix, stix->curheap); stix_killheap (stix, stix->curheap);
stix_killheap (stix, stix->permheap); 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 */ /* deregister all callbacks */
while (stix->cblist) stix_deregcb (stix, stix->cblist); 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 "stix_mod_"
#define MOD_PREFIX_LEN 9 #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); 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 */ /* 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; return mdp;
} }
@ -604,7 +541,7 @@ int stix_importmod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, st
if (pair) if (pair)
{ {
mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair); mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
STIX_ASSERT (mdp != STIX_NULL); STIX_ASSERT (stix, mdp != STIX_NULL);
} }
else else
{ {
@ -673,7 +610,7 @@ stix_pfimpl_t stix_querymod (stix_t* stix, const stix_ooch_t* pfid, stix_oow_t p
if (pair) if (pair)
{ {
mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair); mdp = (stix_mod_data_t*)STIX_RBT_VPTR(pair);
STIX_ASSERT (mdp != STIX_NULL); STIX_ASSERT (stix, mdp != STIX_NULL);
} }
else 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; stix_ooi_t preamble_flags = 0;
static stix_ooch_t dot[] = { '.', '\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; if (!pfname) pfname = mthname;
cls = (stix_oop_class_t)_class; cls = (stix_oop_class_t)_class;
stix_pushtmp (stix, (stix_oop_t*)&cls); tmp_count++; 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++) for (i = 0; mthname[i]; i++)
{ {
@ -808,3 +745,66 @@ oops:
return -1; 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
}

125
stix/lib/stix.h
View File

@ -51,8 +51,17 @@ enum stix_errnum_t
STIX_EINTERN, /**< internal error */ STIX_EINTERN, /**< internal error */
STIX_ESYSMEM, /**< insufficient system memory */ STIX_ESYSMEM, /**< insufficient system memory */
STIX_EOOMEM, /**< insufficient object memory */ STIX_EOOMEM, /**< insufficient object memory */
STIX_EINVAL, /**< invalid parameter or data */ STIX_EINVAL, /**< invalid parameter or data */
STIX_EEXIST, /**< existing/duplicate 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_ETOOBIG, /**< data too large */
STIX_EMSGSND, /**< message sending error. even doesNotUnderstand: is not found */ STIX_EMSGSND, /**< message sending error. even doesNotUnderstand: is not found */
STIX_ERANGE, /**< range error. overflow and underflow */ 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_BITS 2
#define STIX_OOP_TAG_SMINT 1 #define STIX_OOP_TAG_SMINT 1
#define STIX_OOP_TAG_CHAR 2 #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_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) #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_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_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_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_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_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) #define STIX_OOP_TO_CHAR(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))
/* RSRC(resurce) is a index to the VM's resource table(stix->rsrc.ptr) */ #define STIX_OOP_TO_ERROR(oop) (((stix_oow_t)oop) >> STIX_OOP_TAG_BITS)
#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)
/* SMOOI takes up 62 bits on a 64-bit architecture and 30 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 * 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 * The STIX_CLASSOF() macro return the class of an object including a numeric
* object encoded into a pointer. * 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) \ #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 * 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 */ stix_uint8_t* ptr; /* next allocation pointer */
}; };
typedef struct stix_t stix_t;
/* ========================================================================= /* =========================================================================
* VIRTUAL MACHINE PRIMITIVES * VIRTUAL MACHINE PRIMITIVES
* ========================================================================= */ * ========================================================================= */
@ -788,11 +787,13 @@ struct stix_mod_data_t
}; };
typedef struct stix_mod_data_t stix_mod_data_t; typedef struct stix_mod_data_t stix_mod_data_t;
struct stix_sbuf_t struct stix_sbuf_t
{ {
stix_ooch_t* ptr; stix_ooch_t* ptr;
stix_oow_t len; stix_oow_t len;
stix_oow_t capa; stix_oow_t capa;
}; };
typedef struct stix_sbuf_t stix_sbuf_t; typedef struct stix_sbuf_t stix_sbuf_t;
@ -837,13 +838,18 @@ struct stix_t
stix_heap_t* curheap; stix_heap_t* curheap;
stix_heap_t* newheap; stix_heap_t* newheap;
/* ========================= */ /* =============================================================
* nil, true, false
* ============================================================= */
stix_oop_t _nil; /* pointer to the nil object */ stix_oop_t _nil; /* pointer to the nil object */
stix_oop_t _true; stix_oop_t _true;
stix_oop_t _false; 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 _apex; /* Apex */
stix_oop_t _undefined_object; /* UndefinedObject */ stix_oop_t _undefined_object; /* UndefinedObject */
stix_oop_t _class; /* Class */ stix_oop_t _class; /* Class */
@ -867,17 +873,22 @@ struct stix_t
stix_oop_t _process; /* Process */ stix_oop_t _process; /* Process */
stix_oop_t _semaphore; /* Semaphore */ stix_oop_t _semaphore; /* Semaphore */
stix_oop_t _process_scheduler; /* ProcessScheduler */ stix_oop_t _process_scheduler; /* ProcessScheduler */
stix_oop_t _error_class; /* Error */
stix_oop_t _true_class; /* True */ stix_oop_t _true_class; /* True */
stix_oop_t _false_class; /* False */ stix_oop_t _false_class; /* False */
stix_oop_t _character; /* Character */ stix_oop_t _character; /* Character */
stix_oop_t _small_integer; /* SmallInteger */ stix_oop_t _small_integer; /* SmallInteger */
stix_oop_t _large_positive_integer; /* LargePositiveInteger */ stix_oop_t _large_positive_integer; /* LargePositiveInteger */
stix_oop_t _large_negative_integer; /* LargeNegativeInteger */ 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_t* tagged_classes[4];
stix_oop_set_t symtab; /* system-wide symbol table. instance of SymbolSet */ stix_oop_set_t symtab; /* system-wide symbol table. instance of SymbolSet */
stix_oop_set_t sysdic; /* system dictionary. instance of SystemDictionary */ 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_oop_t* tmp_stack[256]; /* stack for temporaries */
stix_oow_t tmp_count; stix_oow_t tmp_count;
/* == EXECUTION REGISTERS == */ /* =============================================================
* EXECUTION REGISTERS
* ============================================================= */
stix_oop_context_t initial_context; /* fake initial context */ stix_oop_context_t initial_context; /* fake initial context */
stix_oop_context_t active_context; stix_oop_context_t active_context;
stix_oop_method_t active_method; 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 proc_switched; /* TODO: this is temporary. implement something else to skip immediate context switching */
int switch_proc; int switch_proc;
stix_ntime_t vm_time_offset; stix_ntime_t vm_time_offset;
/* == END EXECUTION REGISTERS == */ /* =============================================================
* END EXECUTION REGISTERS
* ============================================================= */
/* == BIGINT CONVERSION == */ /* == BIGINT CONVERSION == */
struct struct
@ -917,15 +932,6 @@ struct stix_t
} bigint[37]; } bigint[37];
/* == END BIGINT CONVERSION == */ /* == 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]; stix_sbuf_t sbuf[64];
#if defined(STIX_INCLUDE_COMPILER) #if defined(STIX_INCLUDE_COMPILER)
@ -958,7 +964,7 @@ struct stix_t
* also you must not call this macro more than once */ * 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_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_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 * STIX VM LOGGING
@ -1010,15 +1016,13 @@ typedef enum stix_log_mask_t stix_log_mask_t;
/* ========================================================================= /* =========================================================================
* STIX ASSERTION * STIX ASSERTION
* ========================================================================= */ * ========================================================================= */
#if 0
#if defined(NDEBUG) #if defined(NDEBUG)
# define STIX_ASSERT(expr) ((void)0) # define STIX_ASSERT(stix,expr) ((void)0)
#else #else
# define STIX_ASSERT(expr) (void)((expr) || \ # define STIX_ASSERT(stix,expr) ((void)((expr) || (stix_assertfailed (stix, #expr, __FILE__, __LINE__), 0)))
(stix_logbfmt ("%s at %s:%d", #expr, __FILE__, (int)__LINE__), 0))
#endif
#endif #endif
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#endif #endif
@ -1181,28 +1185,23 @@ STIX_EXPORT void stix_poptmps (
stix_oow_t count stix_oow_t count
); );
STIX_EXPORT int stix_decode ( /* =========================================================================
stix_t* stix, * SYSTEM MEMORY MANAGEMENT FUCNTIONS VIA MMGR
stix_oop_method_t mth, * ========================================================================= */
const stix_oocs_t* classfqn
);
/* Memory allocation/deallocation functions using stix's MMGR */
STIX_EXPORT void* stix_allocmem ( STIX_EXPORT void* stix_allocmem (
stix_t* stix, stix_t* stix,
stix_oow_t size stix_oow_t size
); );
STIX_EXPORT void* stix_callocmem ( STIX_EXPORT void* stix_callocmem (
stix_t* stix, stix_t* stix,
stix_oow_t size stix_oow_t size
); );
STIX_EXPORT void* stix_reallocmem ( STIX_EXPORT void* stix_reallocmem (
stix_t* stix, stix_t* stix,
void* ptr, void* ptr,
stix_oow_t size stix_oow_t size
); );
STIX_EXPORT void stix_freemem ( STIX_EXPORT void stix_freemem (
@ -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) #if defined(__cplusplus)
} }
#endif #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]; symbol = (stix_oop_char_t)oldbuc->slot[--oldsz];
if ((stix_oop_t)symbol != stix->_nil) if ((stix_oop_t)symbol != stix->_nil)
{ {
STIX_ASSERT (STIX_CLASSOF(stix,symbol) == stix->_symbol); STIX_ASSERT (stix, STIX_CLASSOF(stix,symbol) == stix->_symbol);
/*STIX_ASSERT (sym->size > 0);*/ /*STIX_ASSERT (stix, sym->size > 0);*/
index = stix_hashchars(symbol->slot, STIX_OBJ_GET_SIZE(symbol)) % newsz; index = stix_hashchars(symbol->slot, STIX_OBJ_GET_SIZE(symbol)) % newsz;
while (newbuc->slot[index] != stix->_nil) index = (index + 1) % 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_oow_t index;
stix_oop_char_t symbol; stix_oop_char_t symbol;
STIX_ASSERT (len > 0); STIX_ASSERT (stix, len > 0);
if (len <= 0) if (len <= 0)
{ {
/* i don't allow an empty symbol name */ /* 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; 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); index = stix_hashchars(ptr, len) % STIX_OBJ_GET_SIZE(stix->symtab->bucket);
/* find a matching symbol in the open-addressed symbol table */ /* find a matching symbol in the open-addressed symbol table */
while (stix->symtab->bucket->slot[index] != stix->_nil) while (stix->symtab->bucket->slot[index] != stix->_nil)
{ {
symbol = (stix_oop_char_t)stix->symtab->bucket->slot[index]; 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) && if (len == STIX_OBJ_GET_SIZE(symbol) &&
stix_equaloochars (ptr, symbol->slot, len)) 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 */ /* 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); tally = STIX_OOP_TO_SMOOI(stix->symtab->tally);
if (tally >= STIX_SMOOI_MAX) 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); symbol = (stix_oop_char_t)stix_instantiate(stix, stix->_symbol, ptr, len);
if (symbol) 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->tally = STIX_SMOOI_TO_OOP(tally + 1);
stix->symtab->bucket->slot[index] = (stix_oop_t)symbol; 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; __utf8_t* cur, * end;
STIX_ASSERT (STIX_SIZEOF(stix_bch_t) == 1); /*STIX_ASSERT (stix, STIX_SIZEOF(stix_bch_t) == 1);
STIX_ASSERT (STIX_SIZEOF(stix_uch_t) >= 2); STIX_ASSERT (stix, STIX_SIZEOF(stix_uch_t) >= 2);*/
end = utf8_table + STIX_COUNTOF(utf8_table); end = utf8_table + STIX_COUNTOF(utf8_table);
cur = 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; __utf8_t* cur, * end;
STIX_ASSERT (utf8 != STIX_NULL); /*STIX_ASSERT (stix, utf8 != STIX_NULL);
STIX_ASSERT (size > 0); STIX_ASSERT (stix, size > 0);
STIX_ASSERT (STIX_SIZEOF(stix_bch_t) == 1); STIX_ASSERT (stix, STIX_SIZEOF(stix_bch_t) == 1);
STIX_ASSERT (STIX_SIZEOF(stix_uch_t) >= 2); STIX_ASSERT (stix, STIX_SIZEOF(stix_uch_t) >= 2);*/
end = utf8_table + STIX_COUNTOF(utf8_table); end = utf8_table + STIX_COUNTOF(utf8_table);
cur = 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 */ 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 ( 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 */ /* 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; 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 */ /* 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; 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); 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 */ /* error */
} }
rsrc = stix_makersrc (stix, h);
#else #else

12
stix/mod/stdio.c
View File

@ -29,12 +29,9 @@
#include <stix-utl.h> #include <stix-utl.h>
#include <stdio.h> #include <stdio.h>
#include <errno.h>
#include <limits.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; typedef struct stdio_t stdio_t;
struct stdio_t struct stdio_t
{ {
@ -84,7 +81,8 @@ static int pf_open (stix_t* stix, stix_ooi_t nargs)
if (!rcv->fp) if (!rcv->fp)
{ {
STIX_DEBUG2 (stix, "cannot open %s for %s\n", namebuf, modebuf); 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); 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; stdio_t* rcv;
stix_ooi_t i; stix_ooi_t i;
rcv = (stdio_t*)STIX_STACK_GETRCV(stix, nargs); rcv = (stdio_t*)STIX_STACK_GETRCV(stix, nargs);
for (i = 0; i < nargs; i++) 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)) if (STIX_OOP_IS_CHAR(x))
{ {
/* do some faking. */ /* 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); tmpc.slot[0] = STIX_OOP_TO_CHAR(x);
x = (stix_oop_char_t)&tmpc; x = (stix_oop_char_t)&tmpc;