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

added stix_isint(), stix_inttooow(), stix_oowtoint().

Browse Source 
added stix_eqints(), stix_neints(), stix_gtints(), stix_geints(), stix_ltints(), stix_leints().
enhanced some primitive handlers to support large integers
This commit is contained in:
hyunghwan.chung 2015-12-27 18:02:59 +00:00
parent fff2af4762
commit c427f39a12
9 changed files with 627 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
stix/kernel/Apex.st
View File

@ -43,6 +43,18 @@
self primitiveFailed. self primitiveFailed.
} }
#method(#class) ngcNew
{
<primitive: #_ngc_new>
self primitiveFailed.
}
#method(#class) ngcNew: anInteger
{
<primitive: #_ngc_new_with_size>
self primitiveFailed.
}
#method(#class) new #method(#class) new
{ {
| x | | x |
@ -66,6 +78,11 @@
^self. ^self.
} }
#method ngcDispose
{
<primitive: #_ngc_dispose>
self primitiveFailed.
}
## ------------------------------------------------------- ## -------------------------------------------------------
## ------------------------------------------------------- ## -------------------------------------------------------
#method shallowCopy #method shallowCopy

13
stix/kernel/Stix.st
View File

@ -186,6 +186,19 @@
{ {
^self to: end by: 1 do: aBlock. ^self to: end by: 1 do: aBlock.
} }
#method abs
{
self < 0 ifTrue: [^self negated].
^self.
}
#method sign
{
self < 0 ifTrue: [^-1].
self > 0 ifTrue: [^1].
^0.
}
} }
#class SmallInteger(Number) #class SmallInteger(Number)

1
stix/kernel/test-005.st
View File

@ -407,6 +407,7 @@ PROCESS TESTING
##self a: 1 b: 2 c: 3 d: 4 e: 5 f: 6 g: 7. ##self a: 1 b: 2 c: 3 d: 4 e: 5 f: 6 g: 7.
##self a: 1 b: 2 c: 3. ##self a: 1 b: 2 c: 3.
" "
FFI isNil dump. FFI isNil dump.
FFI notNil dump. FFI notNil dump.

398
stix/lib/bigint.c
View File

@ -192,47 +192,34 @@ static int is_normalized_integer (stix_t* stix, stix_oop_t oop)
return 0; return 0;
} }
static STIX_INLINE int is_integer (stix_t* stix, stix_oop_t oop) STIX_INLINE int is_bigint (stix_t* stix, stix_oop_t x)
{ {
if (STIX_OOP_IS_SMOOI(oop)) return 1; stix_oop_t c;
if (STIX_OOP_IS_POINTER(oop))
{ STIX_ASSERT (STIX_OOP_IS_POINTER(x));
stix_oop_t c;
/* 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? */
c = STIX_OBJ_GET_CLASS(oop); c = STIX_OBJ_GET_CLASS(x);
if (c == stix->_large_positive_integer || if (c == stix->_large_positive_integer ||
c == stix->_large_negative_integer) return 1; c == stix->_large_negative_integer) return 1;
}
return 0; return 0;
} }
static STIX_INLINE int integer_to_oow (stix_t* stix, stix_oop_t num, stix_oow_t* w) STIX_INLINE int stix_isint (stix_t* stix, stix_oop_t x)
{ {
/* return value if (STIX_OOP_IS_SMOOI(x)) return 1;
* 1 - a positive number including 0 that can fit into stix_oow_t if (STIX_OOP_IS_POINTER(x)) return is_bigint(stix, x);
* -1 - a negative number whose absolute value can fit into stix_oow_t return 0;
* 0 - number too large or too small }
*/
if (STIX_OOP_IS_SMOOI(num)) static STIX_INLINE int bigint_to_oow (stix_t* stix, stix_oop_t num, stix_oow_t* w)
{ {
stix_ooi_t v; STIX_ASSERT (STIX_OOP_IS_POINTER(num));
STIX_ASSERT (STIX_OBJ_GET_CLASS(num) == stix->_large_positive_integer ||
v = STIX_OOP_TO_SMOOI(num); STIX_OBJ_GET_CLASS(num) == stix->_large_negative_integer);
if (v < 0)
{
*w = -v;
return -1;
}
else
{
*w = v;
return 1;
}
}
#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_OBJ_GET_SIZE(num) >= 1);
@ -261,6 +248,74 @@ static STIX_INLINE int integer_to_oow (stix_t* stix, stix_oop_t num, stix_oow_t*
return 0; /* not convertable */ return 0; /* not convertable */
} }
static STIX_INLINE int integer_to_oow (stix_t* stix, stix_oop_t x, stix_oow_t* w)
{
/* return value
* 1 - a positive number including 0 that can fit into stix_oow_t
* -1 - a negative number whose absolute value can fit into stix_oow_t
* 0 - number too large or too small
*/
if (STIX_OOP_IS_SMOOI(x))
{
stix_ooi_t v;
v = STIX_OOP_TO_SMOOI(x);
if (v < 0)
{
*w = -v;
return -1;
}
else
{
*w = v;
return 1;
}
}
STIX_ASSERT (is_bigint(stix, x));
return bigint_to_oow (stix, x, w);
}
int stix_inttooow (stix_t* stix, stix_oop_t x, stix_oow_t* w)
{
if (STIX_OOP_IS_SMOOI(x))
{
stix_ooi_t v;
v = STIX_OOP_TO_SMOOI(x);
if (v < 0)
{
*w = -v;
return -1;
}
else
{
*w = v;
return 1;
}
}
if (is_bigint(stix, x)) return bigint_to_oow (stix, x, w);
return 0; /* not convertable - too big, too small, or not an integer */
}
static STIX_INLINE stix_oop_t make_bigint_with_oow (stix_t* stix, stix_oow_t w)
{
#if (STIX_LIW_BITS == STIX_OOW_BITS)
STIX_ASSERT (STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_liw_t));
return stix_instantiate (stix, stix->_large_positive_integer, &w, 1);
#elif (STIX_LIW_BITS == STIX_OOHW_BITS)
stix_liw_t hw[2];
hw[0] = w /*& STIX_LBMASK(stix_oow_t,STIX_LIW_BITS)*/;
hw[1] = w >> STIX_LIW_BITS;
return stix_instantiate (stix, stix->_large_positive_integer, &hw, (hw[1] > 0? 2: 1));
#else
# error UNSUPPORTED LIW BIT SIZE
#endif
}
static STIX_INLINE stix_oop_t make_bigint_with_ooi (stix_t* stix, stix_ooi_t i) 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)
@ -382,6 +437,18 @@ static STIX_INLINE stix_oop_t make_bigint_with_intmax (stix_t* stix, stix_intmax
return stix_instantiate (stix, ((v >= 0)? stix->_large_positive_integer: stix->_large_negative_integer), buf, len); return stix_instantiate (stix, ((v >= 0)? stix->_large_positive_integer: stix->_large_negative_integer), buf, len);
} }
stix_oop_t stix_oowtoint (stix_t* stix, stix_oow_t w)
{
if (STIX_IN_SMOOI_RANGE(w))
{
return STIX_SMOOI_TO_OOP(w);
}
else
{
return make_bigint_with_oow(stix, w);
}
}
static STIX_INLINE stix_oop_t expand_bigint (stix_t* stix, stix_oop_t oop, stix_oow_t inc) static STIX_INLINE stix_oop_t expand_bigint (stix_t* stix, stix_oop_t oop, stix_oow_t inc)
{ {
stix_oop_t z; stix_oop_t z;
@ -579,7 +646,52 @@ static STIX_INLINE int is_less (stix_t* stix, stix_oop_t x, stix_oop_t y)
return STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer; return STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer;
} }
return is_less_unsigned (x, y); if (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer)
{
return is_less_unsigned (x, y);
}
else
{
return is_less_unsigned (y, x);
}
}
static STIX_INLINE int is_greater_unsigned_array (const stix_liw_t* x, stix_oow_t xs, const stix_liw_t* y, stix_oow_t ys)
{
stix_oow_t i;
if (xs != ys) return xs > ys;
for (i = xs; i > 0; )
{
--i;
if (x[i] != y[i]) return x[i] > y[i];
}
return 0;
}
static STIX_INLINE int is_greater_unsigned (stix_oop_t x, stix_oop_t y)
{
return is_greater_unsigned_array (
((stix_oop_liword_t)x)->slot, STIX_OBJ_GET_SIZE(x),
((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y));
}
static STIX_INLINE int is_greater (stix_t* stix, stix_oop_t x, stix_oop_t y)
{
if (STIX_OBJ_GET_CLASS(x) != STIX_OBJ_GET_CLASS(y))
{
return STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer;
}
if (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer)
{
return is_greater_unsigned (x, y);
}
else
{
return is_greater_unsigned (y, x);
}
} }
static STIX_INLINE int is_equal (stix_t* stix, stix_oop_t x, stix_oop_t y) static STIX_INLINE int is_equal (stix_t* stix, stix_oop_t x, stix_oop_t y)
@ -1042,7 +1154,7 @@ stix_oop_t stix_addints (stix_t* stix, stix_oop_t x, stix_oop_t y)
if (STIX_OOP_IS_SMOOI(x)) if (STIX_OOP_IS_SMOOI(x))
{ {
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
if (v == 0) return clone_bigint (stix, y, STIX_OBJ_GET_SIZE(y)); if (v == 0) return clone_bigint (stix, y, STIX_OBJ_GET_SIZE(y));
@ -1054,7 +1166,7 @@ stix_oop_t stix_addints (stix_t* stix, stix_oop_t x, stix_oop_t y)
} }
else if (STIX_OOP_IS_SMOOI(y)) else if (STIX_OOP_IS_SMOOI(y))
{ {
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
if (v == 0) return clone_bigint (stix, x, STIX_OBJ_GET_SIZE(x)); if (v == 0) return clone_bigint (stix, x, STIX_OBJ_GET_SIZE(x));
@ -1066,8 +1178,8 @@ stix_oop_t stix_addints (stix_t* stix, stix_oop_t x, stix_oop_t y)
} }
else else
{ {
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
} }
if (STIX_OBJ_GET_CLASS(x) != STIX_OBJ_GET_CLASS(y)) if (STIX_OBJ_GET_CLASS(x) != STIX_OBJ_GET_CLASS(y))
@ -1146,7 +1258,7 @@ stix_oop_t stix_subints (stix_t* stix, stix_oop_t x, stix_oop_t y)
if (STIX_OOP_IS_SMOOI(x)) if (STIX_OOP_IS_SMOOI(x))
{ {
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
if (v == 0) if (v == 0)
@ -1162,7 +1274,7 @@ stix_oop_t stix_subints (stix_t* stix, stix_oop_t x, stix_oop_t y)
} }
else if (STIX_OOP_IS_SMOOI(y)) else if (STIX_OOP_IS_SMOOI(y))
{ {
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
if (v == 0) return clone_bigint (stix, x, STIX_OBJ_GET_SIZE(x)); if (v == 0) return clone_bigint (stix, x, STIX_OBJ_GET_SIZE(x));
@ -1174,8 +1286,8 @@ stix_oop_t stix_subints (stix_t* stix, stix_oop_t x, stix_oop_t y)
} }
else else
{ {
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
} }
if (STIX_OBJ_GET_CLASS(x) != STIX_OBJ_GET_CLASS(y)) if (STIX_OBJ_GET_CLASS(x) != STIX_OBJ_GET_CLASS(y))
@ -1258,7 +1370,7 @@ stix_oop_t stix_mulints (stix_t* stix, stix_oop_t x, stix_oop_t y)
if (STIX_OOP_IS_SMOOI(x)) if (STIX_OOP_IS_SMOOI(x))
{ {
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
switch (v) switch (v)
@ -1278,7 +1390,7 @@ stix_oop_t stix_mulints (stix_t* stix, stix_oop_t x, stix_oop_t y)
} }
else if (STIX_OOP_IS_SMOOI(y)) else if (STIX_OOP_IS_SMOOI(y))
{ {
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
switch (v) switch (v)
@ -1298,8 +1410,8 @@ stix_oop_t stix_mulints (stix_t* stix, stix_oop_t x, stix_oop_t y)
} }
else else
{ {
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
} }
normal: normal:
@ -1427,7 +1539,7 @@ stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, s
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
if (v == 0) if (v == 0)
@ -1445,7 +1557,7 @@ stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, s
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
switch (v) switch (v)
@ -1488,8 +1600,8 @@ stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, s
} }
else else
{ {
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
} }
} }
@ -1579,7 +1691,7 @@ stix_oop_t stix_negateint (stix_t* stix, stix_oop_t x)
} }
else else
{ {
if (!is_integer(stix, x)) goto oops_einval; if (!is_bigint(stix, x)) goto oops_einval;
return clone_bigint_negated (stix, x, STIX_OBJ_GET_SIZE(x)); return clone_bigint_negated (stix, x, STIX_OBJ_GET_SIZE(x));
} }
@ -1614,7 +1726,7 @@ stix_oop_t stix_bitatint (stix_t* stix, stix_oop_t x, stix_oop_t y)
} }
else if (STIX_OOP_IS_SMOOI(x)) else if (STIX_OOP_IS_SMOOI(x))
{ {
if (!is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix, y)) goto oops_einval;
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);
/* y is definitely >= STIX_SMOOI_BITS */ /* y is definitely >= STIX_SMOOI_BITS */
@ -1628,7 +1740,7 @@ stix_oop_t stix_bitatint (stix_t* stix, stix_oop_t x, stix_oop_t y)
stix_ooi_t v; stix_ooi_t v;
stix_oow_t wp, bp, xs; stix_oow_t wp, bp, xs;
if (!is_integer(stix, x)) goto oops_einval; if (!is_bigint(stix, x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
if (v <= 0) return STIX_SMOOI_TO_OOP(0); if (v <= 0) return STIX_SMOOI_TO_OOP(0);
@ -1669,7 +1781,7 @@ stix_oop_t stix_bitatint (stix_t* stix, stix_oop_t x, stix_oop_t y)
int sign; int sign;
#endif #endif
if (!is_integer(stix, x) || !is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix, x) || !is_bigint(stix, y)) goto oops_einval;
#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);
@ -1688,7 +1800,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 = integer_to_oow (stix, y, &w); sign = bigint_to_oow (stix, y, &w);
STIX_ASSERT (sign >= 0); STIX_ASSERT (sign >= 0);
if (sign >= 1) if (sign >= 1)
{ {
@ -1772,7 +1884,7 @@ stix_oop_t stix_bitandints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix, y)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
if (v == 0) return STIX_SMOOI_TO_OOP(0); if (v == 0) return STIX_SMOOI_TO_OOP(0);
@ -1788,7 +1900,7 @@ stix_oop_t stix_bitandints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix, x)) goto oops_einval; if (!is_bigint(stix, x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
if (v == 0) return STIX_SMOOI_TO_OOP(0); if (v == 0) return STIX_SMOOI_TO_OOP(0);
@ -1806,7 +1918,7 @@ stix_oop_t stix_bitandints (stix_t* stix, stix_oop_t x, stix_oop_t y)
stix_oow_t i, xs, ys, zs, zalloc; stix_oow_t i, xs, ys, zs, zalloc;
int negx, negy; int negx, negy;
if (!is_integer(stix,x) || !is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix,x) || !is_bigint(stix, y)) goto oops_einval;
bigint_and_bigint: bigint_and_bigint:
xs = STIX_OBJ_GET_SIZE(x); xs = STIX_OBJ_GET_SIZE(x);
@ -1985,7 +2097,7 @@ stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix, y)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
if (v == 0) return clone_bigint(stix, y, STIX_OBJ_GET_SIZE(y)); if (v == 0) return clone_bigint(stix, y, STIX_OBJ_GET_SIZE(y));
@ -2001,7 +2113,7 @@ stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix, x)) goto oops_einval; if (!is_bigint(stix, x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
if (v == 0) return clone_bigint(stix, x, STIX_OBJ_GET_SIZE(x)); if (v == 0) return clone_bigint(stix, x, STIX_OBJ_GET_SIZE(x));
@ -2019,7 +2131,7 @@ stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
stix_oow_t i, xs, ys, zs, zalloc; stix_oow_t i, xs, ys, zs, zalloc;
int negx, negy; int negx, negy;
if (!is_integer(stix,x) || !is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix,x) || !is_bigint(stix, y)) goto oops_einval;
bigint_and_bigint: bigint_and_bigint:
xs = STIX_OBJ_GET_SIZE(x); xs = STIX_OBJ_GET_SIZE(x);
@ -2203,7 +2315,7 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix, y)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
if (v == 0) return clone_bigint(stix, y, STIX_OBJ_GET_SIZE(y)); if (v == 0) return clone_bigint(stix, y, STIX_OBJ_GET_SIZE(y));
@ -2219,7 +2331,7 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix, x)) goto oops_einval; if (!is_bigint(stix, x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
if (v == 0) return clone_bigint(stix, x, STIX_OBJ_GET_SIZE(x)); if (v == 0) return clone_bigint(stix, x, STIX_OBJ_GET_SIZE(x));
@ -2237,7 +2349,7 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y)
stix_oow_t i, xs, ys, zs, zalloc; stix_oow_t i, xs, ys, zs, zalloc;
int negx, negy; int negx, negy;
if (!is_integer(stix,x) || !is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix,x) || !is_bigint(stix, y)) goto oops_einval;
bigint_and_bigint: bigint_and_bigint:
xs = STIX_OBJ_GET_SIZE(x); xs = STIX_OBJ_GET_SIZE(x);
@ -2421,7 +2533,7 @@ stix_oop_t stix_bitinvint (stix_t* stix, stix_oop_t x)
stix_oow_t i, xs, zs, zalloc; stix_oow_t i, xs, zs, zalloc;
int negx; int negx;
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
xs = STIX_OBJ_GET_SIZE(x); xs = STIX_OBJ_GET_SIZE(x);
negx = (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? 1: 0; negx = (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? 1: 0;
@ -2842,7 +2954,7 @@ stix_oop_t stix_bitshiftint (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix,y)) goto oops_einval; if (!is_bigint(stix,y)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(x); v = STIX_OOP_TO_SMOOI(x);
if (v == 0) return STIX_SMOOI_TO_OOP(0); if (v == 0) return STIX_SMOOI_TO_OOP(0);
@ -2867,7 +2979,7 @@ stix_oop_t stix_bitshiftint (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_ooi_t v; stix_ooi_t v;
if (!is_integer(stix,x)) goto oops_einval; if (!is_bigint(stix,x)) goto oops_einval;
v = STIX_OOP_TO_SMOOI(y); v = STIX_OOP_TO_SMOOI(y);
if (v == 0) return clone_bigint (stix, x, STIX_OBJ_GET_SIZE(x)); if (v == 0) return clone_bigint (stix, x, STIX_OBJ_GET_SIZE(x));
@ -2892,13 +3004,13 @@ stix_oop_t stix_bitshiftint (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
stix_oop_t z; stix_oop_t z;
if (!is_integer(stix,x) || !is_integer(stix, y)) goto oops_einval; if (!is_bigint(stix,x) || !is_bigint(stix, y)) goto oops_einval;
bigint_and_bigint: bigint_and_bigint:
negx = (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? 1: 0; negx = (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? 1: 0;
negy = (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer)? 1: 0; negy = (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer)? 1: 0;
sign = integer_to_oow (stix, y, &shift); sign = bigint_to_oow (stix, y, &shift);
if (sign == 0) if (sign == 0)
{ {
/* y is too big or too small */ /* y is too big or too small */
@ -3249,6 +3361,156 @@ static void reverse_string (stix_ooch_t* str, stix_oow_t len)
} }
} }
stix_oop_t stix_eqints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{
if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y))
{
return (STIX_OOP_TO_SMOOI(x) == STIX_OOP_TO_SMOOI(y))? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(x) || STIX_OOP_IS_SMOOI(y))
{
return stix->_false;
}
else
{
if (!is_bigint(stix, x) || !is_bigint(stix, y)) goto oops_einval;
return is_equal(stix, x, y)? stix->_true: stix->_false;
}
oops_einval:
stix->errnum = STIX_EINVAL;
return STIX_NULL;
}
stix_oop_t stix_neints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{
if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y))
{
return (STIX_OOP_TO_SMOOI(x) != STIX_OOP_TO_SMOOI(y))? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(x) || STIX_OOP_IS_SMOOI(y))
{
return stix->_true;
}
else
{
if (!is_bigint(stix, x) || !is_bigint(stix, y)) goto oops_einval;
return !is_equal(stix, x, y)? stix->_true: stix->_false;
}
oops_einval:
stix->errnum = STIX_EINVAL;
return STIX_NULL;
}
stix_oop_t stix_gtints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{
if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y))
{
return (STIX_OOP_TO_SMOOI(x) > STIX_OOP_TO_SMOOI(y))? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(x))
{
if (!is_bigint(stix, y)) goto oops_einval;
return (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer)? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(y))
{
if (!is_bigint(stix, x)) goto oops_einval;
return (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer)? stix->_true: stix->_false;
}
else
{
if (!is_bigint(stix, x) || !is_bigint(stix, y)) goto oops_einval;
return is_greater(stix, x, y)? stix->_true: stix->_false;
}
oops_einval:
stix->errnum = STIX_EINVAL;
return STIX_NULL;
}
stix_oop_t stix_geints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{
if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y))
{
return (STIX_OOP_TO_SMOOI(x) >= STIX_OOP_TO_SMOOI(y))? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(x))
{
if (!is_bigint(stix, y)) goto oops_einval;
return (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer)? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(y))
{
if (!is_bigint(stix, x)) goto oops_einval;
return (STIX_OBJ_GET_CLASS(x) == stix->_large_positive_integer)? stix->_true: stix->_false;
}
else
{
if (!is_bigint(stix, x) || !is_bigint(stix, y)) goto oops_einval;
return (is_greater(stix, x, y) || is_equal(stix, x, y))? stix->_true: stix->_false;
}
oops_einval:
stix->errnum = STIX_EINVAL;
return STIX_NULL;
}
stix_oop_t stix_ltints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{
if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y))
{
return (STIX_OOP_TO_SMOOI(x) < STIX_OOP_TO_SMOOI(y))? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(x))
{
if (!is_bigint(stix, y)) goto oops_einval;
return (STIX_OBJ_GET_CLASS(y) == stix->_large_positive_integer)? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(y))
{
if (!is_bigint(stix, x)) goto oops_einval;
return (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? stix->_true: stix->_false;
}
else
{
if (!is_bigint(stix, x) || !is_bigint(stix, y)) goto oops_einval;
return is_less(stix, x, y)? stix->_true: stix->_false;
}
oops_einval:
stix->errnum = STIX_EINVAL;
return STIX_NULL;
}
stix_oop_t stix_leints (stix_t* stix, stix_oop_t x, stix_oop_t y)
{
if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y))
{
return (STIX_OOP_TO_SMOOI(x) <= STIX_OOP_TO_SMOOI(y))? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(x))
{
if (!is_bigint(stix, y)) goto oops_einval;
return (STIX_OBJ_GET_CLASS(y) == stix->_large_positive_integer)? stix->_true: stix->_false;
}
else if (STIX_OOP_IS_SMOOI(y))
{
if (!is_bigint(stix, x)) goto oops_einval;
return (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? stix->_true: stix->_false;
}
else
{
if (!is_bigint(stix, x) || !is_bigint(stix, y)) goto oops_einval;
return (is_less(stix, x, y) || is_equal(stix, x, y))? stix->_true: stix->_false;
}
oops_einval:
stix->errnum = STIX_EINVAL;
return STIX_NULL;
}
stix_oop_t stix_inttostr (stix_t* stix, stix_oop_t num, int radix) stix_oop_t stix_inttostr (stix_t* stix, stix_oop_t num, int radix)
{ {
stix_ooi_t v = 0; stix_ooi_t v = 0;
@ -3269,7 +3531,7 @@ stix_oop_t stix_inttostr (stix_t* stix, stix_oop_t num, int radix)
STIX_ASSERT (radix >= 2 && radix <= 36); STIX_ASSERT (radix >= 2 && radix <= 36);
if (!is_integer(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);
if (v) if (v)

225
stix/lib/exec.c
View File

@ -650,14 +650,9 @@ static int prim_basic_new_with_size (stix_t* stix, stix_ooi_t nargs)
} }
szoop = ACTIVE_STACK_GET(stix, stix->sp); szoop = ACTIVE_STACK_GET(stix, stix->sp);
if (STIX_OOP_IS_SMOOI(szoop)) if (stix_inttooow (stix, szoop, &size) <= 0)
{ {
size = STIX_OOP_TO_SMOOI(szoop); /* integer out of range or not integer */
}
/* TODO: support LargeInteger */
else
{
/* size is not a proper numeric object */
return 0; return 0;
} }
@ -679,6 +674,40 @@ static int prim_basic_new_with_size (stix_t* stix, stix_ooi_t nargs)
return 1; /* success */ return 1; /* success */
} }
static int prim_ngc_new (stix_t* stix, stix_ooi_t nargs)
{
int n;
n = prim_basic_new (stix, nargs);
if (n <= 0) return n;
return 1;
}
static int prim_ngc_new_with_size (stix_t* stix, stix_ooi_t nargs)
{
int n;
n = prim_basic_new_with_size (stix, nargs);
if (n <= 0) return n;
return 1;
}
static int prim_ngc_dispose (stix_t* stix, stix_ooi_t nargs)
{
stix_oop_t rcv;
STIX_ASSERT (nargs == 0);
rcv = ACTIVE_STACK_GETTOP (stix);
stix_freemem (stix, rcv);
ACTIVE_STACK_SETTOP (stix, stix->_nil);
return 1; /* success */
}
static int prim_shallow_copy (stix_t* stix, stix_ooi_t nargs) static int prim_shallow_copy (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, obj; stix_oop_t rcv, obj;
@ -697,19 +726,23 @@ static int prim_shallow_copy (stix_t* stix, stix_ooi_t nargs)
static int prim_basic_size (stix_t* stix, stix_ooi_t nargs) static int prim_basic_size (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv; stix_oop_t rcv, sz;
STIX_ASSERT (nargs == 0); STIX_ASSERT (nargs == 0);
rcv = ACTIVE_STACK_GETTOP(stix); rcv = ACTIVE_STACK_GETTOP(stix);
ACTIVE_STACK_SETTOP(stix, STIX_SMOOI_TO_OOP(STIX_OBJ_GET_SIZE(rcv)));
/* TODO: use LargeInteger if the size is very big */ sz = stix_oowtoint (stix, STIX_OBJ_GET_SIZE(rcv));
if (!sz) return -1; /* hard failure */
ACTIVE_STACK_SETTOP(stix, sz);
return 1; return 1;
} }
static int prim_basic_at (stix_t* stix, stix_ooi_t nargs) static int prim_basic_at (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, pos, v; stix_oop_t rcv, pos, v;
stix_ooi_t idx; stix_oow_t idx;
STIX_ASSERT (nargs == 1); STIX_ASSERT (nargs == 1);
@ -721,21 +754,18 @@ static int prim_basic_at (stix_t* stix, stix_ooi_t nargs)
} }
pos = ACTIVE_STACK_GET(stix, stix->sp); pos = ACTIVE_STACK_GET(stix, stix->sp);
if (!STIX_OOP_IS_SMOOI(pos)) if (stix_inttooow (stix, pos, &idx) <= 0)
{ {
/* TODO: handle LargeInteger */ /* integer out of range or not integer */
/* the position must be an integer */
return 0; return 0;
} }
idx = STIX_OOP_TO_SMOOI(pos);
if (idx < 1 || idx > STIX_OBJ_GET_SIZE(rcv)) if (idx < 1 || idx > STIX_OBJ_GET_SIZE(rcv))
{ {
/* index out of range */ /* index out of range */
return 0; return 0;
} }
/* [NOTE] basicAt: and basicAt:put: used a 1-based index. */ /* [NOTE] basicAt: and basicAt:put: uses a 1-based index. */
idx = idx - 1; idx = idx - 1;
switch (STIX_OBJ_GET_FLAGS_TYPE(rcv)) switch (STIX_OBJ_GET_FLAGS_TYPE(rcv))
@ -775,7 +805,7 @@ static int prim_basic_at (stix_t* stix, stix_ooi_t nargs)
static int prim_basic_at_put (stix_t* stix, stix_ooi_t nargs) static int prim_basic_at_put (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, pos, val; stix_oop_t rcv, pos, val;
stix_ooi_t idx; stix_oow_t idx;
STIX_ASSERT (nargs == 2); STIX_ASSERT (nargs == 2);
@ -785,18 +815,14 @@ static int prim_basic_at_put (stix_t* stix, stix_ooi_t nargs)
/* the receiver is a special numeric object, not a normal pointer */ /* the receiver is a special numeric object, not a normal pointer */
return 0; return 0;
} }
pos = ACTIVE_STACK_GET(stix, stix->sp - 1); pos = ACTIVE_STACK_GET(stix, stix->sp - 1);
if (!STIX_OOP_IS_SMOOI(pos))
{
/* TODO: handle LargeInteger */
/* the position must be an integer */
return 0;
}
val = ACTIVE_STACK_GET(stix, stix->sp); val = ACTIVE_STACK_GET(stix, stix->sp);
idx = STIX_OOP_TO_SMOOI(pos); if (stix_inttooow (stix, pos, &idx) <= 0)
{
/* integer out of range or not integer */
return 0;
}
if (idx < 1 || idx > STIX_OBJ_GET_SIZE(rcv)) if (idx < 1 || idx > STIX_OBJ_GET_SIZE(rcv))
{ {
/* index out of range */ /* index out of range */
@ -811,7 +837,7 @@ static int prim_basic_at_put (stix_t* stix, stix_ooi_t nargs)
return 0; return 0;
} }
/* [NOTE] basicAt: and basicAt:put: used a 1-based index. */ /* [NOTE] basicAt: and basicAt:put: uses a 1-based index. */
idx = idx - 1; idx = idx - 1;
switch (STIX_OBJ_GET_FLAGS_TYPE(rcv)) switch (STIX_OBJ_GET_FLAGS_TYPE(rcv))
@ -847,7 +873,7 @@ static int prim_basic_at_put (stix_t* stix, stix_ooi_t nargs)
break; break;
case STIX_OBJ_TYPE_WORD: case STIX_OBJ_TYPE_WORD:
/* TODO: handle largeINteger */ /* TODO: handle LargeInteger */
if (!STIX_OOP_IS_SMOOI(val)) if (!STIX_OOP_IS_SMOOI(val))
{ {
/* the value is not a number */ /* the value is not a number */
@ -1306,168 +1332,104 @@ static int prim_integer_bitshift (stix_t* stix, stix_ooi_t nargs)
static int prim_integer_eq (stix_t* stix, stix_ooi_t nargs) static int prim_integer_eq (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, arg; stix_oop_t rcv, arg, res;
STIX_ASSERT (nargs == 1); STIX_ASSERT (nargs == 1);
rcv = ACTIVE_STACK_GET(stix, stix->sp - 1); rcv = ACTIVE_STACK_GET(stix, stix->sp - 1);
arg = ACTIVE_STACK_GET(stix, stix->sp); arg = ACTIVE_STACK_GET(stix, stix->sp);
if (STIX_OOP_IS_SMOOI(rcv) && STIX_OOP_IS_SMOOI(arg)) res = stix_eqints (stix, rcv, arg);
{ if (!res) return (stix->errnum == STIX_EINVAL? 0: -1); /* soft or hard failure */
ACTIVE_STACK_POP (stix);
if (STIX_OOP_TO_SMOOI(rcv) == STIX_OOP_TO_SMOOI(arg))
{
ACTIVE_STACK_SETTOP (stix, stix->_true);
}
else
{
ACTIVE_STACK_SETTOP (stix, stix->_false);
}
return 1; ACTIVE_STACK_POP (stix);
} ACTIVE_STACK_SETTOP (stix, res);
return 1;
/* TODO: handle LargeInteger */
return 0;
} }
static int prim_integer_ne (stix_t* stix, stix_ooi_t nargs) static int prim_integer_ne (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, arg; stix_oop_t rcv, arg, res;
STIX_ASSERT (nargs == 1); STIX_ASSERT (nargs == 1);
rcv = ACTIVE_STACK_GET(stix, stix->sp - 1); rcv = ACTIVE_STACK_GET(stix, stix->sp - 1);
arg = ACTIVE_STACK_GET(stix, stix->sp); arg = ACTIVE_STACK_GET(stix, stix->sp);
if (STIX_OOP_IS_SMOOI(rcv) && STIX_OOP_IS_SMOOI(arg)) res = stix_neints (stix, rcv, arg);
{ if (!res) return (stix->errnum == STIX_EINVAL? 0: -1); /* soft or hard failure */
ACTIVE_STACK_POP (stix);
if (STIX_OOP_TO_SMOOI(rcv) != STIX_OOP_TO_SMOOI(arg))
{
ACTIVE_STACK_SETTOP (stix, stix->_true);
}
else
{
ACTIVE_STACK_SETTOP (stix, stix->_false);
}
return 1; ACTIVE_STACK_POP (stix);
} ACTIVE_STACK_SETTOP (stix, res);
return 1;
/* TODO: handle LargeInteger */
return 0;
} }
static int prim_integer_lt (stix_t* stix, stix_ooi_t nargs) static int prim_integer_lt (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, arg; stix_oop_t rcv, arg, res;
STIX_ASSERT (nargs == 1); STIX_ASSERT (nargs == 1);
rcv = ACTIVE_STACK_GET(stix, stix->sp - 1); rcv = ACTIVE_STACK_GET(stix, stix->sp - 1);
arg = ACTIVE_STACK_GET(stix, stix->sp); arg = ACTIVE_STACK_GET(stix, stix->sp);
if (STIX_OOP_IS_SMOOI(rcv) && STIX_OOP_IS_SMOOI(arg)) res = stix_ltints (stix, rcv, arg);
{ if (!res) return (stix->errnum == STIX_EINVAL? 0: -1); /* soft or hard failure */
ACTIVE_STACK_POP (stix);
if (STIX_OOP_TO_SMOOI(rcv) < STIX_OOP_TO_SMOOI(arg))
{
ACTIVE_STACK_SETTOP (stix, stix->_true);
}
else
{
ACTIVE_STACK_SETTOP (stix, stix->_false);
}
return 1; ACTIVE_STACK_POP (stix);
} ACTIVE_STACK_SETTOP (stix, res);
return 1;
/* TODO: handle LargeInteger */
return 0;
} }
static int prim_integer_gt (stix_t* stix, stix_ooi_t nargs) static int prim_integer_gt (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, arg; stix_oop_t rcv, arg, res;
STIX_ASSERT (nargs == 1); STIX_ASSERT (nargs == 1);
rcv = ACTIVE_STACK_GET(stix, stix->sp - 1); rcv = ACTIVE_STACK_GET(stix, stix->sp - 1);
arg = ACTIVE_STACK_GET(stix, stix->sp); arg = ACTIVE_STACK_GET(stix, stix->sp);
if (STIX_OOP_IS_SMOOI(rcv) && STIX_OOP_IS_SMOOI(arg)) res = stix_gtints (stix, rcv, arg);
{ if (!res) return (stix->errnum == STIX_EINVAL? 0: -1); /* soft or hard failure */
ACTIVE_STACK_POP (stix);
if (STIX_OOP_TO_SMOOI(rcv) > STIX_OOP_TO_SMOOI(arg))
{
ACTIVE_STACK_SETTOP (stix, stix->_true);
}
else
{
ACTIVE_STACK_SETTOP (stix, stix->_false);
}
return 1; ACTIVE_STACK_POP (stix);
} ACTIVE_STACK_SETTOP (stix, res);
return 1;
/* TODO: handle LargeInteger */
return 0;
} }
static int prim_integer_le (stix_t* stix, stix_ooi_t nargs) static int prim_integer_le (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, arg; stix_oop_t rcv, arg, res;
STIX_ASSERT (nargs == 1); STIX_ASSERT (nargs == 1);
rcv = ACTIVE_STACK_GET(stix, stix->sp - 1); rcv = ACTIVE_STACK_GET(stix, stix->sp - 1);
arg = ACTIVE_STACK_GET(stix, stix->sp); arg = ACTIVE_STACK_GET(stix, stix->sp);
if (STIX_OOP_IS_SMOOI(rcv) && STIX_OOP_IS_SMOOI(arg)) res = stix_leints (stix, rcv, arg);
{ if (!res) return (stix->errnum == STIX_EINVAL? 0: -1); /* soft or hard failure */
ACTIVE_STACK_POP (stix);
if (STIX_OOP_TO_SMOOI(rcv) <= STIX_OOP_TO_SMOOI(arg))
{
ACTIVE_STACK_SETTOP (stix, stix->_true);
}
else
{
ACTIVE_STACK_SETTOP (stix, stix->_false);
}
return 1; ACTIVE_STACK_POP (stix);
} ACTIVE_STACK_SETTOP (stix, res);
return 1;
/* TODO: handle LargeInteger */
return 0;
} }
static int prim_integer_ge (stix_t* stix, stix_ooi_t nargs) static int prim_integer_ge (stix_t* stix, stix_ooi_t nargs)
{ {
stix_oop_t rcv, arg; stix_oop_t rcv, arg, res;
STIX_ASSERT (nargs == 1); STIX_ASSERT (nargs == 1);
rcv = ACTIVE_STACK_GET(stix, stix->sp - 1); rcv = ACTIVE_STACK_GET(stix, stix->sp - 1);
arg = ACTIVE_STACK_GET(stix, stix->sp); arg = ACTIVE_STACK_GET(stix, stix->sp);
if (STIX_OOP_IS_SMOOI(rcv) && STIX_OOP_IS_SMOOI(arg)) res = stix_geints (stix, rcv, arg);
{ if (!res) return (stix->errnum == STIX_EINVAL? 0: -1); /* soft or hard failure */
ACTIVE_STACK_POP (stix);
if (STIX_OOP_TO_SMOOI(rcv) >= STIX_OOP_TO_SMOOI(arg))
{
ACTIVE_STACK_SETTOP (stix, stix->_true);
}
else
{
ACTIVE_STACK_SETTOP (stix, stix->_false);
}
return 1; ACTIVE_STACK_POP (stix);
} ACTIVE_STACK_SETTOP (stix, res);
return 1;
return 0;
} }
static int prim_integer_inttostr (stix_t* stix, stix_ooi_t nargs) static int prim_integer_inttostr (stix_t* stix, stix_ooi_t nargs)
@ -1829,6 +1791,9 @@ static prim_t primitives[] =
{ 0, prim_basic_new, "_basic_new" }, { 0, prim_basic_new, "_basic_new" },
{ 1, prim_basic_new_with_size, "_basic_new_with_size" }, { 1, prim_basic_new_with_size, "_basic_new_with_size" },
{ 0, prim_ngc_new, "_ngc_new" },
{ 1, prim_ngc_new_with_size, "_ngc_new_with_size" },
{ 0, prim_ngc_dispose, "_ngc_dispose" },
{ 0, prim_shallow_copy, "_shallow_copy" }, { 0, prim_shallow_copy, "_shallow_copy" },
{ 0, prim_basic_size, "_basic_size" }, { 0, prim_basic_size, "_basic_size" },

2
stix/lib/ignite.c
View File

@ -290,7 +290,7 @@ int stix_ignite (stix_t* stix)
stix->_nil = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t)); stix->_nil = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t));
if (!stix->_nil) return -1; 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); 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; stix->_nil->_size = 0;
if (ignite_1(stix) <= -1 || ignite_2(stix) <= -1 || ignite_3(stix)) return -1; if (ignite_1(stix) <= -1 || ignite_2(stix) <= -1 || ignite_3(stix)) return -1;

162
stix/lib/obj.c
View File

@ -64,7 +64,7 @@ stix_oop_t stix_allocoopobj (stix_t* stix, stix_oow_t size)
hdr = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t) + nbytes_aligned); hdr = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t) + nbytes_aligned);
if (!hdr) return STIX_NULL; if (!hdr) return STIX_NULL;
hdr->_flags = STIX_OBJ_MAKE_FLAGS(STIX_OBJ_TYPE_OOP, STIX_SIZEOF(stix_oop_t), 0, 0, 0, 0); hdr->_flags = STIX_OBJ_MAKE_FLAGS(STIX_OBJ_TYPE_OOP, STIX_SIZEOF(stix_oop_t), 0, 0, 0, 0, 0);
STIX_OBJ_SET_SIZE (hdr, size); STIX_OBJ_SET_SIZE (hdr, size);
STIX_OBJ_SET_CLASS (hdr, stix->_nil); STIX_OBJ_SET_CLASS (hdr, stix->_nil);
@ -87,7 +87,7 @@ stix_oop_t stix_allocoopobjwithtrailer (stix_t* stix, stix_oow_t size, const sti
hdr = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t) + nbytes_aligned); hdr = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t) + nbytes_aligned);
if (!hdr) return STIX_NULL; if (!hdr) return STIX_NULL;
hdr->_flags = STIX_OBJ_MAKE_FLAGS(STIX_OBJ_TYPE_OOP, STIX_SIZEOF(stix_oop_t), 0, 0, 0, 1); hdr->_flags = STIX_OBJ_MAKE_FLAGS(STIX_OBJ_TYPE_OOP, STIX_SIZEOF(stix_oop_t), 0, 0, 0, 0, 1);
STIX_OBJ_SET_SIZE (hdr, size); STIX_OBJ_SET_SIZE (hdr, size);
STIX_OBJ_SET_CLASS (hdr, stix->_nil); STIX_OBJ_SET_CLASS (hdr, stix->_nil);
@ -130,7 +130,7 @@ static STIX_INLINE stix_oop_t alloc_numeric_array (stix_t* stix, const void* ptr
hdr = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t) + nbytes_aligned); hdr = stix_allocbytes (stix, STIX_SIZEOF(stix_obj_t) + nbytes_aligned);
if (!hdr) return STIX_NULL; if (!hdr) return STIX_NULL;
hdr->_flags = STIX_OBJ_MAKE_FLAGS(type, unit, extra, 0, 0, 0); hdr->_flags = STIX_OBJ_MAKE_FLAGS(type, unit, extra, 0, 0, 0, 0);
hdr->_size = len; hdr->_size = len;
STIX_OBJ_SET_SIZE (hdr, len); STIX_OBJ_SET_SIZE (hdr, len);
STIX_OBJ_SET_CLASS (hdr, stix->_nil); STIX_OBJ_SET_CLASS (hdr, stix->_nil);
@ -170,15 +170,11 @@ stix_oop_t stix_allocwordobj (stix_t* stix, const stix_oow_t* ptr, stix_oow_t le
return alloc_numeric_array (stix, ptr, len, STIX_OBJ_TYPE_WORD, STIX_SIZEOF(stix_oow_t), 0); return alloc_numeric_array (stix, ptr, len, STIX_OBJ_TYPE_WORD, STIX_SIZEOF(stix_oow_t), 0);
} }
stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr, stix_oow_t vlen) static STIX_INLINE int decode_spec (stix_t* stix, stix_oop_t _class, stix_oow_t vlen, stix_obj_type_t* type, stix_oow_t* outlen)
{ {
stix_oop_t oop;
stix_oow_t spec; stix_oow_t spec;
stix_oow_t named_instvar; stix_oow_t named_instvar;
stix_obj_type_t indexed_type; stix_obj_type_t indexed_type;
stix_oow_t tmp_count = 0;
STIX_ASSERT (stix->_nil != STIX_NULL);
STIX_ASSERT (STIX_OOP_IS_POINTER(_class)); STIX_ASSERT (STIX_OOP_IS_POINTER(_class));
STIX_ASSERT (STIX_CLASSOF(stix, _class) == stix->_class); STIX_ASSERT (STIX_CLASSOF(stix, _class) == stix->_class);
@ -197,7 +193,7 @@ stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr,
if (named_instvar > STIX_MAX_NAMED_INSTVARS || if (named_instvar > STIX_MAX_NAMED_INSTVARS ||
vlen > STIX_MAX_INDEXED_INSTVARS(named_instvar)) vlen > STIX_MAX_INDEXED_INSTVARS(named_instvar))
{ {
goto einval; return -1;
} }
STIX_ASSERT (named_instvar + vlen <= STIX_OBJ_SIZE_MAX); STIX_ASSERT (named_instvar + vlen <= STIX_OBJ_SIZE_MAX);
@ -205,8 +201,8 @@ stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr,
else else
{ {
/* a non-pointer indexed class can't have named instance variables */ /* a non-pointer indexed class can't have named instance variables */
if (named_instvar > 0) goto einval; if (named_instvar > 0) return -1;
if (vlen > STIX_OBJ_SIZE_MAX) goto einval; if (vlen > STIX_OBJ_SIZE_MAX) return -1;
} }
} }
else else
@ -216,18 +212,38 @@ stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr,
indexed_type = STIX_OBJ_TYPE_OOP; indexed_type = STIX_OBJ_TYPE_OOP;
vlen = 0; /* vlen is not used */ vlen = 0; /* vlen is not used */
if (named_instvar > STIX_MAX_NAMED_INSTVARS) goto einval; if (named_instvar > STIX_MAX_NAMED_INSTVARS) return -1;
STIX_ASSERT (named_instvar <= STIX_OBJ_SIZE_MAX); STIX_ASSERT (named_instvar <= STIX_OBJ_SIZE_MAX);
} }
*type = indexed_type;
*outlen = named_instvar + vlen;
return 0;
}
stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr, stix_oow_t vlen)
{
stix_oop_t oop;
stix_obj_type_t type;
stix_oow_t alloclen;
stix_oow_t tmp_count = 0;
STIX_ASSERT (stix->_nil != STIX_NULL);
if (decode_spec (stix, _class, vlen, &type, &alloclen) <= -1)
{
stix->errnum = STIX_EINVAL;
return STIX_NULL;
}
stix_pushtmp (stix, &_class); tmp_count++; stix_pushtmp (stix, &_class); tmp_count++;
switch (indexed_type) switch (type)
{ {
case STIX_OBJ_TYPE_OOP: case STIX_OBJ_TYPE_OOP:
/* both the fixed part(named instance variables) and /* both the fixed part(named instance variables) and
* the variable part(indexed instance variables) are allowed. */ * the variable part(indexed instance variables) are allowed. */
oop = stix_allocoopobj (stix, named_instvar + vlen); oop = stix_allocoopobj (stix, alloclen);
STIX_ASSERT (vptr == STIX_NULL); STIX_ASSERT (vptr == STIX_NULL);
/* /*
@ -248,19 +264,19 @@ stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr,
break; break;
case STIX_OBJ_TYPE_CHAR: case STIX_OBJ_TYPE_CHAR:
oop = stix_alloccharobj (stix, vptr, vlen); oop = stix_alloccharobj (stix, vptr, alloclen);
break; break;
case STIX_OBJ_TYPE_BYTE: case STIX_OBJ_TYPE_BYTE:
oop = stix_allocbyteobj (stix, vptr, vlen); oop = stix_allocbyteobj (stix, vptr, alloclen);
break; break;
case STIX_OBJ_TYPE_HALFWORD: case STIX_OBJ_TYPE_HALFWORD:
oop = stix_allochalfwordobj (stix, vptr, vlen); oop = stix_allochalfwordobj (stix, vptr, alloclen);
break; break;
case STIX_OBJ_TYPE_WORD: case STIX_OBJ_TYPE_WORD:
oop = stix_allocwordobj (stix, vptr, vlen); oop = stix_allocwordobj (stix, vptr, alloclen);
break; break;
default: default:
@ -272,67 +288,85 @@ stix_oop_t stix_instantiate (stix_t* stix, stix_oop_t _class, const void* vptr,
if (oop) STIX_OBJ_SET_CLASS (oop, _class); if (oop) STIX_OBJ_SET_CLASS (oop, _class);
stix_poptmps (stix, tmp_count); stix_poptmps (stix, tmp_count);
return oop; return oop;
einval:
STIX_ASSERT (tmp_count <= 0);
stix->errnum = STIX_EINVAL;
return STIX_NULL;
} }
stix_oop_t stix_instantiate2 (stix_t* stix, stix_oop_t _class, const void* vptr, stix_oow_t vlen, int ngc)
{
stix_oop_t oop;
stix_obj_type_t type;
stix_oow_t alloclen;
stix_oow_t tmp_count = 0;
STIX_ASSERT (stix->_nil != STIX_NULL);
if (decode_spec (stix, _class, vlen, &type, &alloclen) <= -1)
{
stix->errnum = STIX_EINVAL;
return STIX_NULL;
}
stix_pushtmp (stix, &_class); tmp_count++;
/* TODO: support NGC */
switch (type)
{
case STIX_OBJ_TYPE_OOP:
/* NOTE: vptr is not used for GC unsafety */
oop = stix_allocoopobj (stix, alloclen);
break;
case STIX_OBJ_TYPE_CHAR:
oop = stix_alloccharobj (stix, vptr, alloclen);
break;
case STIX_OBJ_TYPE_BYTE:
oop = stix_allocbyteobj (stix, vptr, alloclen);
break;
case STIX_OBJ_TYPE_HALFWORD:
oop = stix_allochalfwordobj (stix, vptr, alloclen);
break;
case STIX_OBJ_TYPE_WORD:
oop = stix_allocwordobj (stix, vptr, alloclen);
break;
default:
stix->errnum = STIX_EINTERN;
oop = STIX_NULL;
break;
}
if (oop) STIX_OBJ_SET_CLASS (oop, _class);
stix_poptmps (stix, tmp_count);
return oop;
}
#if defined(STIX_USE_OBJECT_TRAILER) #if defined(STIX_USE_OBJECT_TRAILER)
stix_oop_t stix_instantiatewithtrailer (stix_t* stix, stix_oop_t _class, stix_oow_t vlen, const stix_oob_t* tptr, stix_oow_t tlen) stix_oop_t stix_instantiatewithtrailer (stix_t* stix, stix_oop_t _class, stix_oow_t vlen, const stix_oob_t* tptr, stix_oow_t tlen)
{ {
stix_oop_t oop; stix_oop_t oop;
stix_oow_t spec; stix_obj_type_t type;
stix_oow_t named_instvar; stix_oow_t alloclen;
stix_obj_type_t indexed_type;
stix_oow_t tmp_count = 0; stix_oow_t tmp_count = 0;
STIX_ASSERT (stix->_nil != STIX_NULL); STIX_ASSERT (stix->_nil != STIX_NULL);
STIX_ASSERT (STIX_OOP_IS_POINTER(_class)); if (decode_spec (stix, _class, vlen, &type, &alloclen) <= -1)
STIX_ASSERT (STIX_CLASSOF(stix, _class) == stix->_class);
STIX_ASSERT (STIX_OOP_IS_SMOOI(((stix_oop_class_t)_class)->spec));
spec = STIX_OOP_TO_SMOOI(((stix_oop_class_t)_class)->spec);
named_instvar = STIX_CLASS_SPEC_NAMED_INSTVAR(spec); /* size of the named_instvar part */
if (STIX_CLASS_SPEC_IS_INDEXED(spec))
{ {
indexed_type = STIX_CLASS_SPEC_INDEXED_TYPE(spec); stix->errnum = STIX_EINVAL;
return STIX_NULL;
if (indexed_type == STIX_OBJ_TYPE_OOP)
{
if (named_instvar > STIX_MAX_NAMED_INSTVARS ||
vlen > STIX_MAX_INDEXED_INSTVARS(named_instvar))
{
goto einval;
}
}
else
{
/* not a class for an OOP object */
goto einval;
}
}
else
{
/* named instance variables only. treat it as if it is an
* indexable class with no variable data */
indexed_type = STIX_OBJ_TYPE_OOP;
vlen = 0;
if (named_instvar > STIX_MAX_NAMED_INSTVARS) goto einval;
} }
stix_pushtmp (stix, &_class); tmp_count++; stix_pushtmp (stix, &_class); tmp_count++;
switch (indexed_type) switch (type)
{ {
case STIX_OBJ_TYPE_OOP: case STIX_OBJ_TYPE_OOP:
oop = stix_allocoopobjwithtrailer(stix, named_instvar + vlen, tptr, tlen); /* NOTE: vptr is not used for GC unsafety */
oop = stix_allocoopobjwithtrailer(stix, alloclen, tptr, tlen);
break; break;
default: default:
@ -344,12 +378,6 @@ stix_oop_t stix_instantiatewithtrailer (stix_t* stix, stix_oop_t _class, stix_oo
if (oop) STIX_OBJ_SET_CLASS (oop, _class); if (oop) STIX_OBJ_SET_CLASS (oop, _class);
stix_poptmps (stix, tmp_count); stix_poptmps (stix, tmp_count);
return oop; return oop;
einval:
STIX_ASSERT (tmp_count <= 0);
stix->errnum = STIX_EINVAL;
return STIX_NULL;
} }
#endif #endif

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

@ -1117,6 +1117,22 @@ int stix_utf8toucs (
/* ========================================================================= */ /* ========================================================================= */
/* bigint.c */ /* bigint.c */
/* ========================================================================= */ /* ========================================================================= */
int stix_isint (
stix_t* stix,
stix_oop_t x
);
int stix_inttooow (
stix_t* stix,
stix_oop_t x,
stix_oow_t* w
);
stix_oop_t stix_oowtoint (
stix_t* stix,
stix_oow_t w
);
stix_oop_t stix_addints ( stix_oop_t stix_addints (
stix_t* stix, stix_t* stix,
stix_oop_t x, stix_oop_t x,
@ -1183,6 +1199,42 @@ stix_oop_t stix_bitshiftint (
stix_oop_t y stix_oop_t y
); );
stix_oop_t stix_eqints (
stix_t* stix,
stix_oop_t x,
stix_oop_t y
);
stix_oop_t stix_neints (
stix_t* stix,
stix_oop_t x,
stix_oop_t y
);
stix_oop_t stix_gtints (
stix_t* stix,
stix_oop_t x,
stix_oop_t y
);
stix_oop_t stix_geints (
stix_t* stix,
stix_oop_t x,
stix_oop_t y
);
stix_oop_t stix_ltints (
stix_t* stix,
stix_oop_t x,
stix_oop_t y
);
stix_oop_t stix_leints (
stix_t* stix,
stix_oop_t x,
stix_oop_t y
);
stix_oop_t stix_strtoint ( stix_oop_t stix_strtoint (
stix_t* stix, stix_t* stix,
const stix_ooch_t* str, const stix_ooch_t* str,

41
stix/lib/stix.h
View File

@ -227,6 +227,7 @@ typedef enum stix_obj_type_t stix_obj_type_t;
* VM disallows layout changes of a kernel object. * VM disallows layout changes of a kernel object.
* internal use only. * internal use only.
* moved: 0 or 1. used by GC. internal use only. * moved: 0 or 1. used by GC. internal use only.
* ngc: 0 or 1, used by GC. internal use only.
* trailer: 0 or 1. indicates that there are trailing bytes * trailer: 0 or 1. indicates that there are trailing bytes
* after the object payload. internal use only. * after the object payload. internal use only.
* *
@ -260,21 +261,24 @@ typedef enum stix_obj_type_t stix_obj_type_t;
#define STIX_OBJ_FLAGS_EXTRA_BITS 1 #define STIX_OBJ_FLAGS_EXTRA_BITS 1
#define STIX_OBJ_FLAGS_KERNEL_BITS 2 #define STIX_OBJ_FLAGS_KERNEL_BITS 2
#define STIX_OBJ_FLAGS_MOVED_BITS 1 #define STIX_OBJ_FLAGS_MOVED_BITS 1
#define STIX_OBJ_FLAGS_NGC_BITS 1
#define STIX_OBJ_FLAGS_TRAILER_BITS 1 #define STIX_OBJ_FLAGS_TRAILER_BITS 1
#define STIX_OBJ_GET_FLAGS_TYPE(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_UNIT_BITS + STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_TYPE_BITS) #define STIX_OBJ_GET_FLAGS_TYPE(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_UNIT_BITS + STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_TYPE_BITS)
#define STIX_OBJ_GET_FLAGS_UNIT(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_UNIT_BITS) #define STIX_OBJ_GET_FLAGS_UNIT(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_UNIT_BITS)
#define STIX_OBJ_GET_FLAGS_EXTRA(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_EXTRA_BITS) #define STIX_OBJ_GET_FLAGS_EXTRA(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_EXTRA_BITS)
#define STIX_OBJ_GET_FLAGS_KERNEL(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_KERNEL_BITS) #define STIX_OBJ_GET_FLAGS_KERNEL(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_KERNEL_BITS)
#define STIX_OBJ_GET_FLAGS_MOVED(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_MOVED_BITS) #define STIX_OBJ_GET_FLAGS_MOVED(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_MOVED_BITS)
#define STIX_OBJ_GET_FLAGS_TRAILER(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, 0, STIX_OBJ_FLAGS_TRAILER_BITS) #define STIX_OBJ_GET_FLAGS_NGC(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_MOVED_BITS)
#define STIX_OBJ_GET_FLAGS_TRAILER(oop) STIX_GETBITS(stix_oow_t, (oop)->_flags, 0, STIX_OBJ_FLAGS_TRAILER_BITS)
#define STIX_OBJ_SET_FLAGS_TYPE(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_UNIT_BITS + STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_TYPE_BITS, v) #define STIX_OBJ_SET_FLAGS_TYPE(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_UNIT_BITS + STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_TYPE_BITS, v)
#define STIX_OBJ_SET_FLAGS_UNIT(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_UNIT_BITS, v) #define STIX_OBJ_SET_FLAGS_UNIT(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_UNIT_BITS, v)
#define STIX_OBJ_SET_FLAGS_EXTRA(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_EXTRA_BITS, v) #define STIX_OBJ_SET_FLAGS_EXTRA(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_EXTRA_BITS, v)
#define STIX_OBJ_SET_FLAGS_KERNEL(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_KERNEL_BITS, v) #define STIX_OBJ_SET_FLAGS_KERNEL(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_KERNEL_BITS, v)
#define STIX_OBJ_SET_FLAGS_MOVED(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_MOVED_BITS, v) #define STIX_OBJ_SET_FLAGS_MOVED(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS), STIX_OBJ_FLAGS_MOVED_BITS, v)
#define STIX_OBJ_SET_FLAGS_TRAILER(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, 0, STIX_OBJ_FLAGS_TRAILER_BITS, v) #define STIX_OBJ_SET_FLAGS_NGC(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, (STIX_OBJ_FLAGS_TRAILER_BITS), STIX_OBJ_FLAGS_MOVED_BITS, v)
#define STIX_OBJ_SET_FLAGS_TRAILER(oop,v) STIX_SETBITS(stix_oow_t, (oop)->_flags, 0, STIX_OBJ_FLAGS_TRAILER_BITS, v)
#define STIX_OBJ_GET_SIZE(oop) ((oop)->_size) #define STIX_OBJ_GET_SIZE(oop) ((oop)->_size)
#define STIX_OBJ_GET_CLASS(oop) ((oop)->_class) #define STIX_OBJ_GET_CLASS(oop) ((oop)->_class)
@ -288,12 +292,13 @@ typedef enum stix_obj_type_t stix_obj_type_t;
/* [NOTE] this macro doesn't check the range of the actual value. /* [NOTE] this macro doesn't check the range of the actual value.
* make sure that the value of each bit fields given falls within the * make sure that the value of each bit fields given falls within the
* possible range of the defined bits */ * possible range of the defined bits */
#define STIX_OBJ_MAKE_FLAGS(t,u,e,k,m,r) ( \ #define STIX_OBJ_MAKE_FLAGS(t,u,e,k,m,g,r) ( \
(((stix_oow_t)(t)) << (STIX_OBJ_FLAGS_UNIT_BITS + STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS)) | \ (((stix_oow_t)(t)) << (STIX_OBJ_FLAGS_UNIT_BITS + STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS)) | \
(((stix_oow_t)(u)) << (STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS)) | \ (((stix_oow_t)(u)) << (STIX_OBJ_FLAGS_EXTRA_BITS + STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS)) | \
(((stix_oow_t)(e)) << (STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS)) | \ (((stix_oow_t)(e)) << (STIX_OBJ_FLAGS_KERNEL_BITS + STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS)) | \
(((stix_oow_t)(k)) << (STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS)) | \ (((stix_oow_t)(k)) << (STIX_OBJ_FLAGS_MOVED_BITS + STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS)) | \
(((stix_oow_t)(m)) << (STIX_OBJ_FLAGS_TRAILER_BITS)) | \ (((stix_oow_t)(m)) << (STIX_OBJ_FLAGS_TRAILER_BITS + STIX_OBJ_FLAGS_NGC_BITS)) | \
(((stix_oow_t)(g)) << (STIX_OBJ_FLAGS_TRAILER_BITS)) | \
(((stix_oow_t)(r)) << 0) \ (((stix_oow_t)(r)) << 0) \
) )