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

changed atom_t to stix_liw_t and made related changes.

Browse Source 
introduced #liword to the compiler
This commit is contained in:
hyunghwan.chung 2015-11-17 14:13:59 +00:00
parent 415921d4a7
commit 5cebf7e8dc
9 changed files with 295 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
stix/kernel/Stix.st
View File

@ -115,18 +115,18 @@
{ {
} }
## #class(#halfword) LargeInteger(Number) #class(#halfword) LargeInteger(Number)
#class(#word) LargeInteger(Number) ## #class(#word) LargeInteger(Number)
{ {
} }
## #class(#halfword) LargePositiveInteger(LargeInteger) #class(#halfword) LargePositiveInteger(LargeInteger)
#class(#word) LargePositiveInteger(LargeInteger) ## #class(#word) LargePositiveInteger(LargeInteger)
{ {
} }
## #class(#halfword) LargeNegativeInteger(LargeInteger) #class(#halfword) LargeNegativeInteger(LargeInteger)
#class(#word) LargeNegativeInteger(LargeInteger) ## #class(#word) LargeNegativeInteger(LargeInteger)
{ {
} }

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

@ -266,6 +266,9 @@ PROCESS TESTING
##(-16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF * 1) dump. ##(-16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF * 1) dump.
##((-2305843009213693952 * -1) - 1 + 2) dump. ##((-2305843009213693952 * -1) - 1 + 2) dump.
((-2305843009213693952 * -2305843009213693952 * 2305843009213693952 * 2305843009213693952 * 2305843009213693952) - 1 + 2) dump. ((-2305843009213693952 * -2305843009213693952 * 2305843009213693952 * 2305843009213693952 * 2305843009213693952) - 1 + 2) dump.
(2r111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 * 128971234897128931) dump.
" "
FFI isNil dump. FFI isNil dump.
FFI notNil dump. FFI notNil dump.

339
stix/lib/bigint.c
View File

@ -27,6 +27,12 @@
#include "stix-prv.h" #include "stix-prv.h"
#if defined(STIX_USE_FULL_WORD)
/* nothign special */
#else
# define MAKE_WORD(hw1,hw2) ((stix_oow_t)(hw1) | (stix_oow_t)(hw2) << STIX_LIW_BITS)
#endif
/*#define IS_POWER_OF_2(ui) (((ui) > 0) && (((ui) & (~(ui)+ 1)) == (ui)))*/ /*#define IS_POWER_OF_2(ui) (((ui) > 0) && (((ui) & (~(ui)+ 1)) == (ui)))*/
#define IS_POWER_OF_2(ui) (((ui) > 0) && ((ui) & ((ui) - 1)) == 0) /* unsigned integer only */ #define IS_POWER_OF_2(ui) (((ui) > 0) && ((ui) & ((ui) - 1)) == 0) /* unsigned integer only */
@ -62,7 +68,7 @@ static STIX_INLINE int oow_mul_overflow (stix_oow_t a, stix_oow_t b, stix_oow_t*
/*return k > STIX_TYPE_MAX(stix_oow_t);*/ /*return k > STIX_TYPE_MAX(stix_oow_t);*/
#else #else
*c = a * b; *c = a * b;
return b > 0 && a > STIX_TYPE_MAX(stix_oow_t) / b; /* works for unsigned types only */ return b != 0 && a > STIX_TYPE_MAX(stix_oow_t) / b; /* works for unsigned types only */
#endif #endif
} }
#endif #endif
@ -76,6 +82,9 @@ static STIX_INLINE int oow_mul_overflow (stix_oow_t a, stix_oow_t b, stix_oow_t*
#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_ooi_t a, stix_ooi_t b, stix_ooi_t* c)
{ {
/* take note that this function is not supposed to handle
* the whole stix_ooi_t range. it handles the smooi subrange */
#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;
@ -100,44 +109,45 @@ static STIX_INLINE int smooi_mul_overflow (stix_ooi_t a, stix_ooi_t b, stix_ooi_
/* though this fomula basically works for unsigned types in principle, /* though this fomula basically works for unsigned types in principle,
* the values used here are all absolute values and they fall in * the values used here are all absolute values and they fall in
* a safe range to apply this fomula */ * a safe range to apply this fomula. the safe range is guarantee because
return ub > 0 && ua > STIX_TYPE_MAX(stix_ooi_t) / ub; * the sources are supposed to be smoois. */
return ub != 0 && ua > STIX_TYPE_MAX(stix_ooi_t) / ub;
#endif #endif
} }
#endif #endif
#if (SIZEOF_ATOM_T == STIX_SIZEOF_INT) && defined(STIX_HAVE_BUILTIN_UADD_OVERFLOW) #if (STIX_SIZEOF_LIW_T == STIX_SIZEOF_INT) && defined(STIX_HAVE_BUILTIN_UADD_OVERFLOW)
# define atom_add_overflow(a,b,c) __builtin_uadd_overflow(a,b,c) # define liw_add_overflow(a,b,c) __builtin_uadd_overflow(a,b,c)
#elif (SIZEOF_ATOM_T == STIX_SIZEOF_LONG) && defined(STIX_HAVE_BUILTIN_UADDL_OVERFLOW) #elif (STIX_SIZEOF_LIW_T == STIX_SIZEOF_LONG) && defined(STIX_HAVE_BUILTIN_UADDL_OVERFLOW)
# define atom_add_overflow(a,b,c) __builtin_uaddl_overflow(a,b,c) # define liw_add_overflow(a,b,c) __builtin_uaddl_overflow(a,b,c)
#elif (SIZEOF_ATOM_T == STIX_SIZEOF_LONG_LONG) && defined(STIX_HAVE_BUILTIN_UADDLL_OVERFLOW) #elif (STIX_SIZEOF_LIW_T == STIX_SIZEOF_LONG_LONG) && defined(STIX_HAVE_BUILTIN_UADDLL_OVERFLOW)
# define atom_add_overflow(a,b,c) __builtin_uaddll_overflow(a,b,c) # define liw_add_overflow(a,b,c) __builtin_uaddll_overflow(a,b,c)
#else #else
static STIX_INLINE int atom_add_overflow (atom_t a, atom_t b, atom_t* c) static STIX_INLINE int liw_add_overflow (stix_liw_t a, stix_liw_t b, stix_liw_t* c)
{ {
*c = a + b; *c = a + b;
return b > STIX_TYPE_MAX(atom_t) - a; return b > STIX_TYPE_MAX(stix_liw_t) - a;
} }
#endif #endif
#if (SIZEOF_ATOM_T == STIX_SIZEOF_INT) && defined(STIX_HAVE_BUILTIN_UMUL_OVERFLOW) #if (STIX_SIZEOF_LIW_T == STIX_SIZEOF_INT) && defined(STIX_HAVE_BUILTIN_UMUL_OVERFLOW)
# define atom_mul_overflow(a,b,c) __builtin_umul_overflow(a,b,c) # define liw_mul_overflow(a,b,c) __builtin_umul_overflow(a,b,c)
#elif (SIZEOF_ATOM_T == STIX_SIZEOF_LONG) && defined(STIX_HAVE_BUILTIN_UMULL_OVERFLOW) #elif (STIX_SIZEOF_LIW_T == STIX_SIZEOF_LONG) && defined(STIX_HAVE_BUILTIN_UMULL_OVERFLOW)
# define atom_mul_overflow(a,b,c) __builtin_uaddl_overflow(a,b,c) # define liw_mul_overflow(a,b,c) __builtin_uaddl_overflow(a,b,c)
#elif (SIZEOF_ATOM_T == STIX_SIZEOF_LONG_LONG) && defined(STIX_HAVE_BUILTIN_UMULLL_OVERFLOW) #elif (STIX_SIZEOF_LIW_T == STIX_SIZEOF_LONG_LONG) && defined(STIX_HAVE_BUILTIN_UMULLL_OVERFLOW)
# define atom_mul_overflow(a,b,c) __builtin_uaddll_overflow(a,b,c) # define liw_mul_overflow(a,b,c) __builtin_uaddll_overflow(a,b,c)
#else #else
static STIX_INLINE int atom_mul_overflow (atom_t a, atom_t b, atom_t* c) static STIX_INLINE int liw_mul_overflow (stix_liw_t a, stix_liw_t b, stix_liw_t* c)
{ {
#if (STIX_SIZEOF_UINTMAX_T > SIZEOF_ATOM_T) #if (STIX_SIZEOF_UINTMAX_T > STIX_SIZEOF_LIW_T)
stix_uintmax_t k; stix_uintmax_t k;
k = (stix_uintmax_t)a * (stix_uintmax_t)b; k = (stix_uintmax_t)a * (stix_uintmax_t)b;
*c = (atom_t)k; *c = (stix_liw_t)k;
return (k >> ATOM_BITS) > 0; return (k >> STIX_LIW_BITS) > 0;
/*return k > STIX_TYPE_MAX(atom_t);*/ /*return k > STIX_TYPE_MAX(stix_liw_t);*/
#else #else
*c = a * b; *c = a * b;
return b > 0 && a > STIX_TYPE_MAX(atom_t) / b; /* works for unsigned types only */ return b != 0 && a > STIX_TYPE_MAX(stix_liw_t) / b; /* works for unsigned types only */
#endif #endif
} }
#endif #endif
@ -156,10 +166,10 @@ static STIX_INLINE int is_integer (stix_t* stix, stix_oop_t oop)
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 defined(USE_FULL_WORD) #if defined(STIX_USE_FULL_WORD)
stix_oow_t w; stix_oow_t w;
STIX_ASSERT (STIX_ZIEOF(stix_oow_t) == STIX_SIZEOF(atom_t)); STIX_ASSERT (STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_liw_t));
if (i >= 0) if (i >= 0)
{ {
w = i; w = i;
@ -175,22 +185,22 @@ static STIX_INLINE stix_oop_t make_bigint_with_ooi (stix_t* stix, stix_ooi_t i)
return stix_instantiate (stix, stix->_large_negative_integer, &w, 1); return stix_instantiate (stix, stix->_large_negative_integer, &w, 1);
} }
#else #else
atom_t hw[2]; stix_liw_t hw[2];
stix_oow_t w; stix_oow_t w;
if (i >= 0) if (i >= 0)
{ {
w = i; w = i;
hw[0] = w & STIX_LBMASK(stix_oow_t,ATOM_BITS); hw[0] = w & STIX_LBMASK(stix_oow_t,STIX_LIW_BITS);
hw[1] = w >> ATOM_BITS; hw[1] = w >> STIX_LIW_BITS;
return stix_instantiate (stix, stix->_large_positive_integer, &hw, (hw[1] > 0? 2: 1)); return stix_instantiate (stix, stix->_large_positive_integer, &hw, (hw[1] > 0? 2: 1));
} }
else else
{ {
STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t)); STIX_ASSERT (i > STIX_TYPE_MIN(stix_ooi_t));
w = -i; w = -i;
hw[0] = w & STIX_LBMASK(stix_oow_t,ATOM_BITS); hw[0] = w & STIX_LBMASK(stix_oow_t,STIX_LIW_BITS);
hw[1] = w >> ATOM_BITS; hw[1] = w >> STIX_LIW_BITS;
return stix_instantiate (stix, stix->_large_negative_integer, &hw, (hw[1] > 0? 2: 1)); return stix_instantiate (stix, stix->_large_negative_integer, &hw, (hw[1] > 0? 2: 1));
} }
#endif #endif
@ -199,7 +209,7 @@ 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_intmax (stix_t* stix, stix_intmax_t v) static STIX_INLINE stix_oop_t make_bigint_with_intmax (stix_t* stix, stix_intmax_t v)
{ {
stix_oow_t len; stix_oow_t len;
atom_t buf[STIX_SIZEOF_INTMAX_T / SIZEOF_ATOM_T]; stix_liw_t buf[STIX_SIZEOF_INTMAX_T / STIX_SIZEOF_LIW_T];
stix_uintmax_t ui; stix_uintmax_t ui;
/* this is not a generic function. it can't handle v /* this is not a generic function. it can't handle v
@ -210,8 +220,8 @@ static STIX_INLINE stix_oop_t make_bigint_with_intmax (stix_t* stix, stix_intmax
len = 0; len = 0;
do do
{ {
buf[len++] = (atom_t)ui; buf[len++] = (stix_liw_t)ui;
ui = ui >> ATOM_BITS; ui = ui >> STIX_LIW_BITS;
} }
while (ui > 0); while (ui > 0);
@ -219,7 +229,8 @@ static STIX_INLINE stix_oop_t make_bigint_with_intmax (stix_t* stix, stix_intmax
printf ("MKBI-INTMAX=>"); printf ("MKBI-INTMAX=>");
for (i = len; i > 0;) for (i = len; i > 0;)
{ {
printf ("%016lX ", (unsigned long)buf[--i]);
printf ("%0*lX ", (int)(STIX_SIZEOF(stix_liw_t) * 2), (unsigned long)buf[--i]);
} }
printf ("\n"); printf ("\n");
} }
@ -242,7 +253,7 @@ static STIX_INLINE stix_oop_t clone_bigint (stix_t* stix, stix_oop_t oop, stix_o
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
((oop_atom_t)z)->slot[i] = ((oop_atom_t)oop)->slot[i]; ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)oop)->slot[i];
} }
return z; return z;
} }
@ -267,7 +278,7 @@ static STIX_INLINE stix_oop_t clone_bigint_negated (stix_t* stix, stix_oop_t oop
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
((oop_atom_t)z)->slot[i] = ((oop_atom_t)oop)->slot[i]; ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)oop)->slot[i];
} }
return z; return z;
} }
@ -279,7 +290,7 @@ static STIX_INLINE stix_oow_t count_effective_digits (stix_oop_t oop)
for (i = STIX_OBJ_GET_SIZE(oop); i > 1; ) for (i = STIX_OBJ_GET_SIZE(oop); i > 1; )
{ {
--i; --i;
if (((oop_atom_t)oop)->slot[i] != 0) return i + 1; if (((stix_oop_liword_t)oop)->slot[i] != 0) return i + 1;
} }
return 1; return 1;
@ -292,12 +303,12 @@ static stix_oop_t normalize_bigint (stix_t* stix, stix_oop_t oop)
STIX_ASSERT (STIX_OOP_IS_POINTER(oop)); STIX_ASSERT (STIX_OOP_IS_POINTER(oop));
count = count_effective_digits (oop); count = count_effective_digits (oop);
#if defined(USE_FULL_WORD) #if defined(STIX_USE_FULL_WORD)
if (count == 1) if (count == 1)
{ {
stix_oow_t w; stix_oow_t w;
w = ((oop_atom_t)oop)->slot[0]; w = ((stix_oop_liword_t)oop)->slot[0];
if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer) if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer)
{ {
if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP(w); if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP(w);
@ -314,19 +325,19 @@ static stix_oop_t normalize_bigint (stix_t* stix, stix_oop_t oop)
{ {
if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer) if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer)
{ {
return STIX_SMOOI_TO_OOP(((oop_atom_t)oop)->slot[0]); return STIX_SMOOI_TO_OOP(((stix_oop_liword_t)oop)->slot[0]);
} }
else else
{ {
STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer); STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer);
return STIX_SMOOI_TO_OOP(-(stix_oow_t)((oop_atom_t)oop)->slot[0]); return STIX_SMOOI_TO_OOP(-(stix_oow_t)((stix_oop_liword_t)oop)->slot[0]);
} }
} }
else if (count == 2) else if (count == 2)
{ {
stix_oow_t w; stix_oow_t w;
w = MAKE_WORD (((oop_atom_t)oop)->slot[0], ((oop_atom_t)oop)->slot[1]); w = MAKE_WORD (((stix_oop_liword_t)oop)->slot[0], ((stix_oop_liword_t)oop)->slot[1]);
if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer) if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer)
{ {
if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP(w); if (w <= STIX_SMOOI_MAX) return STIX_SMOOI_TO_OOP(w);
@ -349,7 +360,7 @@ static stix_oop_t normalize_bigint (stix_t* stix, stix_oop_t oop)
} }
static STIX_INLINE int is_less_unsigned_array (const atom_t* x, stix_oow_t xs, const atom_t* y, stix_oow_t ys) static STIX_INLINE int is_less_unsigned_array (const stix_liw_t* x, stix_oow_t xs, const stix_liw_t* y, stix_oow_t ys)
{ {
stix_oow_t i; stix_oow_t i;
@ -366,8 +377,8 @@ static STIX_INLINE int is_less_unsigned_array (const atom_t* x, stix_oow_t xs, c
static STIX_INLINE int is_less_unsigned (stix_oop_t x, stix_oop_t y) static STIX_INLINE int is_less_unsigned (stix_oop_t x, stix_oop_t y)
{ {
return is_less_unsigned_array ( return is_less_unsigned_array (
((oop_atom_t)x)->slot, STIX_OBJ_GET_SIZE(x), ((stix_oop_liword_t)x)->slot, STIX_OBJ_GET_SIZE(x),
((oop_atom_t)y)->slot, STIX_OBJ_GET_SIZE(y)); ((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y));
} }
static STIX_INLINE int is_less (stix_t* stix, stix_oop_t x, stix_oop_t y) static STIX_INLINE int is_less (stix_t* stix, stix_oop_t x, stix_oop_t y)
@ -384,29 +395,29 @@ static STIX_INLINE int is_equal (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
/* check if two large integers are equal to each other */ /* check if two large integers are equal to each other */
return STIX_OBJ_GET_CLASS(x) == STIX_OBJ_GET_CLASS(y) && STIX_OBJ_GET_SIZE(x) == STIX_OBJ_GET_SIZE(y) && return STIX_OBJ_GET_CLASS(x) == STIX_OBJ_GET_CLASS(y) && STIX_OBJ_GET_SIZE(x) == STIX_OBJ_GET_SIZE(y) &&
STIX_MEMCMP(((oop_atom_t)x)->slot, ((oop_atom_t)y)->slot, STIX_OBJ_GET_SIZE(x) * STIX_SIZEOF(atom_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 STIX_INLINE stix_oow_t add_unsigned_array (const atom_t* x, stix_oow_t xs, const atom_t* y, stix_oow_t ys, atom_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)
{ {
stix_oow_t i; stix_oow_t i;
bigatom_t w; stix_lidw_t w;
bigatom_t carry = 0; stix_lidw_t carry = 0;
STIX_ASSERT (xs >= ys); STIX_ASSERT (xs >= ys);
for (i = 0; i < ys; i++) for (i = 0; i < ys; i++)
{ {
w = (bigatom_t)x[i] + (bigatom_t)y[i] + carry; w = (stix_lidw_t)x[i] + (stix_lidw_t)y[i] + carry;
carry = w >> ATOM_BITS; carry = w >> STIX_LIW_BITS;
z[i] = w /*& STIX_LBMASK(bigatom_t, ATOM_BITS) */; z[i] = w /*& STIX_LBMASK(stix_lidw_t, STIX_LIW_BITS) */;
} }
for (; i < xs; i++) for (; i < xs; i++)
{ {
w = (bigatom_t)x[i] + carry; w = (stix_lidw_t)x[i] + carry;
carry = w >> ATOM_BITS; carry = w >> STIX_LIW_BITS;
z[i] = w /*& STIX_LBMASK(bigatom_t, ATOM_BITS)*/; z[i] = w /*& STIX_LBMASK(stix_lidw_t, STIX_LIW_BITS)*/;
} }
if (i > 1 && carry == 0) return i - 1; if (i > 1 && carry == 0) return i - 1;
@ -415,27 +426,27 @@ static STIX_INLINE stix_oow_t add_unsigned_array (const atom_t* x, stix_oow_t xs
return i; return i;
} }
static STIX_INLINE stix_oow_t subtract_unsigned_array (const atom_t* x, stix_oow_t xs, const atom_t* y, stix_oow_t ys, atom_t* z) 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)
{ {
stix_oow_t i; stix_oow_t i;
bigatom_t w; stix_lidw_t w;
bigatom_t borrow = 0; stix_lidw_t borrow = 0;
bigatom_t borrowed_word; stix_lidw_t borrowed_word;
STIX_ASSERT (!is_less_unsigned_array(x, xs, y, ys)); STIX_ASSERT (!is_less_unsigned_array(x, xs, y, ys));
borrowed_word = (bigatom_t)1 << ATOM_BITS; borrowed_word = (stix_lidw_t)1 << STIX_LIW_BITS;
for (i = 0; i < ys; i++) for (i = 0; i < ys; i++)
{ {
w = (bigatom_t)y[i] + borrow; w = (stix_lidw_t)y[i] + borrow;
if ((bigatom_t)x[i] >= w) if ((stix_lidw_t)x[i] >= w)
{ {
z[i] = x[i] - w; z[i] = x[i] - w;
borrow = 0; borrow = 0;
} }
else else
{ {
z[i] = (borrowed_word + (bigatom_t)x[i]) - w; z[i] = (borrowed_word + (stix_lidw_t)x[i]) - w;
borrow = 1; borrow = 1;
} }
} }
@ -444,12 +455,12 @@ static STIX_INLINE stix_oow_t subtract_unsigned_array (const atom_t* x, stix_oow
{ {
if (x[i] >= borrow) if (x[i] >= borrow)
{ {
z[i] = x[i] - (atom_t)borrow; z[i] = x[i] - (stix_liw_t)borrow;
borrow = 0; borrow = 0;
} }
else else
{ {
z[i] = (borrowed_word + (bigatom_t)x[i]) - borrow; z[i] = (borrowed_word + (stix_lidw_t)x[i]) - borrow;
borrow = 1; borrow = 1;
} }
} }
@ -458,15 +469,15 @@ static STIX_INLINE stix_oow_t subtract_unsigned_array (const atom_t* x, stix_oow
return i; return i;
} }
static STIX_INLINE void multiply_unsigned_array (const atom_t* x, stix_oow_t xs, const atom_t* y, stix_oow_t ys, atom_t* z) static STIX_INLINE void multiply_unsigned_array (const stix_liw_t* x, stix_oow_t xs, const stix_liw_t* y, stix_oow_t ys, stix_liw_t* z)
{ {
bigatom_t v; stix_lidw_t v;
stix_oow_t pa; stix_oow_t pa;
/* TODO: implement Karatsuba or Toom-Cook 3-way algorithm when the input length is long */ /* TODO: implement Karatsuba or Toom-Cook 3-way algorithm when the input length is long */
pa = (xs < ys)? xs: ys; pa = (xs < ys)? xs: ys;
if (pa <= ((stix_oow_t)1 << (BIGATOM_BITS - (ATOM_BITS * 2)))) if (pa <= ((stix_oow_t)1 << (STIX_LIDW_BITS - (STIX_LIW_BITS * 2))))
{ {
/* Comba(column-array) multiplication */ /* Comba(column-array) multiplication */
@ -487,18 +498,18 @@ static STIX_INLINE void multiply_unsigned_array (const atom_t* x, stix_oow_t xs,
for (iz = 0; iz < iy; iz++) for (iz = 0; iz < iy; iz++)
{ {
v = v + (bigatom_t)x[tx + iz] * (bigatom_t)y[ty - iz]; v = v + (stix_lidw_t)x[tx + iz] * (stix_lidw_t)y[ty - iz];
} }
z[ix] = (atom_t)v; z[ix] = (stix_liw_t)v;
v = v >> ATOM_BITS; v = v >> STIX_LIW_BITS;
} }
} }
else else
{ {
#if 1 #if 1
stix_oow_t i, j; stix_oow_t i, j;
atom_t carry; stix_liw_t carry;
for (i = 0; i < ys; i++) for (i = 0; i < ys; i++)
{ {
@ -511,9 +522,9 @@ static STIX_INLINE void multiply_unsigned_array (const atom_t* x, stix_oow_t xs,
carry = 0; carry = 0;
for (j = 0; j < xs; j++) for (j = 0; j < xs; j++)
{ {
v = (bigatom_t)x[j] * (bigatom_t)y[i] + (bigatom_t)carry + (bigatom_t)z[j + i]; v = (stix_lidw_t)x[j] * (stix_lidw_t)y[i] + (stix_lidw_t)carry + (stix_lidw_t)z[j + i];
z[j + i] = (atom_t)v; z[j + i] = (stix_liw_t)v;
carry = (atom_t)(v >> ATOM_BITS); carry = (stix_liw_t)(v >> STIX_LIW_BITS);
} }
z[xs + i] = carry; z[xs + i] = carry;
@ -522,7 +533,7 @@ static STIX_INLINE void multiply_unsigned_array (const atom_t* x, stix_oow_t xs,
#else #else
stix_oow_t i, j, idx; stix_oow_t i, j, idx;
atom_t carry; stix_liw_t carry;
for (i = 0; i < ys; i++) for (i = 0; i < ys; i++)
{ {
@ -530,17 +541,17 @@ static STIX_INLINE void multiply_unsigned_array (const atom_t* x, stix_oow_t xs,
for (j = 0; j < xs; j++) for (j = 0; j < xs; j++)
{ {
v = (bigatom_t)x[j] * (bigatom_t)y[i] + (bigatom_t)carry + (bigatom_t)z[idx]; v = (stix_lidw_t)x[j] * (stix_lidw_t)y[i] + (stix_lidw_t)carry + (stix_lidw_t)z[idx];
z[idx] = (atom_t)v; z[idx] = (stix_liw_t)v;
carry = (atom_t)(v >> ATOM_BITS); carry = (stix_liw_t)(v >> STIX_LIW_BITS);
idx++; idx++;
} }
while (carry > 0) while (carry > 0)
{ {
v = (bigatom_t)z[idx] + (bigatom_t)carry; v = (stix_lidw_t)z[idx] + (stix_lidw_t)carry;
z[idx] = (atom_t)v; z[idx] = (stix_liw_t)v;
carry = (atom_t)(v >> ATOM_BITS); carry = (stix_liw_t)(v >> STIX_LIW_BITS);
idx++; idx++;
} }
@ -549,9 +560,81 @@ static STIX_INLINE void multiply_unsigned_array (const atom_t* x, stix_oow_t xs,
} }
} }
static STIX_INLINE void lshift_unsigned_array (stix_liw_t* x, stix_oow_t xs, stix_oow_t bits)
{
/* this function doesn't grow/shrink the array. Shifting is performed
* over the given array */
stix_oow_t word_shifts, bit_shifts, bit_shifts_right;
stix_oow_t si, di;
/* get how many words to shift */
word_shifts = bits / STIX_LIW_BITS;
if (word_shifts >= xs)
{
STIX_MEMSET (x, 0, xs * STIX_SIZEOF(stix_liw_t));
return;
}
/* get how many remaining bits to shift */
bit_shifts = bits % STIX_LIW_BITS;
bit_shifts_right = STIX_LIW_BITS - bit_shifts;
/* shift words and bits */
di = xs - 1;
si = di - word_shifts;
x[di] = x[si] << bit_shifts;
while (di > word_shifts)
{
x[di] = x[di] | (x[--si] >> bit_shifts_right);
x[--di] = x[si] << bit_shifts;
}
/* fill the remaining part with zeros */
if (word_shifts > 0)
STIX_MEMSET (x, 0, word_shifts * STIX_SIZEOF(stix_liw_t));
}
static STIX_INLINE void rshift_unsigned_array (stix_liw_t* x, stix_oow_t xs, stix_oow_t bits)
{
/* this function doesn't grow/shrink the array. Shifting is performed
* over the given array */
stix_oow_t word_shifts, bit_shifts, bit_shifts_left;
stix_oow_t si, di, bound;
/* get how many words to shift */
word_shifts = bits / STIX_LIW_BITS;
if (word_shifts >= xs)
{
STIX_MEMSET (x, 0, xs * STIX_SIZEOF(stix_liw_t));
return;
}
/* get how many remaining bits to shift */
bit_shifts = bits % STIX_LIW_BITS;
bit_shifts_left = STIX_LIW_BITS - bit_shifts;
/* TODO: verify this function */
/* shift words and bits */
di = 0;
si = word_shifts;
x[di] = x[si] >> bit_shifts;
bound = xs - word_shifts - 1;
while (di < bound)
{
x[di] = x[di] | (x[++si] << bit_shifts_left);
x[++di] = x[si] >> bit_shifts;
}
/* fill the remaining part with zeros */
if (word_shifts > 0)
STIX_MEMSET (&x[xs - word_shifts], 0, word_shifts * STIX_SIZEOF(stix_liw_t));
}
static stix_oop_t add_unsigned_integers (stix_t* stix, stix_oop_t x, stix_oop_t y) static stix_oop_t add_unsigned_integers (stix_t* stix, stix_oop_t x, stix_oop_t y)
{ {
atom_t* a, * b; stix_liw_t* a, * b;
stix_oow_t as, bs, zs; stix_oow_t as, bs, zs;
stix_oop_t z; stix_oop_t z;
@ -566,16 +649,16 @@ static stix_oop_t add_unsigned_integers (stix_t* stix, stix_oop_t x, stix_oop_t
if (as >= bs) if (as >= bs)
{ {
a = ((oop_atom_t)x)->slot; a = ((stix_oop_liword_t)x)->slot;
b = ((oop_atom_t)y)->slot; b = ((stix_oop_liword_t)y)->slot;
} }
else else
{ {
a = ((oop_atom_t)y)->slot; a = ((stix_oop_liword_t)y)->slot;
b = ((oop_atom_t)x)->slot; b = ((stix_oop_liword_t)x)->slot;
} }
add_unsigned_array (a, as, b, bs, ((oop_atom_t)z)->slot); add_unsigned_array (a, as, b, bs, ((stix_oop_liword_t)z)->slot);
return z; return z;
} }
@ -591,9 +674,9 @@ static stix_oop_t subtract_unsigned_integers (stix_t* stix, stix_oop_t x, stix_o
stix_poptmps (stix, 2); stix_poptmps (stix, 2);
subtract_unsigned_array ( subtract_unsigned_array (
((oop_atom_t)x)->slot, STIX_OBJ_GET_SIZE(x), ((stix_oop_liword_t)x)->slot, STIX_OBJ_GET_SIZE(x),
((oop_atom_t)y)->slot, STIX_OBJ_GET_SIZE(y), ((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y),
((oop_atom_t)z)->slot); ((stix_oop_liword_t)z)->slot);
return z; return z;
} }
@ -607,9 +690,9 @@ static stix_oop_t multiply_unsigned_integers (stix_t* stix, stix_oop_t x, stix_o
stix_poptmps (stix, 2); stix_poptmps (stix, 2);
multiply_unsigned_array ( multiply_unsigned_array (
((oop_atom_t)x)->slot, STIX_OBJ_GET_SIZE(x), ((stix_oop_liword_t)x)->slot, STIX_OBJ_GET_SIZE(x),
((oop_atom_t)y)->slot, STIX_OBJ_GET_SIZE(y), ((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(y),
((oop_atom_t)z)->slot); ((stix_oop_liword_t)z)->slot);
return z; return z;
} }
@ -893,11 +976,22 @@ stix_oop_t stix_mulints (stix_t* stix, stix_oop_t x, stix_oop_t y)
printf ("MUL=>"); printf ("MUL=>");
for (i = STIX_OBJ_GET_SIZE(z); i > 0;) for (i = STIX_OBJ_GET_SIZE(z); i > 0;)
{ {
printf ("%016lX ", (unsigned long)((oop_atom_t)z)->slot[--i]); printf ("%0*lX ", (int)(STIX_SIZEOF(stix_liw_t) * 2), (unsigned long)((stix_oop_liword_t)z)->slot[--i]);
} }
printf ("\n"); printf ("\n");
} }
lshift_unsigned_array (((stix_oop_liword_t)z)->slot, STIX_OBJ_GET_SIZE(z), 16 * 5 + 4);
{ int i;
printf ("LSHIFT10=>");
for (i = STIX_OBJ_GET_SIZE(z); i > 0;)
{
printf ("%0*lX ", (int)(STIX_SIZEOF(stix_liw_t) * 2), (unsigned long)((stix_oop_liword_t)z)->slot[--i]);
}
printf ("\n");
}
return normalize_bigint (stix, z); return normalize_bigint (stix, z);
oops_einval: oops_einval:
@ -905,6 +999,11 @@ oops_einval:
return STIX_NULL; return STIX_NULL;
} }
stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, stix_oop_t* rem)
{
return STIX_NULL;
}
static stix_uint8_t ooch_val_tab[] = static stix_uint8_t ooch_val_tab[] =
{ {
99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
@ -921,8 +1020,8 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
{ {
int neg = 0; int neg = 0;
const stix_ooch_t* ptr, * start, * end; const stix_ooch_t* ptr, * start, * end;
bigatom_t w, v; stix_lidw_t w, v;
atom_t hw[16], * hwp = STIX_NULL; stix_liw_t hw[16], * hwp = STIX_NULL;
stix_oow_t hwlen, outlen; stix_oow_t hwlen, outlen;
stix_oop_t res; stix_oop_t res;
@ -1007,7 +1106,7 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
/* bytes */ /* bytes */
outlen = ((stix_oow_t)(end - str) * exp + 7) / 8; outlen = ((stix_oow_t)(end - str) * exp + 7) / 8;
/* number of atom_t */ /* number of stix_liw_t */
outlen = (outlen + STIX_SIZEOF(hw[0]) - 1) / STIX_SIZEOF(hw[0]); outlen = (outlen + STIX_SIZEOF(hw[0]) - 1) / STIX_SIZEOF(hw[0]);
if (outlen > STIX_COUNTOF(hw)) if (outlen > STIX_COUNTOF(hw))
@ -1032,35 +1131,35 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
w |= (v << bitcnt); w |= (v << bitcnt);
bitcnt += exp; bitcnt += exp;
if (bitcnt >= ATOM_BITS) if (bitcnt >= STIX_LIW_BITS)
{ {
bitcnt -= ATOM_BITS; bitcnt -= STIX_LIW_BITS;
hwp[hwlen++] = w; /*(atom_t)(w & STIX_LBMASK(bigatom_t, ATOM_BITS));*/ hwp[hwlen++] = w; /*(stix_liw_t)(w & STIX_LBMASK(stix_lidw_t, STIX_LIW_BITS));*/
w >>= ATOM_BITS; w >>= STIX_LIW_BITS;
} }
ptr--; ptr--;
} }
STIX_ASSERT (w <= STIX_TYPE_MAX(atom_t)); STIX_ASSERT (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
{ {
bigatom_t r1, r2; stix_lidw_t r1, r2;
atom_t multiplier; stix_liw_t multiplier;
int dg, i, safe_ndigits; int dg, i, safe_ndigits;
w = 0; w = 0;
ptr = start; ptr = start;
safe_ndigits = stix->bigint[radix].safe_ndigits; safe_ndigits = stix->bigint[radix].safe_ndigits;
multiplier = (atom_t)stix->bigint[radix].multiplier; multiplier = (stix_liw_t)stix->bigint[radix].multiplier;
outlen = (end - str) / safe_ndigits + 1; outlen = (end - str) / safe_ndigits + 1;
if (outlen > STIX_COUNTOF(hw)) if (outlen > STIX_COUNTOF(hw))
{ {
hwp = stix_allocmem (stix, outlen * STIX_SIZEOF(atom_t)); hwp = stix_allocmem (stix, outlen * STIX_SIZEOF(stix_liw_t));
if (!hwp) return STIX_NULL; if (!hwp) return STIX_NULL;
} }
else else
@ -1085,7 +1184,7 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
v = ooch_val_tab[*ptr]; v = ooch_val_tab[*ptr];
if (v >= radix) goto oops_einval; if (v >= radix) goto oops_einval;
r1 = r1 * radix + (atom_t)v; r1 = r1 * radix + (stix_liw_t)v;
ptr++; ptr++;
} }
@ -1093,24 +1192,24 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
r2 = r1; r2 = r1;
for (i = 0; i < hwlen; i++) for (i = 0; i < hwlen; i++)
{ {
atom_t high, low; stix_liw_t high, low;
v = (bigatom_t)hwp[i] * multiplier; v = (stix_lidw_t)hwp[i] * multiplier;
high = (atom_t)(v >> ATOM_BITS); high = (stix_liw_t)(v >> STIX_LIW_BITS);
low = (atom_t)(v /*& STIX_LBMASK(stix_oow_t, ATOM_BITS)*/); low = (stix_liw_t)(v /*& STIX_LBMASK(stix_oow_t, STIX_LIW_BITS)*/);
#if defined(atom_add_overflow) #if defined(liw_add_overflow)
/* use atom_add_overflow() only if it's compiler-builtin. */ /* use liw_add_overflow() only if it's compiler-builtin. */
r2 = high + atom_add_overflow(low, r2, &low); r2 = high + liw_add_overflow(low, r2, &low);
#else #else
/* don't use the fall-back version of atom_add_overflow() */ /* don't use the fall-back version of liw_add_overflow() */
low += r2; low += r2;
r2 = (bigatom_t)high + (low < r2); r2 = (stix_lidw_t)high + (low < r2);
#endif #endif
hwp[i] = low; hwp[i] = low;
} }
if (r2) hwp[hwlen++] = (atom_t)r2; if (r2) hwp[hwlen++] = (stix_liw_t)r2;
} }
while (ptr < end); while (ptr < end);
} }
@ -1118,13 +1217,13 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len,
{ int i; { int i;
for (i = hwlen; i > 0;) for (i = hwlen; i > 0;)
{ {
printf ("%08lx ", (unsigned long)hwp[--i]); printf ("%0*lx ", (int)(STIX_SIZEOF(stix_liw_t) * 2), (unsigned long)hwp[--i]);
} }
printf ("\n"); printf ("\n");
} }
STIX_ASSERT (hwlen >= 1); STIX_ASSERT (hwlen >= 1);
#if defined(USE_FULL_WORD) #if defined(STIX_USE_FULL_WORD)
if (hwlen == 1) if (hwlen == 1)
{ {
w = hwp[0]; w = hwp[0];

21
stix/lib/comp.c
View File

@ -91,6 +91,7 @@ static struct voca_t
{ 5, { 'f','a','l','s','e' } }, { 5, { 'f','a','l','s','e' } },
{ 8, { 'h','a','l','f','w','o','r','d' } }, { 8, { 'h','a','l','f','w','o','r','d' } },
{ 7, { 'i','n','c','l','u','d','e' } }, { 7, { 'i','n','c','l','u','d','e' } },
{ 6, { 'l','i','w','o','r','d' } },
{ 4, { 'm','a','i','n' } }, { 4, { 'm','a','i','n' } },
{ 6, { 'm','e','t','h','o','d' } }, { 6, { 'm','e','t','h','o','d' } },
{ 3, { 'm','t','h' } }, { 3, { 'm','t','h' } },
@ -123,6 +124,7 @@ enum voca_id_t
VOCA_FALSE, VOCA_FALSE,
VOCA_HALFWORD, VOCA_HALFWORD,
VOCA_INCLUDE, VOCA_INCLUDE,
VOCA_LIWORD,
VOCA_MAIN, VOCA_MAIN,
VOCA_METHOD, VOCA_METHOD,
VOCA_MTH, VOCA_MTH,
@ -306,7 +308,17 @@ static void set_syntax_error (stix_t* stix, stix_synerrnum_t num, const stix_iol
{ {
stix->errnum = STIX_ESYNTAX; stix->errnum = STIX_ESYNTAX;
stix->c->synerr.num = num; stix->c->synerr.num = num;
stix->c->synerr.loc = loc? *loc: stix->c->tok.loc;
/* The SCO compiler complains of this ternary operation saying:
* error: operands have incompatible types: op ":"
* it seems to complain of type mismatch between *loc and
* stix->c->tok.loc due to 'const' prefixed to loc. */
/*stix->c->synerr.loc = loc? *loc: stix->c->tok.loc;*/
if (loc)
stix->c->synerr.loc = *loc;
else
stix->c->synerr.loc = stix->c->tok.loc;
if (tgt) stix->c->synerr.tgt = *tgt; if (tgt) stix->c->synerr.tgt = *tgt;
else else
{ {
@ -4551,6 +4563,13 @@ static int __compile_class_definition (stix_t* stix, int extend)
stix->c->cls.indexed_type = STIX_OBJ_TYPE_OOP; stix->c->cls.indexed_type = STIX_OBJ_TYPE_OOP;
GET_TOKEN (stix); GET_TOKEN (stix);
} }
else if (is_token_symbol(stix, VOCA_LIWORD))
{
/* #class(#biatom) */
stix->c->cls.flags |= CLASS_INDEXED;
stix->c->cls.indexed_type = STIX_OBJ_TYPE_LIWORD;
GET_TOKEN (stix);
}
if (stix->c->tok.type != STIX_IOTOK_RPAREN) if (stix->c->tok.type != STIX_IOTOK_RPAREN)
{ {

9
stix/lib/ignite.c
View File

@ -145,13 +145,8 @@ static int ignite_1 (stix_t* stix)
* Does this make sense? */ * Does this make sense? */
stix->_character = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP)); 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->_small_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
#if defined(USE_FULL_WORD) stix->_large_positive_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_LIWORD));
stix->_large_positive_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_WORD)); stix->_large_negative_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_WORD));
#else
stix->_large_positive_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_HALFWORD));
stix->_large_negative_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_HALFWORD));
#endif
if (!stix->_apex || !stix->_undefined_object || if (!stix->_apex || !stix->_undefined_object ||
!stix->_object || !stix->_string || !stix->_object || !stix->_string ||

9
stix/lib/main.c
View File

@ -373,6 +373,7 @@ stix_ooch_t str_stix[] = { 'S', 't', 'i', 'x' };
stix_ooch_t str_my_object[] = { 'M', 'y', 'O', 'b','j','e','c','t' }; stix_ooch_t str_my_object[] = { 'M', 'y', 'O', 'b','j','e','c','t' };
stix_ooch_t str_main[] = { 'm', 'a', 'i', 'n' }; stix_ooch_t str_main[] = { 'm', 'a', 'i', 'n' };
int main (int argc, char* argv[]) int main (int argc, char* argv[])
{ {
stix_t* stix; stix_t* stix;
@ -382,12 +383,14 @@ int main (int argc, char* argv[])
stix_vmprim_t vmprim; stix_vmprim_t vmprim;
int i; int i;
printf ("Stix 1.0.0 - max named %lu max indexed %lu max class %lu max classinst %lu oowmax %lu, smintmax %ld smintmax %ld\n", printf ("Stix 1.0.0 - max named %lu max indexed %lu max class %lu max classinst %lu oowmax %lu, ooimax %ld ooimin %ld smintmax %ld smintmax %ld\n",
(unsigned long int)STIX_MAX_NAMED_INSTVARS, (unsigned long int)STIX_MAX_NAMED_INSTVARS,
(unsigned long int)STIX_MAX_INDEXED_INSTVARS(STIX_MAX_NAMED_INSTVARS), (unsigned long int)STIX_MAX_INDEXED_INSTVARS(STIX_MAX_NAMED_INSTVARS),
(unsigned long int)STIX_MAX_CLASSVARS, (unsigned long int)STIX_MAX_CLASSVARS,
(unsigned long int)STIX_MAX_CLASSINSTVARS, (unsigned long int)STIX_MAX_CLASSINSTVARS,
(unsigned long int)STIX_TYPE_MAX(stix_oow_t), (unsigned long int)STIX_TYPE_MAX(stix_oow_t),
(long int)STIX_TYPE_MAX(stix_ooi_t),
(long int)STIX_TYPE_MIN(stix_ooi_t),
(long)STIX_SMOOI_MAX, (long)STIX_SMOOI_MIN); (long)STIX_SMOOI_MAX, (long)STIX_SMOOI_MIN);
printf ("STIX_SMOOI_MIN + STIX_SMOOI_MIN => %ld\n", (long)(STIX_SMOOI_MIN + STIX_SMOOI_MIN)); printf ("STIX_SMOOI_MIN + STIX_SMOOI_MIN => %ld\n", (long)(STIX_SMOOI_MIN + STIX_SMOOI_MIN));
@ -438,9 +441,6 @@ int main (int argc, char* argv[])
} }
{ {
stix_oow_t tab_size; stix_oow_t tab_size;
@ -464,7 +464,6 @@ int main (int argc, char* argv[])
return -1; return -1;
} }
{ {
/*const stix_bch_t* xxx = "9999999999999999999999999999999999999999999999999999999999999999999999999999999999";*/ /*const stix_bch_t* xxx = "9999999999999999999999999999999999999999999999999999999999999999999999999999999999";*/

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

@ -54,10 +54,6 @@
/*#define STIX_DEBUG_EXEC*/ /*#define STIX_DEBUG_EXEC*/
#define STIX_PROFILE_EXEC #define STIX_PROFILE_EXEC
#if STIX_SIZEOF_UINTMAX_T > STIX_SIZEOF_OOW_T
# define USE_FULL_WORD
#endif
#include <stdio.h> /* TODO: delete these header inclusion lines */ #include <stdio.h> /* TODO: delete these header inclusion lines */
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
@ -103,28 +99,6 @@
#define STIX_ALIGN(x,y) ((((x) + (y) - 1) / (y)) * (y)) #define STIX_ALIGN(x,y) ((((x) + (y) - 1) / (y)) * (y))
/* ========================================================================= */
/* BIGINT TYPES AND MACROS */
/* ========================================================================= */
#if defined(USE_FULL_WORD)
typedef stix_uintmax_t bigatom_t;
typedef stix_oow_t atom_t;
typedef stix_oop_word_t oop_atom_t;
# define SIZEOF_ATOM_T STIX_SIZEOF_OOW_T
# define SIZEOF_BIGATOM_T STIX_SIZEOF_UINTMAX_T
# define ATOM_BITS STIX_OOW_BITS
# define BIGATOM_BITS (STIX_SIZEOF_UINTMAX_T * 8)
#else
typedef stix_oow_t bigatom_t;
typedef stix_oohw_t atom_t;
typedef stix_oop_halfword_t oop_atom_t;
# define SIZEOF_ATOM_T STIX_SIZEOF_OOHW_T
# define SIZEOF_BIGATOM_T STIX_SIZEOF_OOW_T
# define ATOM_BITS STIX_OOHW_BITS
# define BIGATOM_BITS STIX_OOW_BITS
# define MAKE_WORD(hw1,hw2) ((stix_oow_t)(hw1) | (stix_oow_t)(hw2) << ATOM_BITS)
#endif
/* ========================================================================= */ /* ========================================================================= */
/* CLASS SPEC ENCODING */ /* CLASS SPEC ENCODING */
/* ========================================================================= */ /* ========================================================================= */
@ -1115,6 +1089,13 @@ stix_oop_t stix_mulints (
stix_oop_t y stix_oop_t y
); );
stix_oop_t stix_divints (
stix_t* stix,
stix_oop_t x,
stix_oop_t y,
stix_oop_t* rem
);
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,

2
stix/lib/stix.c
View File

@ -65,7 +65,7 @@ static void fill_bigint_tables (stix_t* stix)
for (radix = 2; radix <= 36; radix++) for (radix = 2; radix <= 36; radix++)
{ {
w = 0; w = 0;
ub = (stix_oow_t)STIX_TYPE_MAX(atom_t) / radix - (radix - 1); ub = (stix_oow_t)STIX_TYPE_MAX(stix_liw_t) / radix - (radix - 1);
multiplier = 1; multiplier = 1;
safe_ndigits = 0; safe_ndigits = 0;

33
stix/lib/stix.h
View File

@ -97,6 +97,39 @@ typedef struct stix_obj_word_t* stix_oop_word_t;
#define STIX_OOP_BITS (STIX_SIZEOF_OOP_T * 8) #define STIX_OOP_BITS (STIX_SIZEOF_OOP_T * 8)
#define STIX_OOHW_BITS (STIX_SIZEOF_OOHW_T * 8) #define STIX_OOHW_BITS (STIX_SIZEOF_OOHW_T * 8)
/* ========================================================================= */
/* BIGINT TYPES AND MACROS */
/* ========================================================================= */
#if STIX_SIZEOF_UINTMAX_T > STIX_SIZEOF_OOW_T
# define STIX_USE_FULL_WORD
#endif
#if defined(STIX_USE_FULL_WORD)
typedef stix_oow_t stix_liw_t; /* large integer word */
typedef stix_uintmax_t stix_lidw_t; /* large integer double word */
# define STIX_SIZEOF_LIW_T STIX_SIZEOF_OOW_T
# define STIX_SIZEOF_LIDW_T STIX_SIZEOF_UINTMAX_T
# define STIX_LIW_BITS STIX_OOW_BITS
# define STIX_LIDW_BITS (STIX_SIZEOF_UINTMAX_T * 8)
typedef stix_oop_word_t stix_oop_liword_t;
# define STIX_OBJ_TYPE_LIWORD STIX_OBJ_TYPE_WORD
#else
typedef stix_oohw_t stix_liw_t;
typedef stix_oow_t stix_lidw_t;
# define STIX_SIZEOF_LIW_T STIX_SIZEOF_OOHW_T
# define STIX_SIZEOF_LIDW_T STIX_SIZEOF_OOW_T
# define STIX_LIW_BITS STIX_OOHW_BITS
# define STIX_LIDW_BITS STIX_OOW_BITS
typedef stix_oop_halfword_t stix_oop_liword_t;
# define STIX_OBJ_TYPE_LIWORD STIX_OBJ_TYPE_HALFWORD
#endif
/* /*
* OOP encoding * OOP encoding
* An object pointer(OOP) is an ordinary pointer value to an object. * An object pointer(OOP) is an ordinary pointer value to an object.