diff --git a/stix/kernel/test-005.st b/stix/kernel/test-005.st index 2533f97..ee7b745 100644 --- a/stix/kernel/test-005.st +++ b/stix/kernel/test-005.st @@ -294,13 +294,13 @@ PROCESS TESTING ##(0 \\ -50000000000000000000000000000000000000000000000000000000000000000000) dump. ##(0 // -50000000000000000000000000000000000000000000000000000000000000000000) dump. -(-270000000000000000000000000000000000000000000000000000000000000000000 rem: -1) dump. -(-270000000000000000000000000000000000000000000000000000000000000000000 quo: -1) dump. -(-270000000000000000000000000000000000000000000000000000000000000000000 \\ -1) dump. -(-270000000000000000000000000000000000000000000000000000000000000000000 // -1) dump. +##(-270000000000000000000000000000000000000000000000000000000000000000000 rem: -1) dump. +##(-270000000000000000000000000000000000000000000000000000000000000000000 quo: -1) dump. +##(-270000000000000000000000000000000000000000000000000000000000000000000 \\ -1) dump. +##(-270000000000000000000000000000000000000000000000000000000000000000000 // -1) dump. ## (-27029038 // 2) asString dump. -(-270290380000000000000000000000000000000000000000000000000000000000000000000000000000000000000 // 2) asString dump. +## (-270290380000000000000000000000000000000000000000000000000000000000000000000000000000000000000 // 2) asString dump. ##(-16rAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFF) asString dump. ## (16r2dd01fc06c265c8163ac729b49d890939826ce3dd quo: 16r3b9aca00) dump. @@ -321,7 +321,10 @@ PROCESS TESTING ##(-270 // 5) dump. ##(16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF bitAnd: 16r1111111111111111111111111111111111111111) dump. -(16rF0FFFF bitOr: 16r111111) dump. + +(2r1111111111111111111111111111111111111111111111111111111111111111 printStringRadix:2) dump. + +"(16rF0FFFF bitOr: 16r111111) dump. (16r11 bitOr: 16r20000000000000000000000000000000FFFFFFFFFFFFFFFF11111100000000000000000001) dump. ((16r11 bitOr: 16r20000000000000000000000000000000FFFFFFFFFFFFFFFF11111100000000000000000001) bitOr: 16r1100) dump. @@ -332,6 +335,24 @@ PROCESS TESTING ((2r11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 bitXor: 2r11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111) printStringRadix: 2) dump. ((2r10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101 bitAnd: 2r01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010) printStringRadix: 2) dump. +" + +(16rFFFFFFFFFFFFFFFF bitOr: 16rFFFFFFFFFFFFFFFFFFFFFFFF) dump. +(-16rFFFFFFFFFFFFFFFF bitOr: 16rFFFFFFFFFFFFFFFFFFFFFFFF) dump. +(16rFFFFFFFFFFFFFFFF bitOr: -16rFFFFFFFFFFFFFFFFFFFFFFFF) dump. +(-16rFFFFFFFFFFFFFFFF bitOr: -16rFFFFFFFFFFFFFFFFFFFFFFFF) dump. + + +((16rFFFFFFF bitXor: -16rFFFFFFF) printStringRadix: 16) dump. +((16r1234 bitXor: -16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) printStringRadix: 16) dump. +((16r1234 bitXor: 2r1111111111111111111111111111111111111111111111111111111111111) printStringRadix: 16) dump. + +((16r1234 bitXor: 2r100000000000000000000000000000000000000000000000000000000000000000000000000000) printStringRadix: 16) dump. +((-16r1234 bitXor: 2r100000000000000000000000000000000000000000000000000000000000000000000000000000) printStringRadix: 16) dump. +((16r1234 bitXor: -2r100000000000000000000000000000000000000000000000000000000000000000000000000000) printStringRadix: 16) dump. +((-16r1234 bitXor: -2r100000000000000000000000000000000000000000000000000000000000000000000000000000) printStringRadix: 16) dump. + + " FFI isNil dump. FFI notNil dump. diff --git a/stix/lib/bigint.c b/stix/lib/bigint.c index ff0fd75..3da5689 100644 --- a/stix/lib/bigint.c +++ b/stix/lib/bigint.c @@ -243,7 +243,7 @@ printf ("\n"); return stix_instantiate (stix, ((v >= 0)? stix->_large_positive_integer: stix->_large_negative_integer), buf, len); } -static STIX_INLINE stix_oop_t clone_bigint (stix_t* stix, stix_oop_t oop, stix_oow_t count) +static STIX_INLINE stix_oop_t _clone_bigint (stix_t* stix, stix_oop_t oop, stix_oow_t count, stix_oop_t _class) { stix_oop_t z; stix_oow_t i; @@ -252,7 +252,7 @@ static STIX_INLINE stix_oop_t clone_bigint (stix_t* stix, stix_oop_t oop, stix_o if (count <= 0) count = STIX_OBJ_GET_SIZE(oop); stix_pushtmp (stix, &oop); - z = stix_instantiate (stix, STIX_OBJ_GET_CLASS(oop), STIX_NULL, count); + z = stix_instantiate (stix, _class, STIX_NULL, count); stix_poptmp (stix); if (!z) return STIX_NULL; @@ -263,29 +263,32 @@ static STIX_INLINE stix_oop_t clone_bigint (stix_t* stix, stix_oop_t oop, stix_o return z; } +static STIX_INLINE stix_oop_t clone_bigint (stix_t* stix, stix_oop_t oop, stix_oow_t count) +{ + return _clone_bigint (stix, oop, count, STIX_OBJ_GET_CLASS(oop)); +} + static STIX_INLINE stix_oop_t clone_bigint_negated (stix_t* stix, stix_oop_t oop, stix_oow_t count) { - stix_oop_t z, c; - stix_oow_t i; + stix_oop_t c; STIX_ASSERT (STIX_OOP_IS_POINTER(oop)); - if (count <= 0) count = STIX_OBJ_GET_SIZE(oop); - if (STIX_OBJ_GET_CLASS(oop) == stix->_large_positive_integer) - c = stix->_large_negative_integer; - else - c = stix->_large_positive_integer; - - stix_pushtmp (stix, &oop); - z = stix_instantiate (stix, c, STIX_NULL, count); - stix_poptmp (stix); - if (!z) return STIX_NULL; - - for (i = 0; i < count; i++) { - ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)oop)->slot[i]; + c = stix->_large_negative_integer; } - return z; + else + { + STIX_ASSERT (STIX_OBJ_GET_CLASS(oop) == stix->_large_negative_integer); + c = stix->_large_positive_integer; + } + + return _clone_bigint (stix, oop, count, c); +} + +static STIX_INLINE stix_oop_t clone_bigint_to_positive (stix_t* stix, stix_oop_t oop, stix_oow_t count) +{ + return _clone_bigint (stix, oop, count, stix->_large_positive_integer); } static STIX_INLINE stix_oow_t count_effective (stix_liw_t* x, stix_oow_t xs) @@ -419,6 +422,34 @@ static STIX_INLINE int is_equal (stix_t* stix, stix_oop_t x, stix_oop_t y) STIX_MEMCMP(((stix_oop_liword_t)x)->slot, ((stix_oop_liword_t)y)->slot, STIX_OBJ_GET_SIZE(x) * STIX_SIZEOF(stix_liw_t)) == 0; } +static void complement2_unsigned_array (const stix_liw_t* x, stix_oow_t xs, stix_liw_t* z) +{ + stix_oow_t i; + stix_lidw_t w; + stix_lidw_t carry; + + /* get 2's complement (~x + 1) */ + + carry = 1; + for (i = 0; i < xs; i++) + { + w = (stix_lidw_t)(~x[i]) + carry; + /*w = (stix_lidw_t)(x[i] ^ STIX_TYPE_MAX(stix_liw_t)) + carry;*/ + carry = w >> STIX_LIW_BITS; + z[i] = w; + } + + /* if the array pointed to by x contains all zeros, carry will be + * 1 here and it actually requires 1 more slot. Let't take this 8-bit + * zero for instance: + * 2r00000000 -> 2r11111111 + 1 => 2r0000000100000000 + * + * this function is not designed to handle such a case. + * in fact, 0 is a small integer and it must not stand a change + * to be given to this function */ + STIX_ASSERT (carry == 0); +} + 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; @@ -831,7 +862,6 @@ stix_oop_t stix_addints (stix_t* stix, stix_oop_t x, stix_oop_t y) stix_pushtmp (stix, &y); x = make_bigint_with_ooi (stix, v); stix_poptmp (stix); - if (!x) return STIX_NULL; } else if (STIX_OOP_IS_SMOOI(y)) @@ -844,7 +874,6 @@ stix_oop_t stix_addints (stix_t* stix, stix_oop_t x, stix_oop_t y) stix_pushtmp (stix, &x); y = make_bigint_with_ooi (stix, v); stix_poptmp (stix); - if (!y) return STIX_NULL; } else @@ -940,8 +969,8 @@ stix_oop_t stix_subints (stix_t* stix, stix_oop_t x, stix_oop_t y) stix_pushtmp (stix, &y); x = make_bigint_with_ooi (stix, v); - if (!x) return STIX_NULL; stix_poptmp (stix); + if (!x) return STIX_NULL; } else if (STIX_OOP_IS_SMOOI(y)) { @@ -952,8 +981,8 @@ stix_oop_t stix_subints (stix_t* stix, stix_oop_t x, stix_oop_t y) stix_pushtmp (stix, &x); y = make_bigint_with_ooi (stix, v); - if (!y) return STIX_NULL; stix_poptmp (stix); + if (!y) return STIX_NULL; } else { @@ -1057,7 +1086,6 @@ stix_oop_t stix_mulints (stix_t* stix, stix_oop_t x, stix_oop_t y) stix_pushtmp (stix, &y); x = make_bigint_with_ooi (stix, v); stix_poptmp (stix); - if (!x) return STIX_NULL; } else if (STIX_OOP_IS_SMOOI(y)) @@ -1078,7 +1106,6 @@ stix_oop_t stix_mulints (stix_t* stix, stix_oop_t x, stix_oop_t y) stix_pushtmp (stix, &x); y = make_bigint_with_ooi (stix, v); stix_poptmp (stix); - if (!y) return STIX_NULL; } else @@ -1224,6 +1251,7 @@ stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, s stix_pushtmp (stix, &y); x = make_bigint_with_ooi (stix, v); stix_poptmp (stix); + if (!x) return STIX_NULL; } else if (STIX_OOP_IS_SMOOI(y)) { @@ -1268,6 +1296,7 @@ stix_oop_t stix_divints (stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, s stix_pushtmp (stix, &x); y = make_bigint_with_ooi (stix, v); stix_poptmp (stix); + if (!y) return STIX_NULL; } else { @@ -1353,103 +1382,210 @@ oops_einval: stix_oop_t stix_bitandints (stix_t* stix, stix_oop_t x, stix_oop_t y) { -/* TODO: revisit negative number handling. 2's complement? sign bit */ if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y)) { - stix_ooi_t v1, v2, v3, sign; + stix_ooi_t v1, v2, v3; - sign = 1; v1 = STIX_OOP_TO_SMOOI(x); v2 = STIX_OOP_TO_SMOOI(y); + v3 = v1 & v2; - if (v1 < 0) - { - v1 = -v1; - if (v2 < 0) - { - v2 = -v2; - sign = -1; - } - } - else if (v2 < 0) - { - v2 = -v2; - } - - v3 = (stix_ooi_t)((stix_oow_t)v1 & (stix_oow_t)v2); - return STIX_SMOOI_TO_OOP(v3 * sign); + if (STIX_IN_SMOOI_RANGE(v3)) return STIX_SMOOI_TO_OOP(v3); + return make_bigint_with_ooi (stix, v3); } else if (STIX_OOP_IS_SMOOI(x)) { - stix_ooi_t v1, v3, sign; - stix_oow_t w2; + stix_ooi_t v; - smooi_and_large: - if (!is_integer(stix,y)) goto oops_einval; + if (!is_integer(stix, y)) goto oops_einval; - sign = 1; - v1 = STIX_OOP_TO_SMOOI(x); - if (v1 < 0) - { - v1 = -v1; - if (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer) sign = -1; - } + v = STIX_OOP_TO_SMOOI(x); + if (v == 0) return STIX_SMOOI_TO_OOP(0); - #if (STIX_LIW_BITS == STIX_OOW_BITS) - w2 = ((stix_oop_liword_t)y)->slot[0]; - #elif (STIX_LIW_BITS == STIX_OOHW_BITS) - STIX_ASSERT (STIX_OBJ_GET_SIZE(y) >= 2); - w2 = MAKE_WORD(((stix_oop_liword_t)y)->slot[0], ((stix_oop_liword_t)y)->slot[1]); - #else - # error UNSUPPORTED LIW BIT SIZE - #endif + stix_pushtmp (stix, &y); + x = make_bigint_with_ooi (stix, v); + stix_poptmp (stix); + if (!x) return STIX_NULL; - v3 = (stix_ooi_t)((stix_oow_t)v1 & w2); - return STIX_SMOOI_TO_OOP(v3 * sign); + goto bigint_and_bigint; } else if (STIX_OOP_IS_SMOOI(y)) { - stix_oop_t z; + stix_ooi_t v; - z = x; - x = y; - y = z; + if (!is_integer(stix, x)) goto oops_einval; - goto smooi_and_large; + v = STIX_OOP_TO_SMOOI(y); + if (v == 0) return STIX_SMOOI_TO_OOP(0); + + stix_pushtmp (stix, &x); + y = make_bigint_with_ooi (stix, v); + stix_poptmp (stix); + if (!x) return STIX_NULL; + + goto bigint_and_bigint; } else { - stix_oow_t xs, ys, zs; stix_oop_t z; + stix_oow_t i, xs, ys, zs, zalloc; + int negx, negy; - if (!is_integer(stix,x)) goto oops_einval; - if (!is_integer(stix,y)) goto oops_einval; + if (!is_integer(stix,x) || !is_integer(stix, y)) goto oops_einval; + bigint_and_bigint: xs = STIX_OBJ_GET_SIZE(x); ys = STIX_OBJ_GET_SIZE(y); - zs = (xs < ys)? xs: ys; + if (xs < ys) + { + /* make sure that x is greater than or equal to y */ + z = x; + x = y; + y = z; + zs = ys; + ys = xs; + xs = zs; + } + + negx = (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? 1: 0; + negy = (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer)? 1: 0; + + if (negx && negy) + { + zalloc = xs + 1; + zs = xs; + } + else if (negx) + { + zalloc = ys; + zs = ys; + } + else if (negy) + { + zalloc = xs; + zs = xs; + } + else + { + zalloc = ys; + zs = ys; + } + stix_pushtmp (stix, &x); stix_pushtmp (stix, &y); - z = stix_instantiate (stix, stix->_large_positive_integer, 0, zs); + z = stix_instantiate (stix, stix->_large_positive_integer, STIX_NULL, zalloc); stix_poptmps (stix, 2); if (!z) return STIX_NULL; - while (zs > 0) + if (negx && negy) { - --zs; - ((stix_oop_liword_t)z)->slot[zs] = ((stix_oop_liword_t)x)->slot[zs] & ((stix_oop_liword_t)y)->slot[zs]; + /* both are negative */ + stix_lidw_t w[2]; + stix_lidw_t carry[2]; + + carry[0] = 1; + carry[1] = 1; + /* 2's complement on both x and y and perform bitwise-and */ + for (i = 0; i < ys; i++) + { + w[0] = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry[0]; + carry[0] = w[0] >> STIX_LIW_BITS; + + w[1] = (stix_lidw_t)(~((stix_oop_liword_t)y)->slot[i]) + carry[1]; + carry[1] = w[1] >> STIX_LIW_BITS; + + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] & (stix_liw_t)w[1]; + } + STIX_ASSERT (carry[1] == 0); + + /* 2's complement on the remaining part of x. the lacking part + * in y is treated as if they are all 1s. */ + for (; i < xs; i++) + { + w[0] = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry[0]; + carry[0] = w[0] >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0]; + } + STIX_ASSERT (carry[0] == 0); + + /* 2's complement on the final result */ + ((stix_oop_liword_t)z)->slot[zs] = STIX_TYPE_MAX(stix_liw_t); + carry[0] = 1; + for (i = 0; i <= zs; i++) + { + w[0] = (stix_lidw_t)(~((stix_oop_liword_t)z)->slot[i]) + carry[0]; + carry[0] = w[0] >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0]; + } + STIX_ASSERT (carry[0] == 0); + + STIX_OBJ_SET_CLASS (z, stix->_large_negative_integer); + } + else if (negx) + { + /* x is negative, y is positive */ + stix_lidw_t w, carry; + + carry = 1; + for (i = 0; i < ys; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w & ((stix_oop_liword_t)y)->slot[i]; + } + + /* the lacking part in y is all 0's. the remaining part in x is + * just masked out when bitwise-anded with 0. so nothing is done + * to handle the remaining part in x */ + } + else if (negy) + { + /* x is positive, y is negative */ + stix_lidw_t w, carry; + + /* x & 2's complement on y up to ys */ + carry = 1; + for (i = 0; i < ys; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)y)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] & (stix_liw_t)w; + } + STIX_ASSERT (carry == 0); + + /* handle the longer part in x than y + * + * For example, + * x => + 1010 1100 + * y => - 0011 + * + * If y is extended to the same length as x, + * it is a negative 0000 0001. + * 2's complement is performed on this imaginary extension. + * the result is '1111 1101' (1111 1100 + 1). + * + * when y is shorter and negative, the lacking part can be + * treated as all 1s in the 2's complement format. + * + * the remaining part in x can be just copied to the + * final result 'z'. + */ + for (; i < xs; i++) + { + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i]; + } + } + else + { + /* both are positive */ + for (i = 0; i < ys; i++) + { + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] & ((stix_oop_liword_t)y)->slot[i]; + } } - if (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer && - STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer) - { - STIX_OBJ_SET_CLASS(z, stix->_large_negative_integer); - } - - /* for example, 16r1010101010... bitAnd: 16r0101010101... procduces 0. - * so normalization is needed */ - return normalize_bigint (stix, z); + return normalize_bigint(stix, z); } oops_einval: @@ -1459,99 +1595,64 @@ oops_einval: stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y) { -/* TODO: revisit negative number handling. 2's complement? sign bit */ if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y)) { - stix_ooi_t v1, v2, v3, sign; + stix_ooi_t v1, v2, v3; - sign = 1; v1 = STIX_OOP_TO_SMOOI(x); v2 = STIX_OOP_TO_SMOOI(y); + v3 = v1 | v2; - if (v1 < 0) - { - v1 = -v1; - sign = -1; - } - - if (v2 < 0) - { - v2 = -v2; - sign = -1; - } - - v3 = (stix_ooi_t)((stix_oow_t)v1 | (stix_oow_t)v2); - return STIX_SMOOI_TO_OOP(v3 * sign); + if (STIX_IN_SMOOI_RANGE(v3)) return STIX_SMOOI_TO_OOP(v3); + return make_bigint_with_ooi (stix, v3); } else if (STIX_OOP_IS_SMOOI(x)) { - stix_oop_t z; stix_ooi_t v; - int neg; - smooi_and_large: - if (!is_integer(stix,y)) goto oops_einval; + if (!is_integer(stix, y)) goto oops_einval; - neg = 0; v = STIX_OOP_TO_SMOOI(x); + if (v == 0) return clone_bigint(stix, y, STIX_OBJ_GET_SIZE(y)); - if (v < 0) - { - v = -v; - neg = 1; - } + stix_pushtmp (stix, &y); + x = make_bigint_with_ooi (stix, v); + stix_poptmp (stix); + if (!x) return STIX_NULL; - z = clone_bigint (stix, y, STIX_OBJ_GET_SIZE(y)); - if (!z) return STIX_NULL; - - #if STIX_LIW_BITS == STIX_OOW_BITS - ((stix_oop_liword_t)z)->slot[0] |= (stix_oow_t)v; - #elif STIX_LIW_BITS == STIX_OOHW_BITS - STIX_ASSERT (STIX_OBJ_GET_SIZE(z) >= 2); - ((stix_oop_liword_t)z)->slot[0] |= ((stix_oow_t)v & STIX_LBMASK(stix_oow_t, STIX_OOHW_BITS)); - ((stix_oop_liword_t)z)->slot[1] |= ((stix_oow_t)v >> STIX_OOHW_BITS); - #else - # error UNSUPPORTED LIW BIT SIZE - #endif - - if (neg || STIX_OBJ_GET_CLASS(z) == stix->_large_negative_integer) - { - STIX_OBJ_SET_CLASS(z, stix->_large_negative_integer); - } - else - { - STIX_OBJ_SET_CLASS(z, stix->_large_positive_integer); - } - return z; + goto bigint_and_bigint; } else if (STIX_OOP_IS_SMOOI(y)) { - stix_oop_t z; + stix_ooi_t v; - z = x; - x = y; - y = z; + if (!is_integer(stix, x)) goto oops_einval; - goto smooi_and_large; + v = STIX_OOP_TO_SMOOI(y); + if (v == 0) return clone_bigint(stix, x, STIX_OBJ_GET_SIZE(x)); + + stix_pushtmp (stix, &x); + y = make_bigint_with_ooi (stix, v); + stix_poptmp (stix); + if (!x) return STIX_NULL; + + goto bigint_and_bigint; } else { stix_oop_t z; - stix_oow_t xs, ys, zs; + stix_oow_t i, xs, ys, zs, zalloc; + int negx, negy; - if (!is_integer(stix,x)) goto oops_einval; - if (!is_integer(stix,y)) goto oops_einval; + if (!is_integer(stix,x) || !is_integer(stix, y)) goto oops_einval; + bigint_and_bigint: xs = STIX_OBJ_GET_SIZE(x); ys = STIX_OBJ_GET_SIZE(y); - if (xs > ys) + if (xs < ys) { - zs = xs; - } - else - { - /* swap x and y */ + /* make sure that x is greater than or equal to y */ z = x; x = y; y = z; @@ -1560,31 +1661,142 @@ stix_oop_t stix_bitorints (stix_t* stix, stix_oop_t x, stix_oop_t y) xs = zs; } + negx = (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? 1: 0; + negy = (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer)? 1: 0; + + if (negx && negy) + { + zalloc = ys + 1; + zs = ys; + } + else if (negx) + { + zalloc = xs + 1; + zs = xs; + } + else if (negy) + { + zalloc = ys + 1; + zs = ys; + } + else + { + zalloc = xs; + zs = xs; + } + stix_pushtmp (stix, &x); stix_pushtmp (stix, &y); - z = stix_instantiate (stix, stix->_large_positive_integer, 0, zs); + z = stix_instantiate (stix, stix->_large_positive_integer, STIX_NULL, zalloc); stix_poptmps (stix, 2); if (!z) return STIX_NULL; - while (zs > ys) + if (negx && negy) { - --zs; - ((stix_oop_liword_t)z)->slot[zs] = ((stix_oop_liword_t)x)->slot[zs]; + /* both are negative */ + stix_lidw_t w[2]; + stix_lidw_t carry[2]; + + carry[0] = 1; + carry[1] = 1; + /* 2's complement on both x and y and perform bitwise-and */ + for (i = 0; i < ys; i++) + { + w[0] = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry[0]; + carry[0] = w[0] >> STIX_LIW_BITS; + + w[1] = (stix_lidw_t)(~((stix_oop_liword_t)y)->slot[i]) + carry[1]; + carry[1] = w[1] >> STIX_LIW_BITS; + + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] | (stix_liw_t)w[1]; + } + STIX_ASSERT (carry[1] == 0); + + /* do nothing about the extra part in x and the lacking part + * in y for the reason shown in [NOTE] in the 'else if' block + * further down. */ + + adjust_to_negative: + /* 2's complement on the final result */ + ((stix_oop_liword_t)z)->slot[zs] = STIX_TYPE_MAX(stix_liw_t); + carry[0] = 1; + for (i = 0; i <= zs; i++) + { + w[0] = (stix_lidw_t)(~((stix_oop_liword_t)z)->slot[i]) + carry[0]; + carry[0] = w[0] >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0]; + } + STIX_ASSERT (carry[0] == 0); + + STIX_OBJ_SET_CLASS (z, stix->_large_negative_integer); } - while (zs > 0) + else if (negx) { - --zs; - ((stix_oop_liword_t)z)->slot[zs] = ((stix_oop_liword_t)x)->slot[zs] | ((stix_oop_liword_t)y)->slot[zs]; + /* x is negative, y is positive */ + stix_lidw_t w, carry; + + carry = 1; + for (i = 0; i < ys; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w | ((stix_oop_liword_t)y)->slot[i]; + } + + for (; i < xs; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w; + } + + STIX_ASSERT (carry == 0); + goto adjust_to_negative; + } + else if (negy) + { + /* x is positive, y is negative */ + stix_lidw_t w, carry; + + /* x & 2's complement on y up to ys */ + carry = 1; + for (i = 0; i < ys; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)y)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] | (stix_liw_t)w; + } + STIX_ASSERT (carry == 0); + + /* [NOTE] + * in theory, the lacking part in ys is all 1s when y is + * extended to the width of x. but those 1s are inverted to + * 0s when another 2's complement is performed over the final + * result after the jump to 'adjust_to_negative'. + * setting zs to 'xs + 1' and performing the following loop is + * redundant. + for (; i < xs; i++) + { + ((stix_oop_liword_t)z)->slot[i] = STIX_TYPE_MAX(stix_liw_t); + } + */ + goto adjust_to_negative; + } + else + { + /* both are positive */ + for (i = 0; i < ys; i++) + { + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] | ((stix_oop_liword_t)y)->slot[i]; + } + + for (; i < xs; i++) + { + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i]; + } } - if (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer || - STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer) - { - STIX_OBJ_SET_CLASS(z, stix->_large_negative_integer); - } - - /* no normalization is needed */ - return z; + return normalize_bigint(stix, z); } oops_einval: @@ -1596,103 +1808,62 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y) { if (STIX_OOP_IS_SMOOI(x) && STIX_OOP_IS_SMOOI(y)) { - stix_ooi_t v[3], sign[2]; + stix_ooi_t v1, v2, v3; - sign[0] = 1; - sign[1] = 1; - v[0] = STIX_OOP_TO_SMOOI(x); - v[1] = STIX_OOP_TO_SMOOI(y); + v1 = STIX_OOP_TO_SMOOI(x); + v2 = STIX_OOP_TO_SMOOI(y); + v3 = v1 ^ v2; - if (v[0] < 0) - { - v[0] = -v[0]; - sign[0] = -1; - } - - if (v[1] < 0) - { - v[1] = -v[1]; - sign[1] = -1; - } - - v[2] = (stix_ooi_t)((stix_oow_t)v[0] ^ (stix_oow_t)v[1]); - return STIX_SMOOI_TO_OOP(v[2] * sign[0] * sign[1]); + if (STIX_IN_SMOOI_RANGE(v3)) return STIX_SMOOI_TO_OOP(v3); + return make_bigint_with_ooi (stix, v3); } else if (STIX_OOP_IS_SMOOI(x)) { - stix_oop_t z; stix_ooi_t v; - int neg1, neg2; - smooi_and_large: - if (!is_integer(stix,y)) goto oops_einval; + if (!is_integer(stix, y)) goto oops_einval; - neg1 = 0; - neg2 = 0; v = STIX_OOP_TO_SMOOI(x); + if (v == 0) return clone_bigint(stix, y, STIX_OBJ_GET_SIZE(y)); - if (v < 0) - { - v = -v; - neg1 = 1; - } + stix_pushtmp (stix, &y); + x = make_bigint_with_ooi (stix, v); + stix_poptmp (stix); + if (!x) return STIX_NULL; - if (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer) neg2 = 1; - - z = clone_bigint (stix, y, STIX_OBJ_GET_SIZE(y)); - if (!z) return STIX_NULL; - - #if STIX_LIW_BITS == STIX_OOW_BITS - ((stix_oop_liword_t)z)->slot[0] ^= (stix_oow_t)v; - #elif STIX_LIW_BITS == STIX_OOHW_BITS - STIX_ASSERT (STIX_OBJ_GET_SIZE(z) >= 2); - ((stix_oop_liword_t)z)->slot[0] ^= ((stix_oow_t)v & STIX_LBMASK(stix_oow_t, STIX_OOHW_BITS)); - ((stix_oop_liword_t)z)->slot[1] ^= ((stix_oow_t)v >> STIX_OOHW_BITS); - #else - # error UNSUPPORTED LIW BIT SIZE - #endif - - if (STIX_OBJ_GET_CLASS(z) == stix->_large_negative_integer) neg2 = 1; - - if (neg1 == neg2) - { - STIX_OBJ_SET_CLASS(z, stix->_large_negative_integer); - } - else - { - STIX_OBJ_SET_CLASS(z, stix->_large_positive_integer); - } - - return normalize_bigint (stix, z); + goto bigint_and_bigint; } else if (STIX_OOP_IS_SMOOI(y)) { - stix_oop_t z; + stix_ooi_t v; - z = x; - x = y; - y = z; + if (!is_integer(stix, x)) goto oops_einval; - goto smooi_and_large; + v = STIX_OOP_TO_SMOOI(y); + if (v == 0) return clone_bigint(stix, x, STIX_OBJ_GET_SIZE(x)); + + stix_pushtmp (stix, &x); + y = make_bigint_with_ooi (stix, v); + stix_poptmp (stix); + if (!x) return STIX_NULL; + + goto bigint_and_bigint; } else { stix_oop_t z; - stix_oow_t xs, ys, zs; + stix_oow_t i, xs, ys, zs, zalloc; + int negx, negy; - if (!is_integer(stix,x)) goto oops_einval; - if (!is_integer(stix,y)) goto oops_einval; + if (!is_integer(stix,x) || !is_integer(stix, y)) goto oops_einval; + bigint_and_bigint: xs = STIX_OBJ_GET_SIZE(x); ys = STIX_OBJ_GET_SIZE(y); - if (xs > ys) + if (xs < ys) { - zs = xs; - } - else - { - /* swap x and y */ + /* make sure that x is greater than or equal to y */ z = x; x = y; y = z; @@ -1701,29 +1872,141 @@ stix_oop_t stix_bitxorints (stix_t* stix, stix_oop_t x, stix_oop_t y) xs = zs; } + negx = (STIX_OBJ_GET_CLASS(x) == stix->_large_negative_integer)? 1: 0; + negy = (STIX_OBJ_GET_CLASS(y) == stix->_large_negative_integer)? 1: 0; + + if (negx && negy) + { + zalloc = xs; + zs = xs; + } + else if (negx) + { + zalloc = xs + 1; + zs = xs; + } + else if (negy) + { + zalloc = xs + 1; + zs = xs; + } + else + { + zalloc = xs; + zs = xs; + } + stix_pushtmp (stix, &x); stix_pushtmp (stix, &y); - z = stix_instantiate (stix, stix->_large_positive_integer, 0, zs); + z = stix_instantiate (stix, stix->_large_positive_integer, STIX_NULL, zalloc); stix_poptmps (stix, 2); if (!z) return STIX_NULL; - while (zs > ys) + if (negx && negy) { - --zs; - ((stix_oop_liword_t)z)->slot[zs] = ((stix_oop_liword_t)x)->slot[zs]; + /* both are negative */ + stix_lidw_t w[2]; + stix_lidw_t carry[2]; + + carry[0] = 1; + carry[1] = 1; + /* 2's complement on both x and y and perform bitwise-and */ + for (i = 0; i < ys; i++) + { + w[0] = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry[0]; + carry[0] = w[0] >> STIX_LIW_BITS; + + w[1] = (stix_lidw_t)(~((stix_oop_liword_t)y)->slot[i]) + carry[1]; + carry[1] = w[1] >> STIX_LIW_BITS; + + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] ^ (stix_liw_t)w[1]; + } + STIX_ASSERT (carry[1] == 0); + + /* treat the lacking part in y as all 1s */ + for (; i < xs; i++) + { + w[0] = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry[0]; + carry[0] = w[0] >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w[0] ^ STIX_TYPE_MAX(stix_liw_t); + } + STIX_ASSERT (carry[0] == 0); } - while (zs > 0) + else if (negx) { - --zs; - ((stix_oop_liword_t)z)->slot[zs] = ((stix_oop_liword_t)x)->slot[zs] ^ ((stix_oop_liword_t)y)->slot[zs]; + /* x is negative, y is positive */ + stix_lidw_t w, carry; + + carry = 1; + for (i = 0; i < ys; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w ^ ((stix_oop_liword_t)y)->slot[i]; + } + + /* treat the lacking part in y as all 0s */ + for (; i < xs; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)x)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w; + } + STIX_ASSERT (carry == 0); + + adjust_to_negative: + /* 2's complement on the final result */ + ((stix_oop_liword_t)z)->slot[zs] = STIX_TYPE_MAX(stix_liw_t); + carry = 1; + for (i = 0; i <= zs; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)z)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = (stix_liw_t)w; + } + STIX_ASSERT (carry == 0); + + STIX_OBJ_SET_CLASS (z, stix->_large_negative_integer); + } + else if (negy) + { + /* x is positive, y is negative */ + stix_lidw_t w, carry; + + /* x & 2's complement on y up to ys */ + carry = 1; + for (i = 0; i < ys; i++) + { + w = (stix_lidw_t)(~((stix_oop_liword_t)y)->slot[i]) + carry; + carry = w >> STIX_LIW_BITS; + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] ^ (stix_liw_t)w; + } + STIX_ASSERT (carry == 0); + + /* treat the lacking part in y as all 1s */ + for (; i < xs; i++) + { + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] ^ STIX_TYPE_MAX(stix_liw_t); + } + + goto adjust_to_negative; + } + else + { + /* both are positive */ + for (i = 0; i < ys; i++) + { + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i] ^ ((stix_oop_liword_t)y)->slot[i]; + } + + /* treat the lacking part in y as all 0s */ + for (; i < xs; i++) + { + ((stix_oop_liword_t)z)->slot[i] = ((stix_oop_liword_t)x)->slot[i]; + } } - if (STIX_OBJ_GET_CLASS(x) == STIX_OBJ_GET_CLASS(y)) - { - STIX_OBJ_SET_CLASS(z, stix->_large_negative_integer); - } - - return normalize_bigint (stix, z); + return normalize_bigint(stix, z); } oops_einval: @@ -1731,6 +2014,7 @@ oops_einval: return STIX_NULL; } + static stix_uint8_t ooch_val_tab[] = { 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, @@ -1969,6 +2253,7 @@ stix_oop_t stix_strtoint (stix_t* stix, const stix_ooch_t* str, stix_oow_t len, res = stix_instantiate (stix, (sign < 0? stix->_large_negative_integer: stix->_large_positive_integer), hwp, hwlen); if (hwp && hw != hwp) stix_freemem (stix, hwp); + return res; oops_einval: diff --git a/stix/lib/comp.c b/stix/lib/comp.c index c210078..9e7985e 100644 --- a/stix/lib/comp.c +++ b/stix/lib/comp.c @@ -70,7 +70,7 @@ typedef enum var_type_t var_type_t; struct var_info_t { var_type_t type; - stix_ssize_t pos; /* not used for VAR_GLOBAL */ + stix_ooi_t pos; /* not used for VAR_GLOBAL */ stix_oop_class_t cls; /* useful if type is VAR_CLASS. note STIX_NULL indicates the self class. */ stix_oop_association_t gbl; /* used for VAR_GLOBAL only */ }; @@ -149,7 +149,7 @@ typedef enum voca_id_t voca_id_t; static int compile_block_statement (stix_t* stix); static int compile_method_statement (stix_t* stix); static int compile_method_expression (stix_t* stix, int pop); -static int add_literal (stix_t* stix, stix_oop_t lit, stix_size_t* index); +static int add_literal (stix_t* stix, stix_oop_t lit, stix_oow_t* index); static STIX_INLINE int is_spacechar (stix_ooci_t c) { @@ -327,9 +327,9 @@ static void set_syntax_error (stix_t* stix, stix_synerrnum_t num, const stix_iol } } -static int copy_string_to (stix_t* stix, const stix_oocs_t* src, stix_oocs_t* dst, stix_size_t* dst_capa, int append, stix_ooch_t add_delim) +static int copy_string_to (stix_t* stix, const stix_oocs_t* src, stix_oocs_t* dst, stix_oow_t* dst_capa, int append, stix_ooch_t add_delim) { - stix_size_t len, pos; + stix_oow_t len, pos; if (append) { @@ -346,7 +346,7 @@ static int copy_string_to (stix_t* stix, const stix_oocs_t* src, stix_oocs_t* ds if (len > *dst_capa) { stix_ooch_t* tmp; - stix_size_t capa; + stix_oow_t capa; capa = STIX_ALIGN(len, CLASS_BUFFER_ALIGN); @@ -363,7 +363,7 @@ static int copy_string_to (stix_t* stix, const stix_oocs_t* src, stix_oocs_t* ds return 0; } -static int find_word_in_string (const stix_oocs_t* haystack, const stix_oocs_t* name, stix_size_t* xindex) +static int find_word_in_string (const stix_oocs_t* haystack, const stix_oocs_t* name, stix_oow_t* xindex) { /* this function is inefficient. but considering the typical number * of arguments and temporary variables, the inefficiency can be @@ -372,7 +372,7 @@ static int find_word_in_string (const stix_oocs_t* haystack, const stix_oocs_t* * inefficient lookup */ stix_ooch_t* t, * e; - stix_size_t index, i; + stix_oow_t index, i; t = haystack->ptr; e = t + haystack->len; @@ -554,7 +554,7 @@ static stix_oop_t string_to_num (stix_t* stix, stix_oocs_t* str, int radixed) do { if (add_token_char(stix, c) <= -1) return -1; } while (0) -static STIX_INLINE int add_token_str (stix_t* stix, const stix_ooch_t* ptr, stix_size_t len) +static STIX_INLINE int add_token_str (stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len) { stix_oocs_t tmp; @@ -581,7 +581,7 @@ static STIX_INLINE void unget_char (stix_t* stix, const stix_iolxc_t* c) static int get_char (stix_t* stix) { - stix_ssize_t n; + stix_ooi_t n; stix_ooci_t lc, ec; if (stix->c->nungots > 0) @@ -993,11 +993,11 @@ static int get_strlit (stix_t* stix) return 0; } -static int get_string (stix_t* stix, stix_ooch_t end_char, stix_ooch_t esc_char, int regex, stix_size_t preescaped) +static int get_string (stix_t* stix, stix_ooch_t end_char, stix_ooch_t esc_char, int regex, stix_oow_t preescaped) { stix_ooci_t c; - stix_size_t escaped = preescaped; - stix_size_t digit_count = 0; + stix_oow_t escaped = preescaped; + stix_oow_t digit_count = 0; stix_ooci_t c_acc = 0; stix->c->tok.type = STIX_IOTOK_STRLIT; @@ -1624,7 +1624,7 @@ static int end_include (stix_t* stix) static STIX_INLINE int emit_byte_instruction (stix_t* stix, stix_oob_t code) { - stix_size_t i; + stix_oow_t i; i = stix->c->mth.code.len + 1; if (i > stix->c->mth.code_capa) @@ -1716,7 +1716,7 @@ write_long: } -static int emit_double_param_instruction (stix_t* stix, int cmd, stix_size_t param_1, stix_size_t param_2) +static int emit_double_param_instruction (stix_t* stix, int cmd, stix_oow_t param_1, stix_oow_t param_2) { stix_oob_t bc; @@ -1773,7 +1773,7 @@ write_long: static int emit_push_smint_literal (stix_t* stix, stix_ooi_t i) { - stix_size_t index; + stix_oow_t index; switch (i) { @@ -1818,9 +1818,9 @@ printf ("\tpush litral_0 %d\n", (int)index); * --------------------------------------------------------------------- */ -static int add_literal (stix_t* stix, stix_oop_t lit, stix_size_t* index) +static int add_literal (stix_t* stix, stix_oop_t lit, stix_oow_t* index) { - stix_size_t i; + stix_oow_t i; for (i = 0; i < stix->c->mth.literal_count; i++) { @@ -1839,7 +1839,7 @@ static int add_literal (stix_t* stix, stix_oop_t lit, stix_size_t* index) if (stix->c->mth.literal_count >= stix->c->mth.literal_capa) { stix_oop_t* tmp; - stix_size_t new_capa; + stix_oow_t new_capa; new_capa = STIX_ALIGN (stix->c->mth.literal_count + 1, LITERAL_BUFFER_ALIGN); tmp = (stix_oop_t*)stix_reallocmem (stix, stix->c->mth.literals, new_capa * STIX_SIZEOF(*tmp)); @@ -1854,15 +1854,15 @@ static int add_literal (stix_t* stix, stix_oop_t lit, stix_size_t* index) return 0; } -static STIX_INLINE int add_character_literal (stix_t* stix, stix_ooch_t ch, stix_size_t* index) +static STIX_INLINE int add_character_literal (stix_t* stix, stix_ooch_t ch, stix_oow_t* index) { return add_literal (stix, STIX_CHAR_TO_OOP(ch), index); } -static int add_string_literal (stix_t* stix, const stix_oocs_t* str, stix_size_t* index) +static int add_string_literal (stix_t* stix, const stix_oocs_t* str, stix_oow_t* index) { stix_oop_t lit; - stix_size_t i; + stix_oow_t i; for (i = 0; i < stix->c->mth.literal_count; i++) { @@ -1883,7 +1883,7 @@ static int add_string_literal (stix_t* stix, const stix_oocs_t* str, stix_size_t return add_literal (stix, lit, index); } -static int add_symbol_literal (stix_t* stix, const stix_oocs_t* str, stix_size_t* index) +static int add_symbol_literal (stix_t* stix, const stix_oocs_t* str, stix_oow_t* index) { stix_oop_t tmp; @@ -1924,7 +1924,7 @@ static STIX_INLINE int add_class_level_variable (stix_t* stix, var_type_t index, static STIX_INLINE int add_pool_dictionary (stix_t* stix, const stix_oocs_t* name, stix_oop_set_t pooldic_oop) { int n; - stix_size_t saved_len; + stix_oow_t saved_len; saved_len = stix->c->cls.pooldic.len; @@ -1933,7 +1933,7 @@ static STIX_INLINE int add_pool_dictionary (stix_t* stix, const stix_oocs_t* nam { if (stix->c->cls.pooldic_count >= stix->c->cls.pooldic_oop_capa) { - stix_size_t new_capa; + stix_oow_t new_capa; stix_oop_set_t* tmp; new_capa = STIX_ALIGN(stix->c->cls.pooldic_oop_capa + 1, POOLDIC_OOP_BUFFER_ALIGN); @@ -1957,9 +1957,9 @@ static STIX_INLINE int add_pool_dictionary (stix_t* stix, const stix_oocs_t* nam } -static stix_ssize_t find_class_level_variable (stix_t* stix, stix_oop_class_t self, const stix_oocs_t* name, var_info_t* var) +static stix_ooi_t find_class_level_variable (stix_t* stix, stix_oop_class_t self, const stix_oocs_t* name, var_info_t* var) { - stix_size_t pos; + stix_oow_t pos; stix_oop_t super; stix_oop_char_t v; stix_oop_char_t* vv; @@ -2093,10 +2093,10 @@ done: return pos; } -static int clone_assignee (stix_t* stix, const stix_oocs_t* name, stix_size_t* offset) +static int clone_assignee (stix_t* stix, const stix_oocs_t* name, stix_oow_t* offset) { int n; - stix_size_t old_len; + stix_oow_t old_len; old_len = stix->c->mth.assignees.len; n = copy_string_to (stix, name, &stix->c->mth.assignees, &stix->c->mth.assignees_capa, 1, '\0'); @@ -2108,10 +2108,10 @@ static int clone_assignee (stix_t* stix, const stix_oocs_t* name, stix_size_t* o return 0; } -static int clone_binary_selector (stix_t* stix, const stix_oocs_t* name, stix_size_t* offset) +static int clone_binary_selector (stix_t* stix, const stix_oocs_t* name, stix_oow_t* offset) { int n; - stix_size_t old_len; + stix_oow_t old_len; old_len = stix->c->mth.binsels.len; n = copy_string_to (stix, name, &stix->c->mth.binsels, &stix->c->mth.binsels_capa, 1, '\0'); @@ -2123,10 +2123,10 @@ static int clone_binary_selector (stix_t* stix, const stix_oocs_t* name, stix_si return 0; } -static int clone_keyword (stix_t* stix, const stix_oocs_t* name, stix_size_t* offset) +static int clone_keyword (stix_t* stix, const stix_oocs_t* name, stix_oow_t* offset) { int n; - stix_size_t old_len; + stix_oow_t old_len; old_len = stix->c->mth.kwsels.len; n = copy_string_to (stix, name, &stix->c->mth.kwsels, &stix->c->mth.kwsels_capa, 1, '\0'); @@ -2157,14 +2157,14 @@ static int add_temporary_variable (stix_t* stix, const stix_oocs_t* name) return copy_string_to (stix, name, &stix->c->mth.tmprs, &stix->c->mth.tmprs_capa, 1, ' '); } -static STIX_INLINE int find_temporary_variable (stix_t* stix, const stix_oocs_t* name, stix_size_t* xindex) +static STIX_INLINE int find_temporary_variable (stix_t* stix, const stix_oocs_t* name, stix_oow_t* xindex) { return find_word_in_string (&stix->c->mth.tmprs, name, xindex); } static stix_oop_set_t add_namespace (stix_t* stix, stix_oop_set_t dic, const stix_oocs_t* name) { - stix_size_t tmp_count = 0; + stix_oow_t tmp_count = 0; stix_oop_t sym; stix_oop_set_t ns; stix_oop_association_t ass; @@ -2195,7 +2195,7 @@ oops: static int preprocess_dotted_name (stix_t* stix, int dont_add_ns, int accept_pooldic_as_ns, const stix_oocs_t* fqn, const stix_ioloc_t* fqn_loc, stix_oocs_t* name, stix_oop_set_t* ns_oop) { const stix_ooch_t* ptr, * dot; - stix_size_t len; + stix_oow_t len; stix_oocs_t seg; stix_oop_set_t dic; stix_oop_association_t ass; @@ -2332,7 +2332,7 @@ static int compile_class_level_variables (stix_t* stix) stix_oocs_t last; stix_oop_set_t ns_oop; stix_oop_association_t ass; - stix_size_t i; + stix_oow_t i; do { @@ -2648,7 +2648,7 @@ static int compile_method_primitive (stix_t* stix) us = stix_findoochar (stix->c->tok.name.ptr, stix->c->tok.name.len, '_'); if (us > stix->c->tok.name.ptr && us < stix->c->tok.name.ptr + stix->c->tok.name.len - 1) { - stix_size_t lit_idx; + stix_oow_t lit_idx; /* the symbol literal contains an underscore. * and it is none of the first of the last character */ if (add_symbol_literal(stix, &stix->c->tok.name, &lit_idx) >= 0 && @@ -2692,7 +2692,7 @@ static int compile_method_primitive (stix_t* stix) static int get_variable_info (stix_t* stix, const stix_oocs_t* name, const stix_ioloc_t* name_loc, int name_dotted, var_info_t* var) { - stix_size_t index; + stix_oow_t index; STIX_MEMSET (var, 0, STIX_SIZEOF(*var)); @@ -2826,7 +2826,7 @@ printf ("\n"); } else { - stix_size_t i; + stix_oow_t i; stix_oop_association_t ass2 = STIX_NULL; /* attempt to find the variable in pool dictionaries */ @@ -2915,15 +2915,15 @@ static int compile_block_temporaries (stix_t* stix) return 0; } -static int store_tmpr_count_for_block (stix_t* stix, stix_size_t tmpr_count) +static int store_tmpr_count_for_block (stix_t* stix, stix_oow_t tmpr_count) { if (stix->c->mth.blk_depth >= stix->c->mth.blk_tmprcnt_capa) { - stix_size_t* tmp; - stix_size_t new_capa; + stix_oow_t* tmp; + stix_oow_t new_capa; new_capa = STIX_ALIGN (stix->c->mth.blk_depth + 1, BLK_TMPRCNT_BUFFER_ALIGN); - tmp = (stix_size_t*)stix_reallocmem (stix, stix->c->mth.blk_tmprcnt, new_capa * STIX_SIZEOF(*tmp)); + tmp = (stix_oow_t*)stix_reallocmem (stix, stix->c->mth.blk_tmprcnt, new_capa * STIX_SIZEOF(*tmp)); if (!tmp) return -1; stix->c->mth.blk_tmprcnt_capa = new_capa; @@ -2937,10 +2937,10 @@ static int store_tmpr_count_for_block (stix_t* stix, stix_size_t tmpr_count) static int compile_block_expression (stix_t* stix) { - stix_size_t jump_inst_pos; - stix_size_t saved_tmpr_count, saved_tmprs_len; - stix_size_t block_arg_count, block_tmpr_count; - stix_size_t block_code_size; + stix_oow_t jump_inst_pos; + stix_oow_t saved_tmpr_count, saved_tmprs_len; + stix_oow_t block_arg_count, block_tmpr_count; + stix_oow_t block_code_size; stix_ioloc_t block_loc, colon_loc, tmpr_loc; /* @@ -3088,7 +3088,7 @@ printf ("\treturn_from_block\n"); } else { - stix_size_t jump_offset; + stix_oow_t jump_offset; if (block_code_size > MAX_CODE_JUMP) { @@ -3126,7 +3126,7 @@ static int add_to_balit_buffer (stix_t* stix, stix_oob_t b) if (stix->c->mth.balit_count >= stix->c->mth.balit_capa) { stix_oob_t* tmp; - stix_size_t new_capa; + stix_oow_t new_capa; new_capa = STIX_ALIGN (stix->c->mth.balit_count + 1, BALIT_BUFFER_ALIGN); tmp = (stix_oob_t*)stix_reallocmem (stix, stix->c->mth.balit, new_capa * STIX_SIZEOF(*tmp)); @@ -3145,7 +3145,7 @@ static int add_to_arlit_buffer (stix_t* stix, stix_oop_t item) if (stix->c->mth.arlit_count >= stix->c->mth.arlit_capa) { stix_oop_t* tmp; - stix_size_t new_capa; + stix_oow_t new_capa; new_capa = STIX_ALIGN (stix->c->mth.arlit_count + 1, ARLIT_BUFFER_ALIGN); tmp = (stix_oop_t*)stix_reallocmem (stix, stix->c->mth.arlit, new_capa * STIX_SIZEOF(*tmp)); @@ -3207,8 +3207,8 @@ static int __read_byte_array_literal (stix_t* stix, stix_oop_t* xlit) struct arlit_info_t { - stix_size_t pos; - stix_size_t len; + stix_oow_t pos; + stix_oow_t len; }; typedef struct arlit_info_t arlit_info_t; @@ -3216,7 +3216,7 @@ typedef struct arlit_info_t arlit_info_t; static int __read_array_literal (stix_t* stix, stix_oop_t* xlit) { stix_oop_t lit, a; - stix_size_t i, saved_arlit_count; + stix_oow_t i, saved_arlit_count; arlit_info_t info; info.pos = stix->c->mth.arlit_count; @@ -3320,7 +3320,7 @@ static STIX_INLINE int read_byte_array_literal (stix_t* stix, stix_oop_t* xlit) static int compile_byte_array_literal (stix_t* stix) { stix_oop_t lit; - stix_size_t index; + stix_oow_t index; if (read_byte_array_literal(stix, &lit) <= -1 || add_literal(stix, lit, &index) <= -1 || @@ -3334,7 +3334,7 @@ printf ("\tpush_literal byte_array\n"); static int read_array_literal (stix_t* stix, stix_oop_t* xlit) { int x; - stix_size_t saved_arlit_count; + stix_oow_t saved_arlit_count; stix->c->in_array = 1; if (get_token(stix) <= -1) @@ -3354,7 +3354,7 @@ static int read_array_literal (stix_t* stix, stix_oop_t* xlit) static int compile_array_literal (stix_t* stix) { stix_oop_t lit; - stix_size_t index; + stix_oow_t index; STIX_ASSERT (stix->c->mth.arlit_count == 0); @@ -3375,7 +3375,7 @@ static int compile_expression_primary (stix_t* stix, const stix_oocs_t* ident, c var_info_t var; int read_next_token = 0; - stix_size_t index; + stix_oow_t index; *to_super = 0; @@ -3393,7 +3393,7 @@ static int compile_expression_primary (stix_t* stix, const stix_oocs_t* ident, c #if defined(STIX_USE_CTXTEMPVAR) if (stix->c->mth.blk_depth > 0) { - stix_size_t i; + stix_oow_t i; STIX_ASSERT (var.pos < stix->c->mth.blk_tmprcnt[stix->c->mth.blk_depth]); for (i = stix->c->mth.blk_depth; i > 0; i--) @@ -3603,7 +3603,7 @@ static stix_oob_t send_message_cmd[] = static int compile_unary_message (stix_t* stix, int to_super) { - stix_size_t index; + stix_oow_t index; STIX_ASSERT (stix->c->tok.type == STIX_IOTOK_IDENT); @@ -3628,10 +3628,10 @@ static int compile_binary_message (stix_t* stix, int to_super) * binary-message := binary-selector binary-argument * binary-argument := expression-primary unary-message* */ - stix_size_t index; + stix_oow_t index; int to_super2; stix_oocs_t binsel; - stix_size_t saved_binsels_len, binsel_offset; + stix_oow_t saved_binsels_len, binsel_offset; STIX_ASSERT (stix->c->tok.type == STIX_IOTOK_BINSEL); @@ -3676,13 +3676,13 @@ static int compile_keyword_message (stix_t* stix, int to_super) * keyword-argument := expression-primary unary-message* binary-message* */ - stix_size_t index; + stix_oow_t index; int to_super2; stix_oocs_t kw, kwsel; stix_ioloc_t saved_kwsel_loc; - stix_size_t saved_kwsel_len; - stix_size_t kw_offset; - stix_size_t nargs = 0; + stix_oow_t saved_kwsel_len; + stix_oow_t kw_offset; + stix_oow_t nargs = 0; saved_kwsel_loc = stix->c->tok.loc; saved_kwsel_len = stix->c->mth.kwsels.len; @@ -3746,7 +3746,7 @@ static int compile_message_expression (stix_t* stix, int to_super) * unary-message := unary-selector * cascaded-message := (";" single-message)* */ - stix_size_t noop_pos; + stix_oow_t noop_pos; do { @@ -3873,7 +3873,7 @@ static int compile_method_expression (stix_t* stix, int pop) */ stix_oocs_t assignee; - stix_size_t index; + stix_oow_t index; int ret = 0; STIX_ASSERT (pop == 0 || pop == 1); @@ -3883,7 +3883,7 @@ static int compile_method_expression (stix_t* stix, int pop) stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED) { stix_ioloc_t assignee_loc; - stix_size_t assignee_offset; + stix_oow_t assignee_offset; int assignee_dotted; /* store the assignee name to the internal buffer @@ -3931,7 +3931,7 @@ printf ("\n"); #if defined(STIX_USE_CTXTEMPVAR) if (stix->c->mth.blk_depth > 0) { - stix_size_t i; + stix_oow_t i; STIX_ASSERT (var.pos < stix->c->mth.blk_tmprcnt[stix->c->mth.blk_depth]); for (i = stix->c->mth.blk_depth; i > 0; i--) @@ -4105,8 +4105,8 @@ static int add_compiled_method (stix_t* stix) #else stix_oop_byte_t code; #endif - stix_size_t tmp_count = 0; - stix_size_t i; + stix_oow_t tmp_count = 0; + stix_oow_t i; stix_ooi_t preamble_code, preamble_index; name = stix_makesymbol (stix, stix->c->mth.name.ptr, stix->c->mth.name.len); @@ -4780,7 +4780,7 @@ printf ("\n"); static int compile_class_definition (stix_t* stix, int extend) { int n; - stix_size_t i; + stix_oow_t i; /* reset the structure to hold information about a class to be compiled */ stix->c->cls.flags = 0; @@ -4834,7 +4834,7 @@ static int __compile_pooldic_definition (stix_t* stix) { stix_oop_t lit; stix_ooi_t tally; - stix_size_t i; + stix_oow_t i; if (stix->c->tok.type != STIX_IOTOK_IDENT && stix->c->tok.type != STIX_IOTOK_IDENT_DOTTED) @@ -5076,7 +5076,7 @@ static void gc_compiler (stix_t* stix) /* called when garbage collection is performed */ if (stix->c) { - stix_size_t i; + stix_oow_t i; if (stix->c->cls.self_oop) stix->c->cls.self_oop = (stix_oop_class_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.self_oop); @@ -5118,7 +5118,7 @@ static void fini_compiler (stix_t* stix) /* called before the stix object is closed */ if (stix->c) { - stix_size_t i; + stix_oow_t i; clear_io_names (stix); diff --git a/stix/lib/debug.c b/stix/lib/debug.c index cf99633..fcc1367 100644 --- a/stix/lib/debug.c +++ b/stix/lib/debug.c @@ -78,7 +78,7 @@ void dump_dictionary (stix_t* stix, stix_oop_set_t dic, const char* title) void print_oocs (const stix_oocs_t* name) { - stix_size_t i; + stix_oow_t i; for (i = 0; i < name->len; i++) printf ("%c", name->ptr[i]); } @@ -105,7 +105,7 @@ void print_object (stix_t* stix, stix_oop_t oop) { stix_bch_t bcs[32]; stix_uch_t uch; - stix_size_t ucslen, bcslen; + stix_oow_t ucslen, bcslen; uch = STIX_OOP_TO_CHAR(oop); bcslen = STIX_COUNTOF(bcs); @@ -119,9 +119,9 @@ void print_object (stix_t* stix, stix_oop_t oop) { stix_oop_class_t c; stix_oocs_t s; - stix_size_t i; + stix_oow_t i; stix_bch_t bcs[32]; - stix_size_t ucslen, bcslen; + stix_oow_t ucslen, bcslen; STIX_ASSERT (STIX_OOP_IS_POINTER(oop)); c = (stix_oop_class_t)STIX_OBJ_GET_CLASS(oop); /*STIX_CLASSOF(stix, oop);*/ @@ -256,7 +256,7 @@ static void __dump_object (stix_t* stix, stix_oop_t oop, int depth) { stix_bch_t bcs[32]; stix_uch_t uch; - stix_size_t ucslen, bcslen; + stix_oow_t ucslen, bcslen; uch = STIX_OOP_TO_CHAR(oop); bcslen = STIX_COUNTOF(bcs); @@ -292,7 +292,7 @@ static void __dump_object (stix_t* stix, stix_oop_t oop, int depth) { stix_bch_t bcs[32]; stix_uch_t uch; - stix_size_t ucslen, bcslen; + stix_oow_t ucslen, bcslen; uch = ((stix_oop_char_t)oop)->slot[i]; if (uch == '\'') printf ("''"); else diff --git a/stix/lib/exec.c b/stix/lib/exec.c index 838ff25..9754d10 100644 --- a/stix/lib/exec.c +++ b/stix/lib/exec.c @@ -1617,7 +1617,7 @@ printf ("CALL MODE 222 ERROR %d %d\n", dcGetError (dc), DC_ERROR_UNSUPPORTED_MOD case 's': { - stix_size_t bcslen, ucslen; + stix_oow_t bcslen, ucslen; stix_bch_t bcs[1024]; ucslen = STIX_OBJ_GET_SIZE(arr->slot[i - 2]); @@ -1673,7 +1673,7 @@ printf ("CALL ERROR %d %d\n", dcGetError (dc), DC_ERROR_UNSUPPORTED_MODE); case 's': { - stix_size_t bcslen, ucslen; + stix_oow_t bcslen, ucslen; stix_ooch_t ucs[1024]; stix_oop_t s; char* r = dcCallPointer (dc, f); @@ -1975,7 +1975,7 @@ int stix_execute (stix_t* stix) stix_oop_t return_value; #if defined(STIX_PROFILE_EXEC) - stix_size_t inst_counter = 0; + stix_oow_t inst_counter = 0; #endif STIX_ASSERT (stix->active_context != STIX_NULL); diff --git a/stix/lib/heap.c b/stix/lib/heap.c index 082352b..ea37262 100644 --- a/stix/lib/heap.c +++ b/stix/lib/heap.c @@ -26,7 +26,7 @@ #include "stix-prv.h" -stix_heap_t* stix_makeheap (stix_t* stix, stix_size_t size) +stix_heap_t* stix_makeheap (stix_t* stix, stix_oow_t size) { stix_heap_t* heap; @@ -61,7 +61,7 @@ void stix_killheap (stix_t* stix, stix_heap_t* heap) STIX_MMGR_FREE (stix->mmgr, heap); } -void* stix_allocheapmem (stix_t* stix, stix_heap_t* heap, stix_size_t size) +void* stix_allocheapmem (stix_t* stix, stix_heap_t* heap, stix_oow_t size) { stix_uint8_t* ptr; diff --git a/stix/lib/main.c b/stix/lib/main.c index 643bfc1..02ba8c3 100644 --- a/stix/lib/main.c +++ b/stix/lib/main.c @@ -84,16 +84,16 @@ struct xtn_t const char* source_path; char bchar_buf[1024]; - stix_size_t bchar_pos; - stix_size_t bchar_len; + stix_oow_t bchar_pos; + stix_oow_t bchar_len; }; -static void* sys_alloc (stix_mmgr_t* mmgr, stix_size_t size) +static void* sys_alloc (stix_mmgr_t* mmgr, stix_oow_t size) { return malloc (size); } -static void* sys_realloc (stix_mmgr_t* mmgr, void* ptr, stix_size_t size) +static void* sys_realloc (stix_mmgr_t* mmgr, void* ptr, stix_oow_t size) { return realloc (ptr, size); } @@ -112,14 +112,14 @@ static stix_mmgr_t sys_mmgr = }; -static STIX_INLINE stix_ssize_t open_input (stix_t* stix, stix_io_arg_t* arg) +static STIX_INLINE stix_ooi_t open_input (stix_t* stix, stix_io_arg_t* arg) { if (arg->includer) { /* includee */ stix_bch_t bcs[1024]; /* TODO: right buffer size */ - stix_size_t bcslen = STIX_COUNTOF(bcs); - stix_size_t ucslen = ~(stix_size_t)0; + stix_oow_t bcslen = STIX_COUNTOF(bcs); + stix_oow_t ucslen = ~(stix_oow_t)0; if (stix_ucstoutf8 (arg->name, &ucslen, bcs, &bcslen) <= -1) { @@ -155,10 +155,10 @@ static STIX_INLINE stix_ssize_t open_input (stix_t* stix, stix_io_arg_t* arg) return 0; } -static STIX_INLINE stix_ssize_t read_input (stix_t* stix, stix_io_arg_t* arg) +static STIX_INLINE stix_ooi_t read_input (stix_t* stix, stix_io_arg_t* arg) { xtn_t* xtn = stix_getxtn(stix); - stix_size_t n, bcslen, ucslen, remlen; + stix_oow_t n, bcslen, ucslen, remlen; int x; STIX_ASSERT (arg->handle != STIX_NULL); @@ -188,14 +188,14 @@ static STIX_INLINE stix_ssize_t read_input (stix_t* stix, stix_io_arg_t* arg) return ucslen; } -static STIX_INLINE stix_ssize_t close_input (stix_t* stix, stix_io_arg_t* arg) +static STIX_INLINE stix_ooi_t close_input (stix_t* stix, stix_io_arg_t* arg) { STIX_ASSERT (arg->handle != STIX_NULL); fclose ((FILE*)arg->handle); return 0; } -static stix_ssize_t input_handler (stix_t* stix, stix_io_cmd_t cmd, stix_io_arg_t* arg) +static stix_ooi_t input_handler (stix_t* stix, stix_io_cmd_t cmd, stix_io_arg_t* arg) { switch (cmd) { @@ -219,8 +219,8 @@ static void* mod_open (stix_t* stix, const stix_ooch_t* name) #if defined(USE_LTDL) /* TODO: support various platforms */ stix_bch_t buf[1024]; /* TODO: use a proper path buffer */ - stix_size_t ucslen, bcslen; - stix_size_t len; + stix_oow_t ucslen, bcslen; + stix_oow_t len; void* handle; /* TODO: using MODPREFIX isn't a good idean for all kind of modules. @@ -236,7 +236,7 @@ static void* mod_open (stix_t* stix, const stix_ooch_t* name) len = stix_copybcstr (buf, STIX_COUNTOF(buf), STIX_DEFAULT_MODPREFIX); /* TODO: proper error checking and overflow checking */ - ucslen = ~(stix_size_t)0; + ucslen = ~(stix_oow_t)0; bcslen = STIX_COUNTOF(buf) - len; stix_ucstoutf8 (name, &ucslen, &buf[len], &bcslen); @@ -279,12 +279,12 @@ static void* mod_getsym (stix_t* stix, void* handle, const stix_ooch_t* name) { #if defined(USE_LTDL) stix_bch_t buf[1024]; /* TODO: use a proper buffer. dynamically allocated if conversion result in too a large value */ - stix_size_t ucslen, bcslen; + stix_oow_t ucslen, bcslen; void* sym; buf[0] = '_'; - ucslen = ~(stix_size_t)0; + ucslen = ~(stix_oow_t)0; bcslen = STIX_COUNTOF(buf) - 2; stix_ucstoutf8 (name, &ucslen, &buf[1], &bcslen); printf ("MOD_GETSYM [%s]\n", &buf[1]); @@ -542,7 +542,7 @@ printf ("%p\n", a); { stix_synerr_t synerr; stix_bch_t bcs[1024]; /* TODO: right buffer size */ - stix_size_t bcslen, ucslen; + stix_oow_t bcslen, ucslen; stix_getsynerr (stix, &synerr); @@ -550,7 +550,7 @@ printf ("%p\n", a); if (synerr.loc.file) { bcslen = STIX_COUNTOF(bcs); - ucslen = ~(stix_size_t)0; + ucslen = ~(stix_oow_t)0; if (stix_ucstoutf8 (synerr.loc.file, &ucslen, bcs, &bcslen) >= 0) { printf ("%.*s ", (int)bcslen, bcs); diff --git a/stix/lib/obj.c b/stix/lib/obj.c index c19d55a..a2496c7 100644 --- a/stix/lib/obj.c +++ b/stix/lib/obj.c @@ -26,7 +26,7 @@ #include "stix-prv.h" -void* stix_allocbytes (stix_t* stix, stix_size_t size) +void* stix_allocbytes (stix_t* stix, stix_oow_t size) { stix_uint8_t* ptr; diff --git a/stix/lib/stix-cmn.h b/stix/lib/stix-cmn.h index 281b6d9..7ff4c77 100644 --- a/stix/lib/stix-cmn.h +++ b/stix/lib/stix-cmn.h @@ -272,21 +272,48 @@ # error UNKNOWN INTMAX SIZE #endif +/* ========================================================================= + * BASIC STIX TYPES + * =========================================================================*/ -typedef stix_uintptr_t stix_size_t; -typedef stix_intptr_t stix_ssize_t; +typedef char stix_bch_t; +typedef int stix_bci_t; -typedef char stix_bch_t; -typedef stix_uint16_t stix_uch_t; /* TODO ... wchar_t??? */ -typedef stix_int32_t stix_uci_t; +typedef stix_uint16_t stix_uch_t; /* TODO ... wchar_t??? */ +typedef stix_int32_t stix_uci_t; + +typedef stix_uint8_t stix_oob_t; + +/* NOTE: sizeof(stix_oop_t) must be equal to sizeof(stix_oow_t) */ +typedef stix_uintptr_t stix_oow_t; +typedef stix_intptr_t stix_ooi_t; +#define STIX_SIZEOF_OOW_T STIX_SIZEOF_UINTPTR_T +#define STIX_SIZEOF_OOI_T STIX_SIZEOF_INTPTR_T + +typedef stix_ushortptr_t stix_oohw_t; /* half word - half word */ +typedef stix_shortptr_t stix_oohi_t; /* signed half word */ +#define STIX_SIZEOF_OOHW_T STIX_SIZEOF_USHORTPTR_T +#define STIX_SIZEOF_OOHI_T STIX_SIZEOF_SHORTPTR_T struct stix_ucs_t { stix_uch_t* ptr; - stix_size_t len; + stix_oow_t len; }; typedef struct stix_ucs_t stix_ucs_t; +struct stix_bcs_t +{ + stix_bch_t* ptr; + stix_oow_t len; +}; +typedef struct stix_bcs_t stix_bcs_t; + +typedef stix_uch_t stix_ooch_t; +typedef stix_uci_t stix_ooci_t; +typedef stix_ucs_t stix_oocs_t; +#define STIX_OOCH_IS_UCH + /* ========================================================================= * PRIMITIVE MACROS @@ -378,12 +405,12 @@ typedef struct stix_mmgr_t stix_mmgr_t; * allocate a memory chunk of the size \a n. * \return pointer to a memory chunk on success, #STIX_NULL on failure. */ -typedef void* (*stix_mmgr_alloc_t) (stix_mmgr_t* mmgr, stix_size_t n); +typedef void* (*stix_mmgr_alloc_t) (stix_mmgr_t* mmgr, stix_oow_t n); /** * resize a memory chunk pointed to by \a ptr to the size \a n. * \return pointer to a memory chunk on success, #STIX_NULL on failure. */ -typedef void* (*stix_mmgr_realloc_t) (stix_mmgr_t* mmgr, void* ptr, stix_size_t n); +typedef void* (*stix_mmgr_realloc_t) (stix_mmgr_t* mmgr, void* ptr, stix_oow_t n); /** * free a memory chunk pointed to by \a ptr. */ @@ -432,16 +459,16 @@ struct stix_mmgr_t typedef struct stix_cmgr_t stix_cmgr_t; -typedef stix_size_t (*stix_cmgr_bctouc_t) ( +typedef stix_oow_t (*stix_cmgr_bctouc_t) ( const stix_bch_t* mb, - stix_size_t size, + stix_oow_t size, stix_uch_t* wc ); -typedef stix_size_t (*stix_cmgr_uctobc_t) ( +typedef stix_oow_t (*stix_cmgr_uctobc_t) ( stix_uch_t wc, stix_bch_t* mb, - stix_size_t size + stix_oow_t size ); /** @@ -524,29 +551,6 @@ struct stix_cmgr_t ((STIX_TYPE_IS_SIGNED(type)? STIX_TYPE_SIGNED_MIN(type): STIX_TYPE_UNSIGNED_MIN(type))) -/* ========================================================================= - * BASIC STIX TYPES - * =========================================================================*/ - -typedef stix_uint8_t stix_oob_t; - -/* NOTE: sizeof(stix_oop_t) must be equal to sizeof(stix_oow_t) */ -typedef stix_uintptr_t stix_oow_t; -typedef stix_intptr_t stix_ooi_t; -#define STIX_SIZEOF_OOW_T STIX_SIZEOF_UINTPTR_T -#define STIX_SIZEOF_OOI_T STIX_SIZEOF_INTPTR_T - -typedef stix_ushortptr_t stix_oohw_t; /* half word - half word */ -typedef stix_shortptr_t stix_oohi_t; /* signed half word */ -#define STIX_SIZEOF_OOHW_T STIX_SIZEOF_USHORTPTR_T -#define STIX_SIZEOF_OOHI_T STIX_SIZEOF_SHORTPTR_T - -typedef stix_uch_t stix_ooch_t; -typedef stix_uci_t stix_ooci_t; -typedef stix_ucs_t stix_oocs_t; -#define STIX_OOCH_IS_UCH - - /* ========================================================================= * COMPILER FEATURE TEST MACROS * =========================================================================*/ diff --git a/stix/lib/stix-prv.h b/stix/lib/stix-prv.h index 10ba2f4..3a404a6 100644 --- a/stix/lib/stix-prv.h +++ b/stix/lib/stix-prv.h @@ -271,7 +271,7 @@ struct stix_io_arg_t /*-----------------------------------------------------------------*/ }; -typedef stix_ssize_t (*stix_io_impl_t) ( +typedef stix_ooi_t (*stix_io_impl_t) ( stix_t* stix, stix_io_cmd_t cmd, stix_io_arg_t* arg @@ -314,7 +314,7 @@ struct stix_iotok_t } type; stix_oocs_t name; - stix_size_t name_capa; + stix_oow_t name_capa; stix_ioloc_t loc; }; @@ -395,7 +395,7 @@ typedef struct stix_synerr_t stix_synerr_t; struct stix_code_t { stix_uint8_t* ptr; - stix_size_t len; + stix_oow_t len; }; typedef struct stix_code_t stix_code_t; @@ -445,31 +445,31 @@ struct stix_compiler_t stix_oop_set_t ns_oop; stix_oocs_t fqn; stix_oocs_t name; - stix_size_t fqn_capa; + stix_oow_t fqn_capa; stix_ioloc_t fqn_loc; stix_oop_set_t superns_oop; stix_oocs_t superfqn; stix_oocs_t supername; - stix_size_t superfqn_capa; + stix_oow_t superfqn_capa; stix_ioloc_t superfqn_loc; /* instance variable, class variable, class instance variable */ stix_oocs_t vars[3]; - stix_size_t vars_capa[3]; + stix_oow_t vars_capa[3]; /* var_count, unlike vars above, includes superclass counts as well. * var_count[0] - number of named instance variables * var_count[1] - number of class variables * var_count[2] - number of class instance variables */ - stix_size_t var_count[3]; + stix_oow_t var_count[3]; stix_oocs_t pooldic; - stix_size_t pooldic_capa; - stix_size_t pooldic_count; + stix_oow_t pooldic_capa; + stix_oow_t pooldic_count; stix_oop_set_t* pooldic_oops; - stix_size_t pooldic_oop_capa; + stix_oow_t pooldic_oop_capa; } cls; /* information about a function being comipled */ @@ -479,45 +479,45 @@ struct stix_compiler_t /* method source text */ stix_oocs_t text; - stix_size_t text_capa; + stix_oow_t text_capa; /* buffer to store identifier names to be assigned */ stix_oocs_t assignees; - stix_size_t assignees_capa; + stix_oow_t assignees_capa; /* buffer to store binary selectors being worked on */ stix_oocs_t binsels; - stix_size_t binsels_capa; + stix_oow_t binsels_capa; /* buffer to store keyword selectors being worked on */ stix_oocs_t kwsels; - stix_size_t kwsels_capa; + stix_oow_t kwsels_capa; /* method name */ stix_oocs_t name; - stix_size_t name_capa; + stix_oow_t name_capa; stix_ioloc_t name_loc; /* single string containing a space separated list of temporaries */ stix_oocs_t tmprs; - stix_size_t tmprs_capa; - stix_size_t tmpr_count; /* total number of temporaries including arguments */ - stix_size_t tmpr_nargs; + stix_oow_t tmprs_capa; + stix_oow_t tmpr_count; /* total number of temporaries including arguments */ + stix_oow_t tmpr_nargs; /* literals */ stix_oop_t* literals; - stix_size_t literal_count; - stix_size_t literal_capa; + stix_oow_t literal_count; + stix_oow_t literal_capa; /* byte array elements */ stix_oob_t* balit; - stix_size_t balit_count; - stix_size_t balit_capa; + stix_oow_t balit_count; + stix_oow_t balit_capa; /* array elements */ stix_oop_t* arlit; - stix_size_t arlit_count; - stix_size_t arlit_capa; + stix_oow_t arlit_count; + stix_oow_t arlit_capa; /* 0 for no primitive, 1 for a normal primitive, 2 for a named primitive */ int prim_type; @@ -525,13 +525,13 @@ struct stix_compiler_t stix_ooi_t prim_no; /* block depth */ - stix_size_t blk_depth; - stix_size_t* blk_tmprcnt; - stix_size_t blk_tmprcnt_capa; + stix_oow_t blk_depth; + stix_oow_t* blk_tmprcnt; + stix_oow_t blk_tmprcnt_capa; /* byte code */ stix_code_t code; - stix_size_t code_capa; + stix_oow_t code_capa; } mth; }; @@ -855,7 +855,7 @@ extern "C" { */ stix_heap_t* stix_makeheap ( stix_t* stix, - stix_size_t size + stix_oow_t size ); /** @@ -875,7 +875,7 @@ void stix_killheap ( void* stix_allocheapmem ( stix_t* stix, stix_heap_t* heap, - stix_size_t size + stix_oow_t size ); @@ -892,7 +892,7 @@ stix_oop_t stix_moveoop ( /* ========================================================================= */ void* stix_allocbytes ( stix_t* stix, - stix_size_t size + stix_oow_t size ); /** @@ -1023,23 +1023,23 @@ stix_oop_process_t stix_makeproc ( /* ========================================================================= */ /* utf8.c */ /* ========================================================================= */ -stix_size_t stix_uctoutf8 ( +stix_oow_t stix_uctoutf8 ( stix_uch_t uc, stix_bch_t* utf8, - stix_size_t size + stix_oow_t size ); -stix_size_t stix_utf8touc ( +stix_oow_t stix_utf8touc ( const stix_bch_t* utf8, - stix_size_t size, + stix_oow_t size, stix_uch_t* uc ); int stix_ucstoutf8 ( const stix_uch_t* ucs, - stix_size_t* ucslen, + stix_oow_t* ucslen, stix_bch_t* bcs, - stix_size_t* bcslen + stix_oow_t* bcslen ); /** @@ -1050,14 +1050,14 @@ int stix_ucstoutf8 ( * \code * const stix_bch_t* bcs = "test string"; * stix_uch_t ucs[100]; - * stix_size_t ucslen = STIX_COUNTOF(buf), n; - * stix_size_t bcslen = 11; + * stix_oow_t ucslen = STIX_COUNTOF(buf), n; + * stix_oow_t bcslen = 11; * int n; * n = stix_utf8toucs (bcs, &bcslen, ucs, &ucslen); * if (n <= -1) { invalid/incomplenete sequence or buffer to small } * \endcode * - * For a null-terminated string, you can specify ~(stix_size_t)0 in + * For a null-terminated string, you can specify ~(stix_oow_t)0 in * \a bcslen. The destination buffer \a ucs also must be large enough to * store a terminating null. Otherwise, -2 is returned. * @@ -1072,9 +1072,9 @@ int stix_ucstoutf8 ( */ int stix_utf8toucs ( const stix_bch_t* bcs, - stix_size_t* bcslen, + stix_oow_t* bcslen, stix_uch_t* ucs, - stix_size_t* ucslen + stix_oow_t* ucslen ); /* ========================================================================= */ diff --git a/stix/lib/stix-rbt.c b/stix/lib/stix-rbt.c index 7b33982..e22201e 100644 --- a/stix/lib/stix-rbt.c +++ b/stix/lib/stix-rbt.c @@ -56,14 +56,14 @@ #define rotate_right(rbt,pivot) rotate(rbt,pivot,0); STIX_INLINE stix_rbt_pair_t* stix_rbt_allocpair ( - stix_rbt_t* rbt, void* kptr, stix_size_t klen, void* vptr, stix_size_t vlen) + stix_rbt_t* rbt, void* kptr, stix_oow_t klen, void* vptr, stix_oow_t vlen) { stix_rbt_pair_t* n; copier_t kcop = rbt->style->copier[STIX_RBT_KEY]; copier_t vcop = rbt->style->copier[STIX_RBT_VAL]; - stix_size_t as = STIX_SIZEOF(stix_rbt_pair_t); + stix_oow_t as = STIX_SIZEOF(stix_rbt_pair_t); if (kcop == STIX_RBT_COPIER_INLINE) as += KTOB(rbt,klen); if (vcop == STIX_RBT_COPIER_INLINE) as += VTOB(rbt,vlen); @@ -191,7 +191,7 @@ const stix_rbt_style_t* stix_getrbtstyle (stix_rbt_style_kind_t kind) return &style[kind]; } -stix_rbt_t* stix_rbt_open (stix_mmgr_t* mmgr, stix_size_t xtnsize, int kscale, int vscale) +stix_rbt_t* stix_rbt_open (stix_mmgr_t* mmgr, stix_oow_t xtnsize, int kscale, int vscale) { stix_rbt_t* rbt; @@ -264,12 +264,12 @@ void stix_rbt_setstyle (stix_rbt_t* rbt, const stix_rbt_style_t* style) rbt->style = style; } -stix_size_t stix_rbt_getsize (const stix_rbt_t* rbt) +stix_oow_t stix_rbt_getsize (const stix_rbt_t* rbt) { return rbt->size; } -stix_rbt_pair_t* stix_rbt_search (const stix_rbt_t* rbt, const void* kptr, stix_size_t klen) +stix_rbt_pair_t* stix_rbt_search (const stix_rbt_t* rbt, const void* kptr, stix_oow_t klen) { stix_rbt_pair_t* pair = rbt->root; @@ -418,7 +418,7 @@ static void adjust (stix_rbt_t* rbt, stix_rbt_pair_t* pair) } static stix_rbt_pair_t* change_pair_val ( - stix_rbt_t* rbt, stix_rbt_pair_t* pair, void* vptr, stix_size_t vlen) + stix_rbt_t* rbt, stix_rbt_pair_t* pair, void* vptr, stix_oow_t vlen) { if (VPTR(pair) == vptr && VLEN(pair) == vlen) { @@ -434,7 +434,7 @@ static stix_rbt_pair_t* change_pair_val ( { copier_t vcop = rbt->style->copier[STIX_RBT_VAL]; void* ovptr = VPTR(pair); - stix_size_t ovlen = VLEN(pair); + stix_oow_t ovlen = VLEN(pair); /* place the new value according to the copier */ if (vcop == STIX_RBT_COPIER_SIMPLE) @@ -501,7 +501,7 @@ static stix_rbt_pair_t* change_pair_val ( } static stix_rbt_pair_t* insert ( - stix_rbt_t* rbt, void* kptr, stix_size_t klen, void* vptr, stix_size_t vlen, int opt) + stix_rbt_t* rbt, void* kptr, stix_oow_t klen, void* vptr, stix_oow_t vlen, int opt) { stix_rbt_pair_t* x_cur = rbt->root; stix_rbt_pair_t* x_par = STIX_NULL; @@ -570,32 +570,32 @@ static stix_rbt_pair_t* insert ( } stix_rbt_pair_t* stix_rbt_upsert ( - stix_rbt_t* rbt, void* kptr, stix_size_t klen, void* vptr, stix_size_t vlen) + stix_rbt_t* rbt, void* kptr, stix_oow_t klen, void* vptr, stix_oow_t vlen) { return insert (rbt, kptr, klen, vptr, vlen, UPSERT); } stix_rbt_pair_t* stix_rbt_ensert ( - stix_rbt_t* rbt, void* kptr, stix_size_t klen, void* vptr, stix_size_t vlen) + stix_rbt_t* rbt, void* kptr, stix_oow_t klen, void* vptr, stix_oow_t vlen) { return insert (rbt, kptr, klen, vptr, vlen, ENSERT); } stix_rbt_pair_t* stix_rbt_insert ( - stix_rbt_t* rbt, void* kptr, stix_size_t klen, void* vptr, stix_size_t vlen) + stix_rbt_t* rbt, void* kptr, stix_oow_t klen, void* vptr, stix_oow_t vlen) { return insert (rbt, kptr, klen, vptr, vlen, INSERT); } stix_rbt_pair_t* stix_rbt_update ( - stix_rbt_t* rbt, void* kptr, stix_size_t klen, void* vptr, stix_size_t vlen) + stix_rbt_t* rbt, void* kptr, stix_oow_t klen, void* vptr, stix_oow_t vlen) { return insert (rbt, kptr, klen, vptr, vlen, UPDATE); } stix_rbt_pair_t* stix_rbt_cbsert ( - stix_rbt_t* rbt, void* kptr, stix_size_t klen, cbserter_t cbserter, void* ctx) + stix_rbt_t* rbt, void* kptr, stix_oow_t klen, cbserter_t cbserter, void* ctx) { stix_rbt_pair_t* x_cur = rbt->root; stix_rbt_pair_t* x_par = STIX_NULL; @@ -865,7 +865,7 @@ static void delete_pair (stix_rbt_t* rbt, stix_rbt_pair_t* pair) rbt->size--; } -int stix_rbt_delete (stix_rbt_t* rbt, const void* kptr, stix_size_t klen) +int stix_rbt_delete (stix_rbt_t* rbt, const void* kptr, stix_oow_t klen) { stix_rbt_pair_t* pair; @@ -979,9 +979,9 @@ void stix_rbt_rwalk (stix_rbt_t* rbt, walker_t walker, void* ctx) walk (rbt, walker, ctx, RIGHT, LEFT); } -int stix_rbt_dflcomp (const stix_rbt_t* rbt, const void* kptr1, stix_size_t klen1, const void* kptr2, stix_size_t klen2) +int stix_rbt_dflcomp (const stix_rbt_t* rbt, const void* kptr1, stix_oow_t klen1, const void* kptr2, stix_oow_t klen2) { - stix_size_t min; + stix_oow_t min; int n, nn; if (klen1 < klen2) diff --git a/stix/lib/stix-rbt.h b/stix/lib/stix-rbt.h index 4b5a4bd..8b2d4ee 100644 --- a/stix/lib/stix-rbt.h +++ b/stix/lib/stix-rbt.h @@ -101,7 +101,7 @@ typedef enum stix_rbt_id_t stix_rbt_id_t; typedef void* (*stix_rbt_copier_t) ( stix_rbt_t* rbt /* red-black tree */, void* dptr /* pointer to a key or a value */, - stix_size_t dlen /* length of a key or a value */ + stix_oow_t dlen /* length of a key or a value */ ); /** @@ -110,7 +110,7 @@ typedef void* (*stix_rbt_copier_t) ( typedef void (*stix_rbt_freeer_t) ( stix_rbt_t* rbt, /**< red-black tree */ void* dptr, /**< pointer to a key or a value */ - stix_size_t dlen /**< length of a key or a value */ + stix_oow_t dlen /**< length of a key or a value */ ); /** @@ -123,9 +123,9 @@ typedef void (*stix_rbt_freeer_t) ( typedef int (*stix_rbt_comper_t) ( const stix_rbt_t* rbt, /**< red-black tree */ const void* kptr1, /**< key pointer */ - stix_size_t klen1, /**< key length */ + stix_oow_t klen1, /**< key length */ const void* kptr2, /**< key pointer */ - stix_size_t klen2 /**< key length */ + stix_oow_t klen2 /**< key length */ ); /** @@ -137,7 +137,7 @@ typedef int (*stix_rbt_comper_t) ( typedef void (*stix_rbt_keeper_t) ( stix_rbt_t* rbt, /**< red-black tree */ void* vptr, /**< value pointer */ - stix_size_t vlen /**< value length */ + stix_oow_t vlen /**< value length */ ); /** @@ -163,7 +163,7 @@ typedef stix_rbt_pair_t* (*stix_rbt_cbserter_t) ( stix_rbt_t* rbt, /**< red-black tree */ stix_rbt_pair_t* pair, /**< pair pointer */ void* kptr, /**< key pointer */ - stix_size_t klen, /**< key length */ + stix_oow_t klen, /**< key length */ void* ctx /**< callback context */ ); @@ -178,13 +178,13 @@ struct stix_rbt_pair_t struct { void* ptr; - stix_size_t len; + stix_oow_t len; } key; struct { void* ptr; - stix_size_t len; + stix_oow_t len; } val; /* management information below */ @@ -238,7 +238,7 @@ struct stix_rbt_t const stix_rbt_style_t* style; stix_oob_t scale[2]; /**< length scale */ stix_rbt_pair_t xnil; /**< internal nil node */ - stix_size_t size; /**< number of pairs */ + stix_oow_t size; /**< number of pairs */ stix_rbt_pair_t* root; /**< root pair */ }; @@ -262,7 +262,7 @@ struct stix_rbt_t /** * The STIX_RBT_SIZE() macro returns the number of pairs in red-black tree. */ -#define STIX_RBT_SIZE(m) ((const stix_size_t)(m)->size) +#define STIX_RBT_SIZE(m) ((const stix_oow_t)(m)->size) #define STIX_RBT_KSCALE(m) ((const int)(m)->scale[STIX_RBT_KEY]) #define STIX_RBT_VSCALE(m) ((const int)(m)->scale[STIX_RBT_VAL]) @@ -294,7 +294,7 @@ STIX_EXPORT const stix_rbt_style_t* stix_getrbtstyle ( */ STIX_EXPORT stix_rbt_t* stix_rbt_open ( stix_mmgr_t* mmgr, /**< memory manager */ - stix_size_t xtnsize, /**< extension size in bytes */ + stix_oow_t xtnsize, /**< extension size in bytes */ int kscale, /**< key scale */ int vscale /**< value scale */ ); @@ -353,7 +353,7 @@ STIX_EXPORT void stix_rbt_setstyle ( /** * The stix_rbt_getsize() function gets the number of pairs in red-black tree. */ -STIX_EXPORT stix_size_t stix_rbt_getsize ( +STIX_EXPORT stix_oow_t stix_rbt_getsize ( const stix_rbt_t* rbt /**< red-black tree */ ); @@ -367,7 +367,7 @@ STIX_EXPORT stix_size_t stix_rbt_getsize ( STIX_EXPORT stix_rbt_pair_t* stix_rbt_search ( const stix_rbt_t* rbt, /**< red-black tree */ const void* kptr, /**< key pointer */ - stix_size_t klen /**< the size of the key */ + stix_oow_t klen /**< the size of the key */ ); /** @@ -381,9 +381,9 @@ STIX_EXPORT stix_rbt_pair_t* stix_rbt_search ( STIX_EXPORT stix_rbt_pair_t* stix_rbt_upsert ( stix_rbt_t* rbt, /**< red-black tree */ void* kptr, /**< key pointer */ - stix_size_t klen, /**< key length */ + stix_oow_t klen, /**< key length */ void* vptr, /**< value pointer */ - stix_size_t vlen /**< value length */ + stix_oow_t vlen /**< value length */ ); /** @@ -395,9 +395,9 @@ STIX_EXPORT stix_rbt_pair_t* stix_rbt_upsert ( STIX_EXPORT stix_rbt_pair_t* stix_rbt_ensert ( stix_rbt_t* rbt, /**< red-black tree */ void* kptr, /**< key pointer */ - stix_size_t klen, /**< key length */ + stix_oow_t klen, /**< key length */ void* vptr, /**< value pointer */ - stix_size_t vlen /**< value length */ + stix_oow_t vlen /**< value length */ ); /** @@ -409,9 +409,9 @@ STIX_EXPORT stix_rbt_pair_t* stix_rbt_ensert ( STIX_EXPORT stix_rbt_pair_t* stix_rbt_insert ( stix_rbt_t* rbt, /**< red-black tree */ void* kptr, /**< key pointer */ - stix_size_t klen, /**< key length */ + stix_oow_t klen, /**< key length */ void* vptr, /**< value pointer */ - stix_size_t vlen /**< value length */ + stix_oow_t vlen /**< value length */ ); /** @@ -422,9 +422,9 @@ STIX_EXPORT stix_rbt_pair_t* stix_rbt_insert ( STIX_EXPORT stix_rbt_pair_t* stix_rbt_update ( stix_rbt_t* rbt, /**< red-black tree */ void* kptr, /**< key pointer */ - stix_size_t klen, /**< key length */ + stix_oow_t klen, /**< key length */ void* vptr, /**< value pointer */ - stix_size_t vlen /**< value length */ + stix_oow_t vlen /**< value length */ ); /** @@ -446,7 +446,7 @@ STIX_EXPORT stix_rbt_pair_t* stix_rbt_update ( * * stix_rbt_pair_t* cbserter ( * stix_rbt_t* rbt, stix_rbt_pair_t* pair, - * void* kptr, stix_size_t klen, void* ctx) + * void* kptr, stix_oow_t klen, void* ctx) * { * stix_cstr_t* v = (stix_cstr_t*)ctx; * if (pair == STIX_NULL) @@ -517,7 +517,7 @@ STIX_EXPORT stix_rbt_pair_t* stix_rbt_update ( STIX_EXPORT stix_rbt_pair_t* stix_rbt_cbsert ( stix_rbt_t* rbt, /**< red-black tree */ void* kptr, /**< key pointer */ - stix_size_t klen, /**< key length */ + stix_oow_t klen, /**< key length */ stix_rbt_cbserter_t cbserter, /**< callback function */ void* ctx /**< callback context */ ); @@ -529,7 +529,7 @@ STIX_EXPORT stix_rbt_pair_t* stix_rbt_cbsert ( STIX_EXPORT int stix_rbt_delete ( stix_rbt_t* rbt, /**< red-black tree */ const void* kptr, /**< key pointer */ - stix_size_t klen /**< key size */ + stix_oow_t klen /**< key size */ ); /** @@ -574,9 +574,9 @@ STIX_EXPORT void stix_rbt_rwalk ( STIX_EXPORT stix_rbt_pair_t* stix_rbt_allocpair ( stix_rbt_t* rbt, void* kptr, - stix_size_t klen, + stix_oow_t klen, void* vptr, - stix_size_t vlen + stix_oow_t vlen ); /** @@ -595,9 +595,9 @@ STIX_EXPORT void stix_rbt_freepair ( STIX_EXPORT int stix_rbt_dflcomp ( const stix_rbt_t* rbt, const void* kptr1, - stix_size_t klen1, + stix_oow_t klen1, const void* kptr2, - stix_size_t klen2 + stix_oow_t klen2 ); #if defined(__cplusplus) diff --git a/stix/lib/stix-utl.c b/stix/lib/stix-utl.c index 2f446c3..608101e 100644 --- a/stix/lib/stix-utl.c +++ b/stix/lib/stix-utl.c @@ -27,9 +27,9 @@ #include "stix-utl.h" -stix_size_t stix_hashbytes (const stix_oob_t* ptr, stix_size_t len) +stix_oow_t stix_hashbytes (const stix_oob_t* ptr, stix_oow_t len) { - stix_size_t h = 0; + stix_oow_t h = 0; const stix_uint8_t* bp, * be; bp = ptr; be = bp + len; @@ -38,14 +38,14 @@ stix_size_t stix_hashbytes (const stix_oob_t* ptr, stix_size_t len) return h; } -stix_size_t stix_hashuchars (const stix_uch_t* ptr, stix_size_t len) +stix_oow_t stix_hashuchars (const stix_uch_t* ptr, stix_oow_t len) { return stix_hashbytes ((const stix_oob_t *)ptr, len * STIX_SIZEOF(*ptr)); } -int stix_equalchars (const stix_uch_t* str1, const stix_uch_t* str2, stix_size_t len) +int stix_equalchars (const stix_uch_t* str1, const stix_uch_t* str2, stix_oow_t len) { - stix_size_t i; + stix_oow_t i; for (i = 0; i < len; i++) { @@ -88,7 +88,7 @@ int stix_compucbcstr (const stix_uch_t* str1, const stix_bch_t* str2) return (*str1 > *str2)? 1: -1; } -int stix_compucxbcstr (const stix_uch_t* str1, stix_size_t len, const stix_bch_t* str2) +int stix_compucxbcstr (const stix_uch_t* str1, stix_oow_t len, const stix_bch_t* str2) { const stix_uch_t* end = str1 + len; while (str1 < end && *str2 != '\0' && *str1 == *str2) str1++, str2++; @@ -97,25 +97,25 @@ int stix_compucxbcstr (const stix_uch_t* str1, stix_size_t len, const stix_bch_t return (*str1 > *str2)? 1: -1; } -void stix_copyuchars (stix_uch_t* dst, const stix_uch_t* src, stix_size_t len) +void stix_copyuchars (stix_uch_t* dst, const stix_uch_t* src, stix_oow_t len) { - stix_size_t i; + stix_oow_t i; for (i = 0; i < len; i++) dst[i] = src[i]; } -void stix_copybchars (stix_bch_t* dst, const stix_bch_t* src, stix_size_t len) +void stix_copybchars (stix_bch_t* dst, const stix_bch_t* src, stix_oow_t len) { - stix_size_t i; + stix_oow_t i; for (i = 0; i < len; i++) dst[i] = src[i]; } -void stix_copybchtouchars (stix_uch_t* dst, const stix_bch_t* src, stix_size_t len) +void stix_copybchtouchars (stix_uch_t* dst, const stix_bch_t* src, stix_oow_t len) { - stix_size_t i; + stix_oow_t i; for (i = 0; i < len; i++) dst[i] = src[i]; } -stix_size_t stix_copyucstr (stix_uch_t* dst, stix_size_t len, const stix_uch_t* src) +stix_oow_t stix_copyucstr (stix_uch_t* dst, stix_oow_t len, const stix_uch_t* src) { stix_uch_t* p, * p2; @@ -131,7 +131,7 @@ stix_size_t stix_copyucstr (stix_uch_t* dst, stix_size_t len, const stix_uch_t* return p - dst; } -stix_size_t stix_copybcstr (stix_bch_t* dst, stix_size_t len, const stix_bch_t* src) +stix_oow_t stix_copybcstr (stix_bch_t* dst, stix_oow_t len, const stix_bch_t* src) { stix_bch_t* p, * p2; @@ -147,21 +147,21 @@ stix_size_t stix_copybcstr (stix_bch_t* dst, stix_size_t len, const stix_bch_t* return p - dst; } -stix_size_t stix_countucstr (const stix_uch_t* str) +stix_oow_t stix_countucstr (const stix_uch_t* str) { const stix_uch_t* ptr = str; while (*ptr != '\0') ptr++; return ptr - str; } -stix_size_t stix_countbcstr (const stix_bch_t* str) +stix_oow_t stix_countbcstr (const stix_bch_t* str) { const stix_bch_t* ptr = str; while (*ptr != '\0') ptr++; return ptr - str; } -stix_uch_t* stix_finduchar (const stix_uch_t* ptr, stix_size_t len, stix_uch_t c) +stix_uch_t* stix_finduchar (const stix_uch_t* ptr, stix_oow_t len, stix_uch_t c) { const stix_uch_t* end; @@ -175,7 +175,7 @@ stix_uch_t* stix_finduchar (const stix_uch_t* ptr, stix_size_t len, stix_uch_t c return STIX_NULL; } -stix_bch_t* stix_findbchar (const stix_bch_t* ptr, stix_size_t len, stix_bch_t c) +stix_bch_t* stix_findbchar (const stix_bch_t* ptr, stix_oow_t len, stix_bch_t c) { const stix_bch_t* end; diff --git a/stix/lib/stix-utl.h b/stix/lib/stix-utl.h index 06f747b..028f243 100644 --- a/stix/lib/stix-utl.h +++ b/stix/lib/stix-utl.h @@ -57,14 +57,14 @@ extern "C" { /* ========================================================================= */ /* stix-utl.c */ /* ========================================================================= */ -stix_size_t stix_hashbytes ( +stix_oow_t stix_hashbytes ( const stix_oob_t* ptr, - stix_size_t len + stix_oow_t len ); -stix_size_t stix_hashuchars ( +stix_oow_t stix_hashuchars ( const stix_uch_t* ptr, - stix_size_t len + stix_oow_t len ); #define stix_hashbchars(ptr,len) stix_hashbytes(ptr,len) @@ -73,7 +73,7 @@ stix_size_t stix_hashuchars ( int stix_equalchars ( const stix_uch_t* str1, const stix_uch_t* str2, - stix_size_t len + stix_oow_t len ); int stix_compucstr ( @@ -93,57 +93,57 @@ int stix_compucbcstr ( int stix_compucxbcstr ( const stix_uch_t* str1, - stix_size_t len, + stix_oow_t len, const stix_bch_t* str2 ); void stix_copyuchars ( stix_uch_t* dst, const stix_uch_t* src, - stix_size_t len + stix_oow_t len ); void stix_copybchars ( stix_bch_t* dst, const stix_bch_t* src, - stix_size_t len + stix_oow_t len ); void stix_copybchtouchars ( stix_uch_t* dst, const stix_bch_t* src, - stix_size_t len + stix_oow_t len ); -stix_size_t stix_copyucstr ( +stix_oow_t stix_copyucstr ( stix_uch_t* dst, - stix_size_t len, + stix_oow_t len, const stix_uch_t* src ); -stix_size_t stix_copybcstr ( +stix_oow_t stix_copybcstr ( stix_bch_t* dst, - stix_size_t len, + stix_oow_t len, const stix_bch_t* src ); stix_uch_t* stix_finduchar ( const stix_uch_t* ptr, - stix_size_t len, + stix_oow_t len, stix_uch_t c ); stix_bch_t* stix_findbchar ( const stix_bch_t* ptr, - stix_size_t len, + stix_oow_t len, stix_bch_t c ); -stix_size_t stix_countucstr ( +stix_oow_t stix_countucstr ( const stix_uch_t* str ); -stix_size_t stix_countbcstr ( +stix_oow_t stix_countbcstr ( const stix_bch_t* str ); diff --git a/stix/lib/stix.c b/stix/lib/stix.c index e663746..7b985f1 100644 --- a/stix/lib/stix.c +++ b/stix/lib/stix.c @@ -27,7 +27,7 @@ #include "stix-prv.h" -stix_t* stix_open (stix_mmgr_t* mmgr, stix_size_t xtnsize, stix_size_t heapsize, const stix_vmprim_t* vmprim, stix_errnum_t* errnum) +stix_t* stix_open (stix_mmgr_t* mmgr, stix_oow_t xtnsize, stix_oow_t heapsize, const stix_vmprim_t* vmprim, stix_errnum_t* errnum) { stix_t* stix; @@ -83,7 +83,7 @@ static void fill_bigint_tables (stix_t* stix) } } -int stix_init (stix_t* stix, stix_mmgr_t* mmgr, stix_size_t heapsz, const stix_vmprim_t* vmprim) +int stix_init (stix_t* stix, stix_mmgr_t* mmgr, stix_oow_t heapsz, const stix_vmprim_t* vmprim) { STIX_MEMSET (stix, 0, STIX_SIZEOF(*stix)); stix->mmgr = mmgr; @@ -244,7 +244,7 @@ void stix_deregcb (stix_t* stix, stix_cb_t* cb) stix_freemem (stix, cb); } -void* stix_allocmem (stix_t* stix, stix_size_t size) +void* stix_allocmem (stix_t* stix, stix_oow_t size) { void* ptr; @@ -253,7 +253,7 @@ void* stix_allocmem (stix_t* stix, stix_size_t size) return ptr; } -void* stix_callocmem (stix_t* stix, stix_size_t size) +void* stix_callocmem (stix_t* stix, stix_oow_t size) { void* ptr; @@ -263,7 +263,7 @@ void* stix_callocmem (stix_t* stix, stix_size_t size) return ptr; } -void* stix_reallocmem (stix_t* stix, void* ptr, stix_size_t size) +void* stix_reallocmem (stix_t* stix, void* ptr, stix_oow_t size) { ptr = STIX_MMGR_REALLOC (stix->mmgr, ptr, size); if (!ptr) stix->errnum = STIX_ENOMEM; diff --git a/stix/lib/stix.h b/stix/lib/stix.h index 67de621..23a7dbf 100644 --- a/stix/lib/stix.h +++ b/stix/lib/stix.h @@ -759,8 +759,8 @@ extern "C" { STIX_EXPORT stix_t* stix_open ( stix_mmgr_t* mmgr, - stix_size_t xtnsize, - stix_size_t heapsize, + stix_oow_t xtnsize, + stix_oow_t heapsize, const stix_vmprim_t* vmprim, stix_errnum_t* errnum ); @@ -772,7 +772,7 @@ STIX_EXPORT void stix_close ( STIX_EXPORT int stix_init ( stix_t* vm, stix_mmgr_t* mmgr, - stix_size_t heapsize, + stix_oow_t heapsize, const stix_vmprim_t* vmprim ); @@ -912,18 +912,18 @@ STIX_EXPORT void stix_poptmps ( STIX_EXPORT void* stix_allocmem ( stix_t* stix, - stix_size_t size + stix_oow_t size ); STIX_EXPORT void* stix_callocmem ( stix_t* stix, - stix_size_t size + stix_oow_t size ); STIX_EXPORT void* stix_reallocmem ( stix_t* stix, void* ptr, - stix_size_t size + stix_oow_t size ); STIX_EXPORT void stix_freemem ( diff --git a/stix/lib/utf8.c b/stix/lib/utf8.c index 4464be9..8ae9c6b 100644 --- a/stix/lib/utf8.c +++ b/stix/lib/utf8.c @@ -81,7 +81,7 @@ static STIX_INLINE __utf8_t* get_utf8_slot (stix_uch_t uc) return STIX_NULL; /* invalid character */ } -stix_size_t stix_uctoutf8 (stix_uch_t uc, stix_bch_t* utf8, stix_size_t size) +stix_oow_t stix_uctoutf8 (stix_uch_t uc, stix_bch_t* utf8, stix_oow_t size) { __utf8_t* cur = get_utf8_slot (uc); @@ -105,10 +105,10 @@ stix_size_t stix_uctoutf8 (stix_uch_t uc, stix_bch_t* utf8, stix_size_t size) /* small buffer is also indicated by this return value * greater than 'size'. */ - return (stix_size_t)cur->length; + return (stix_oow_t)cur->length; } -stix_size_t stix_utf8touc (const stix_bch_t* utf8, stix_size_t size, stix_uch_t* uc) +stix_oow_t stix_utf8touc (const stix_bch_t* utf8, stix_oow_t size, stix_uch_t* uc) { __utf8_t* cur, * end; @@ -171,7 +171,7 @@ stix_size_t stix_utf8touc (const stix_bch_t* utf8, stix_size_t size, stix_uch_t* * and * the incomplete seqeunce error (size < cur->length). */ - return (stix_size_t)cur->length; + return (stix_oow_t)cur->length; } cur++; } @@ -182,12 +182,12 @@ stix_size_t stix_utf8touc (const stix_bch_t* utf8, stix_size_t size, stix_uch_t* /* ----------------------------------------------------------------------- */ static STIX_INLINE int bcsn_to_ucsn_with_cmgr ( - const stix_bch_t* bcs, stix_size_t* bcslen, - stix_uch_t* ucs, stix_size_t* ucslen, stix_cmgr_t* cmgr, int all) + const stix_bch_t* bcs, stix_oow_t* bcslen, + stix_uch_t* ucs, stix_oow_t* ucslen, stix_cmgr_t* cmgr, int all) { const stix_bch_t* p; int ret = 0; - stix_size_t mlen; + stix_oow_t mlen; if (ucs) { @@ -203,7 +203,7 @@ static STIX_INLINE int bcsn_to_ucsn_with_cmgr ( while (mlen > 0) { - stix_size_t n; + stix_oow_t n; if (q >= qend) { @@ -259,14 +259,14 @@ static STIX_INLINE int bcsn_to_ucsn_with_cmgr ( * the buffer. */ stix_uch_t w; - stix_size_t wlen = 0; + stix_oow_t wlen = 0; p = bcs; mlen = *bcslen; while (mlen > 0) { - stix_size_t n; + stix_oow_t n; n = cmgr->bctouc (p, mlen, &w); if (n == 0) @@ -303,11 +303,11 @@ static STIX_INLINE int bcsn_to_ucsn_with_cmgr ( } static STIX_INLINE int bcs_to_ucs_with_cmgr ( - const stix_bch_t* bcs, stix_size_t* bcslen, - stix_uch_t* ucs, stix_size_t* ucslen, stix_cmgr_t* cmgr, int all) + const stix_bch_t* bcs, stix_oow_t* bcslen, + stix_uch_t* ucs, stix_oow_t* ucslen, stix_cmgr_t* cmgr, int all) { const stix_bch_t* bp; - stix_size_t mlen, wlen; + stix_oow_t mlen, wlen; int n; for (bp = bcs; *bp != '\0'; bp++) /* nothing */ ; @@ -326,8 +326,8 @@ static STIX_INLINE int bcs_to_ucs_with_cmgr ( } static STIX_INLINE int ucsn_to_bcsn_with_cmgr ( - const stix_uch_t* ucs, stix_size_t* ucslen, - stix_bch_t* bcs, stix_size_t* bcslen, stix_cmgr_t* cmgr) + const stix_uch_t* ucs, stix_oow_t* ucslen, + stix_bch_t* bcs, stix_oow_t* bcslen, stix_cmgr_t* cmgr) { const stix_uch_t* p = ucs; const stix_uch_t* end = ucs + *ucslen; @@ -335,11 +335,11 @@ static STIX_INLINE int ucsn_to_bcsn_with_cmgr ( if (bcs) { - stix_size_t rem = *bcslen; + stix_oow_t rem = *bcslen; while (p < end) { - stix_size_t n; + stix_oow_t n; if (rem <= 0) { @@ -366,11 +366,11 @@ static STIX_INLINE int ucsn_to_bcsn_with_cmgr ( else { stix_bch_t bcsbuf[STIX_BCLEN_MAX]; - stix_size_t mlen = 0; + stix_oow_t mlen = 0; while (p < end) { - stix_size_t n; + stix_oow_t n; n = cmgr->uctobc (*p, bcsbuf, STIX_COUNTOF(bcsbuf)); if (n == 0) @@ -396,19 +396,19 @@ static STIX_INLINE int ucsn_to_bcsn_with_cmgr ( static int ucs_to_bcs_with_cmgr ( - const stix_uch_t* ucs, stix_size_t* ucslen, - stix_bch_t* bcs, stix_size_t* bcslen, stix_cmgr_t* cmgr) + const stix_uch_t* ucs, stix_oow_t* ucslen, + stix_bch_t* bcs, stix_oow_t* bcslen, stix_cmgr_t* cmgr) { const stix_uch_t* p = ucs; int ret = 0; if (bcs) { - stix_size_t rem = *bcslen; + stix_oow_t rem = *bcslen; while (*p != '\0') { - stix_size_t n; + stix_oow_t n; if (rem <= 0) { @@ -448,11 +448,11 @@ static int ucs_to_bcs_with_cmgr ( else { stix_bch_t bcsbuf[STIX_BCLEN_MAX]; - stix_size_t mlen = 0; + stix_oow_t mlen = 0; while (*p != '\0') { - stix_size_t n; + stix_oow_t n; n = cmgr->uctobc (*p, bcsbuf, STIX_COUNTOF(bcsbuf)); if (n == 0) @@ -482,9 +482,9 @@ static stix_cmgr_t utf8_cmgr = stix_uctoutf8 }; -int stix_utf8toucs (const stix_bch_t* bcs, stix_size_t* bcslen, stix_uch_t* ucs, stix_size_t* ucslen) +int stix_utf8toucs (const stix_bch_t* bcs, stix_oow_t* bcslen, stix_uch_t* ucs, stix_oow_t* ucslen) { - if (*bcslen == ~(stix_size_t)0) + if (*bcslen == ~(stix_oow_t)0) { /* the source is null-terminated. */ return bcs_to_ucs_with_cmgr (bcs, bcslen, ucs, ucslen, &utf8_cmgr, 0); @@ -496,9 +496,9 @@ int stix_utf8toucs (const stix_bch_t* bcs, stix_size_t* bcslen, stix_uch_t* ucs, } } -int stix_ucstoutf8 (const stix_uch_t* ucs, stix_size_t *ucslen, stix_bch_t* bcs, stix_size_t* bcslen) +int stix_ucstoutf8 (const stix_uch_t* ucs, stix_oow_t *ucslen, stix_bch_t* bcs, stix_oow_t* bcslen) { - if (*ucslen == ~(stix_size_t)0) + if (*ucslen == ~(stix_oow_t)0) { /* null-terminated */ return ucs_to_bcs_with_cmgr (ucs, ucslen, bcs, bcslen, &utf8_cmgr); @@ -511,7 +511,7 @@ int stix_ucstoutf8 (const stix_uch_t* ucs, stix_size_t *ucslen, stix_bch_t* bcs, } /* -stix_size_t stix_ucslen (const stix_uch_t* ucs) +stix_oow_t stix_ucslen (const stix_uch_t* ucs) { const stix_uch_t* ptr = ucs; while (*ptr) ptr = STIX_INCPTR(const stix_uch_t, ptr, 1);