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

rewrote stix_bitandints(), stix_bitorints(), stix_bitxorints() to handle negative numbers in the 2's complement form

Browse Source
This commit is contained in:
hyunghwan.chung 2015-12-17 16:11:10 +00:00
parent bf412e0c07
commit 08cfa55acc
17 changed files with 866 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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.

781
stix/lib/bigint.c
View File

File diff suppressed because it is too large Load Diff

150
stix/lib/comp.c
View File

@ -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);

12
stix/lib/debug.c
View File

@ -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

6
stix/lib/exec.c
View File

@ -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);

4
stix/lib/heap.c
View File

@ -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;

36
stix/lib/main.c
View File

@ -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);

2
stix/lib/obj.c
View File

@ -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;

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

@ -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
* =========================================================================*/

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

@ -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
);
/* ========================================================================= */

32
stix/lib/stix-rbt.c
View File

@ -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)

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

@ -101,7 +101,7 @@ typedef enum stix_rbt_id_t stix_rbt_id_t;
typedef void* (*stix_rbt_copier_t) (
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)

36
stix/lib/stix-utl.c
View File

@ -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;

34
stix/lib/stix-utl.h
View File

@ -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
);

10
stix/lib/stix.c
View File

@ -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;

12
stix/lib/stix.h
View File

@ -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 (

60
stix/lib/utf8.c
View File

@ -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);