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

redefined some types

Browse Source
This commit is contained in:
hyunghwan.chung 2015-10-28 14:58:58 +00:00
parent 2aef6b9bab
commit 98631175d0
17 changed files with 460 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
stix/configure vendored
View File

@ -17915,8 +17915,8 @@ then
fi
fi
CFLAGS="$CFLAGS -DSTIX_HAVE_CONFIG_H"
CXXFLAGS="$CXXFLAGS -DSTIX_HAVE_CONFIG_H"
CFLAGS="$CFLAGS -DSTIX_HAVE_CFG_H"
CXXFLAGS="$CXXFLAGS -DSTIX_HAVE_CFG_H"
CFLAGS="$CFLAGS -D_LARGEFILE64_SOURCE"
CXXFLAGS="$CXXFLAGS -D_LARGEFILE64_SOURCE"

4
stix/configure.ac
View File

@ -95,8 +95,8 @@ then
fi
dnl indicate the existence of config.h
CFLAGS="$CFLAGS -DSTIX_HAVE_CONFIG_H"
CXXFLAGS="$CXXFLAGS -DSTIX_HAVE_CONFIG_H"
CFLAGS="$CFLAGS -DSTIX_HAVE_CFG_H"
CXXFLAGS="$CXXFLAGS -DSTIX_HAVE_CFG_H"
dnl make visible the 64-bit interface to the file system
CFLAGS="$CFLAGS -D_LARGEFILE64_SOURCE"

186
stix/lib/comp.c
View File

@ -79,7 +79,7 @@ typedef struct var_info_t var_info_t;
static struct voca_t
{
stix_oow_t len;
stix_uch_t str[11];
stix_ooch_t str[11];
} vocas[] = {
{ 4, { 'b','y','t','e' } },
{ 9, { 'c','h','a','r','a','c','t','e','r' } },
@ -147,7 +147,7 @@ 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 STIX_INLINE int is_spacechar (stix_uci_t c)
static STIX_INLINE int is_spacechar (stix_ooci_t c)
{
/* TODO: handle other space unicode characters */
switch (c)
@ -166,25 +166,25 @@ static STIX_INLINE int is_spacechar (stix_uci_t c)
}
static STIX_INLINE int is_alphachar (stix_uci_t c)
static STIX_INLINE int is_alphachar (stix_ooci_t c)
{
/* TODO: support full unicode */
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}
static STIX_INLINE int is_digitchar (stix_uci_t c)
static STIX_INLINE int is_digitchar (stix_ooci_t c)
{
/* TODO: support full unicode */
return (c >= '0' && c <= '9');
}
static STIX_INLINE int is_alnumchar (stix_uci_t c)
static STIX_INLINE int is_alnumchar (stix_ooci_t c)
{
/* TODO: support full unicode */
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
}
static STIX_INLINE int is_binselchar (stix_uci_t c)
static STIX_INLINE int is_binselchar (stix_ooci_t c)
{
/*
* binary-selector-character :=
@ -218,17 +218,17 @@ static STIX_INLINE int is_binselchar (stix_uci_t c)
}
}
static STIX_INLINE int is_leadidentchar (stix_uci_t c)
static STIX_INLINE int is_leadidentchar (stix_ooci_t c)
{
return is_alphachar(c) || c == '_';
}
static STIX_INLINE int is_identchar (stix_uci_t c)
static STIX_INLINE int is_identchar (stix_ooci_t c)
{
return is_alnumchar(c) || c == '_';
}
static STIX_INLINE int is_closing_char (stix_uci_t c)
static STIX_INLINE int is_closing_char (stix_ooci_t c)
{
switch (c)
{
@ -271,12 +271,12 @@ static STIX_INLINE int is_token_keyword (stix_t* stix, voca_id_t id)
return stix->c->tok.type == STIX_IOTOK_KEYWORD && does_token_name_match(stix, id);
}
static STIX_INLINE int is_word (const stix_ucs_t* ucs, voca_id_t id)
static STIX_INLINE int is_word (const stix_oocs_t* ucs, voca_id_t id)
{
return ucs->len == vocas[id].len && stix_equalchars(ucs->ptr, vocas[id].str, vocas[id].len);
}
static int is_reserved_word (const stix_ucs_t* ucs)
static int is_reserved_word (const stix_oocs_t* ucs)
{
static int rw[] =
{
@ -300,7 +300,7 @@ static int is_reserved_word (const stix_ucs_t* ucs)
static int begin_include (stix_t* fsc);
static int end_include (stix_t* fsc);
static void set_syntax_error (stix_t* stix, stix_synerrnum_t num, const stix_ioloc_t* loc, const stix_ucs_t* tgt)
static void set_syntax_error (stix_t* stix, stix_synerrnum_t num, const stix_ioloc_t* loc, const stix_oocs_t* tgt)
{
stix->errnum = STIX_ESYNTAX;
stix->c->synerr.num = num;
@ -313,7 +313,7 @@ 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_ucs_t* src, stix_ucs_t* dst, stix_size_t* dst_capa, int append, stix_uch_t add_delim)
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)
{
stix_size_t len, pos;
@ -331,7 +331,7 @@ static int copy_string_to (stix_t* stix, const stix_ucs_t* src, stix_ucs_t* dst,
if (len > *dst_capa)
{
stix_uch_t* tmp;
stix_ooch_t* tmp;
stix_size_t capa;
capa = STIX_ALIGN(len, CLASS_BUFFER_ALIGN);
@ -344,12 +344,12 @@ static int copy_string_to (stix_t* stix, const stix_ucs_t* src, stix_ucs_t* dst,
}
if (append && add_delim) dst->ptr[pos++] = add_delim;
stix_copyuchars (&dst->ptr[pos], src->ptr, src->len);
stix_copyoochars (&dst->ptr[pos], src->ptr, src->len);
dst->len = len;
return 0;
}
static int find_word_in_string (const stix_ucs_t* haystack, const stix_ucs_t* name, stix_size_t* xindex)
static int find_word_in_string (const stix_oocs_t* haystack, const stix_oocs_t* name, stix_size_t* xindex)
{
/* this function is inefficient. but considering the typical number
* of arguments and temporary variables, the inefficiency can be
@ -357,7 +357,7 @@ static int find_word_in_string (const stix_ucs_t* haystack, const stix_ucs_t* na
* table from a name to an index should be greater than this simple
* inefficient lookup */
stix_uch_t* t, * e;
stix_ooch_t* t, * e;
stix_size_t index, i;
t = haystack->ptr;
@ -401,7 +401,7 @@ static int find_word_in_string (const stix_ucs_t* haystack, const stix_ucs_t* na
(c >= 'A' && c <= 'Z')? ((c - 'A' + 10 < base)? (c - 'A' + 10): base): \
(c >= 'a' && c <= 'z')? ((c - 'a' + 10 < base)? (c - 'a' + 10): base): base)
static int string_to_smint (stix_t* stix, stix_ucs_t* str, int radixed, stix_ooi_t* num)
static int string_to_smint (stix_t* stix, stix_oocs_t* str, int radixed, stix_ooi_t* num)
{
/* it is not a generic conversion function.
* it assumes a certain pre-sanity check on the string
@ -409,7 +409,7 @@ static int string_to_smint (stix_t* stix, stix_ucs_t* str, int radixed, stix_ooi
/* TODO: handle floating point numbers, etc, handle radix */
int v, negsign, base;
const stix_uch_t* ptr, * end;
const stix_ooch_t* ptr, * end;
stix_oow_t value, old_value;
negsign = 0;
@ -514,18 +514,18 @@ static int string_to_smint (stix_t* stix, stix_ucs_t* str, int radixed, stix_ooi
do { if (add_token_char(stix, c) <= -1) return -1; } while (0)
static STIX_INLINE int add_token_str (stix_t* stix, const stix_uch_t* ptr, stix_size_t len)
static STIX_INLINE int add_token_str (stix_t* stix, const stix_ooch_t* ptr, stix_size_t len)
{
stix_ucs_t tmp;
stix_oocs_t tmp;
tmp.ptr = (stix_uch_t*)ptr;
tmp.ptr = (stix_ooch_t*)ptr;
tmp.len = len;
return copy_string_to (stix, &tmp, &stix->c->tok.name, &stix->c->tok.name_capa, 1, '\0');
}
static STIX_INLINE int add_token_char (stix_t* stix, stix_uch_t c)
static STIX_INLINE int add_token_char (stix_t* stix, stix_ooch_t c)
{
stix_ucs_t tmp;
stix_oocs_t tmp;
tmp.ptr = &c;
tmp.len = 1;
@ -542,7 +542,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_uci_t lc, ec;
stix_ooci_t lc, ec;
if (stix->c->nungots > 0)
{
@ -648,7 +648,7 @@ static int skip_spaces (stix_t* stix)
static int skip_comment (stix_t* stix)
{
stix_uci_t c = stix->c->lxc.c;
stix_ooci_t c = stix->c->lxc.c;
stix_iolxc_t lc;
if (c == '"')
@ -706,14 +706,14 @@ static int skip_comment (stix_t* stix)
return 0;
}
static int get_ident (stix_t* stix, stix_uci_t char_read_ahead)
static int get_ident (stix_t* stix, stix_ooci_t char_read_ahead)
{
/*
* identifier := alpha-char (alpha-char | digit-char)*
* keyword := identifier ":"
*/
stix_uci_t c;
stix_ooci_t c;
c = stix->c->lxc.c;
stix->c->tok.type = STIX_IOTOK_IDENT;
@ -839,7 +839,7 @@ static int get_numlit (stix_t* stix, int negated)
* fractionalDigits := decimal-integer
*/
stix_uci_t c;
stix_ooci_t c;
int radix = 0, r;
c = stix->c->lxc.c;
@ -905,7 +905,7 @@ static int get_charlit (stix_t* stix)
* character := normal-character | "'"
*/
stix_uci_t c = stix->c->lxc.c; /* even a new-line or white space would be taken */
stix_ooci_t c = stix->c->lxc.c; /* even a new-line or white space would be taken */
if (c == STIX_UCI_EOF)
{
set_syntax_error (stix, STIX_SYNERR_CLTNT, &stix->c->lxc.l, STIX_NULL);
@ -927,7 +927,7 @@ static int get_strlit (stix_t* stix)
* normal-character := character-except-single-quote
*/
stix_uci_t c = stix->c->lxc.c;
stix_ooci_t c = stix->c->lxc.c;
stix->c->tok.type = STIX_IOTOK_STRLIT;
do
@ -953,12 +953,12 @@ static int get_strlit (stix_t* stix)
return 0;
}
static int get_string (stix_t* stix, stix_uch_t end_char, stix_uch_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_size_t preescaped)
{
stix_uci_t c;
stix_ooci_t c;
stix_size_t escaped = preescaped;
stix_size_t digit_count = 0;
stix_uci_t c_acc = 0;
stix_ooci_t c_acc = 0;
stix->c->tok.type = STIX_IOTOK_STRLIT;
@ -1030,7 +1030,7 @@ static int get_string (stix_t* stix, stix_uch_t end_char, stix_uch_t esc_char, i
}
else
{
stix_uch_t rc;
stix_ooch_t rc;
rc = (escaped == 2)? 'x':
(escaped == 4)? 'u': 'U';
@ -1081,14 +1081,14 @@ static int get_string (stix_t* stix, stix_uch_t end_char, stix_uch_t esc_char, i
c_acc = 0;
continue;
}
else if (c == 'u' && STIX_SIZEOF(stix_uch_t) >= 2)
else if (c == 'u' && STIX_SIZEOF(stix_ooch_t) >= 2)
{
escaped = 4;
digit_count = 0;
c_acc = 0;
continue;
}
else if (c == 'U' && STIX_SIZEOF(stix_uch_t) >= 4)
else if (c == 'U' && STIX_SIZEOF(stix_ooch_t) >= 4)
{
escaped = 8;
digit_count = 0;
@ -1119,7 +1119,7 @@ static int get_binsel (stix_t* stix)
/*
* binary-selector := binary-selector-character+
*/
stix_uci_t oc;
stix_ooci_t oc;
oc = stix->c->lxc.c;
ADD_TOKEN_CHAR (stix, oc);
@ -1150,7 +1150,7 @@ static int get_binsel (stix_t* stix)
static int get_token (stix_t* stix)
{
stix_uci_t c;
stix_ooci_t c;
int n;
retry:
@ -1374,7 +1374,7 @@ retry:
case 'S': /* a string with a C-style escape sequences */
case 'M': /* a symbol with a C-style escape sequences */
{
stix_uci_t saved_c = c;
stix_ooci_t saved_c = c;
GET_CHAR_TO (stix, c);
if (c == '\'')
@ -1437,7 +1437,7 @@ retry:
}
else
{
stix->c->ilchr = (stix_uch_t)c;
stix->c->ilchr = (stix_ooch_t)c;
set_syntax_error (stix, STIX_SYNERR_ILCHR, &stix->c->lxc.l, &stix->c->ilchr_ucs);
return -1;
}
@ -1451,7 +1451,7 @@ retry:
/*
printf ("TOKEN: [");
print_ucs (&stix->c->tok.name);
print_oocs (&stix->c->tok.name);
printf ("]\n");
*/
return 0;
@ -1472,17 +1472,17 @@ static void clear_io_names (stix_t* stix)
}
}
static const stix_uch_t* add_io_name (stix_t* stix, const stix_ucs_t* name)
static const stix_ooch_t* add_io_name (stix_t* stix, const stix_oocs_t* name)
{
stix_iolink_t* link;
stix_uch_t* ptr;
stix_ooch_t* ptr;
link = (stix_iolink_t*) stix_callocmem (stix, STIX_SIZEOF(*link) + STIX_SIZEOF(stix_uch_t) * (name->len + 1));
link = (stix_iolink_t*) stix_callocmem (stix, STIX_SIZEOF(*link) + STIX_SIZEOF(stix_ooch_t) * (name->len + 1));
if (!link) return STIX_NULL;
ptr = (stix_uch_t*)(link + 1);
ptr = (stix_ooch_t*)(link + 1);
stix_copyuchars (ptr, name->ptr, name->len);
stix_copyoochars (ptr, name->ptr, name->len);
ptr[name->len] = '\0';
link->link = stix->c->io_names;
@ -1494,7 +1494,7 @@ static const stix_uch_t* add_io_name (stix_t* stix, const stix_ucs_t* name)
static int begin_include (stix_t* stix)
{
stix_io_arg_t* arg;
const stix_uch_t* io_name;
const stix_ooch_t* io_name;
io_name = add_io_name (stix, &stix->c->tok.name);
if (!io_name) return -1;
@ -1806,12 +1806,12 @@ 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_uch_t ch, stix_size_t* index)
static STIX_INLINE int add_character_literal (stix_t* stix, stix_ooch_t ch, stix_size_t* index)
{
return add_literal (stix, STIX_OOP_FROM_CHAR(ch), index);
}
static int add_string_literal (stix_t* stix, const stix_ucs_t* str, stix_size_t* index)
static int add_string_literal (stix_t* stix, const stix_oocs_t* str, stix_size_t* index)
{
stix_oop_t lit;
stix_size_t i;
@ -1835,7 +1835,7 @@ static int add_string_literal (stix_t* stix, const stix_ucs_t* str, stix_size_t*
return add_literal (stix, lit, index);
}
static int add_symbol_literal (stix_t* stix, const stix_ucs_t* str, stix_size_t* index)
static int add_symbol_literal (stix_t* stix, const stix_oocs_t* str, stix_size_t* index)
{
stix_oop_t tmp;
@ -1845,21 +1845,21 @@ static int add_symbol_literal (stix_t* stix, const stix_ucs_t* str, stix_size_t*
return add_literal (stix, tmp, index);
}
static STIX_INLINE int set_class_fqn (stix_t* stix, const stix_ucs_t* name)
static STIX_INLINE int set_class_fqn (stix_t* stix, const stix_oocs_t* name)
{
if (copy_string_to (stix, name, &stix->c->cls.fqn, &stix->c->cls.fqn_capa, 0, '\0') <= -1) return -1;
stix->c->cls.name = stix->c->cls.fqn;
return 0;
}
static STIX_INLINE int set_superclass_fqn (stix_t* stix, const stix_ucs_t* name)
static STIX_INLINE int set_superclass_fqn (stix_t* stix, const stix_oocs_t* name)
{
if (copy_string_to (stix, name, &stix->c->cls.superfqn, &stix->c->cls.superfqn_capa, 0, '\0') <= -1) return -1;
stix->c->cls.supername = stix->c->cls.superfqn;
return 0;
}
static STIX_INLINE int add_class_level_variable (stix_t* stix, var_type_t index, const stix_ucs_t* name)
static STIX_INLINE int add_class_level_variable (stix_t* stix, var_type_t index, const stix_oocs_t* name)
{
int n;
@ -1873,7 +1873,7 @@ static STIX_INLINE int add_class_level_variable (stix_t* stix, var_type_t index,
return n;
}
static STIX_INLINE int add_pool_dictionary (stix_t* stix, const stix_ucs_t* name, stix_oop_set_t pooldic_oop)
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;
@ -1909,13 +1909,13 @@ static STIX_INLINE int add_pool_dictionary (stix_t* stix, const stix_ucs_t* name
}
static stix_ssize_t find_class_level_variable (stix_t* stix, stix_oop_class_t self, const stix_ucs_t* name, var_info_t* var)
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)
{
stix_size_t pos;
stix_oop_t super;
stix_oop_char_t v;
stix_oop_char_t* vv;
stix_ucs_t hs;
stix_oocs_t hs;
int index;
if (self)
@ -2045,7 +2045,7 @@ done:
return pos;
}
static int clone_assignee (stix_t* stix, const stix_ucs_t* name, stix_size_t* offset)
static int clone_assignee (stix_t* stix, const stix_oocs_t* name, stix_size_t* offset)
{
int n;
stix_size_t old_len;
@ -2060,7 +2060,7 @@ static int clone_assignee (stix_t* stix, const stix_ucs_t* name, stix_size_t* of
return 0;
}
static int clone_binary_selector (stix_t* stix, const stix_ucs_t* name, stix_size_t* offset)
static int clone_binary_selector (stix_t* stix, const stix_oocs_t* name, stix_size_t* offset)
{
int n;
stix_size_t old_len;
@ -2075,7 +2075,7 @@ static int clone_binary_selector (stix_t* stix, const stix_ucs_t* name, stix_siz
return 0;
}
static int clone_keyword (stix_t* stix, const stix_ucs_t* name, stix_size_t* offset)
static int clone_keyword (stix_t* stix, const stix_oocs_t* name, stix_size_t* offset)
{
int n;
stix_size_t old_len;
@ -2090,31 +2090,31 @@ static int clone_keyword (stix_t* stix, const stix_ucs_t* name, stix_size_t* off
return 0;
}
static int add_method_name_fragment (stix_t* stix, const stix_ucs_t* name)
static int add_method_name_fragment (stix_t* stix, const stix_oocs_t* name)
{
/* method name fragments are concatenated without any delimiters */
return copy_string_to (stix, name, &stix->c->mth.name, &stix->c->mth.name_capa, 1, '\0');
}
static int method_exists (stix_t* stix, const stix_ucs_t* name)
static int method_exists (stix_t* stix, const stix_oocs_t* name)
{
/* check if the current class contains a method of the given name */
return stix_lookupdic (stix, stix->c->cls.mthdic_oop[stix->c->mth.type], name) != STIX_NULL;
}
static int add_temporary_variable (stix_t* stix, const stix_ucs_t* name)
static int add_temporary_variable (stix_t* stix, const stix_oocs_t* name)
{
/* temporary variable names are added to the string with leading
* space if it's not the first variable */
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_ucs_t* name, stix_size_t* xindex)
static STIX_INLINE int find_temporary_variable (stix_t* stix, const stix_oocs_t* name, stix_size_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_ucs_t* name)
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_oop_t sym;
@ -2144,11 +2144,11 @@ oops:
return STIX_NULL;
}
static int preprocess_dotted_name (stix_t* stix, int dont_add_ns, int accept_pooldic_as_ns, const stix_ucs_t* fqn, const stix_ioloc_t* fqn_loc, stix_ucs_t* name, stix_oop_set_t* ns_oop)
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_uch_t* ptr, * dot;
const stix_ooch_t* ptr, * dot;
stix_size_t len;
stix_ucs_t seg;
stix_oocs_t seg;
stix_oop_set_t dic;
stix_oop_association_t ass;
int pooldic_gotten = 0;
@ -2159,9 +2159,9 @@ static int preprocess_dotted_name (stix_t* stix, int dont_add_ns, int accept_poo
while (1)
{
seg.ptr = (stix_uch_t*)ptr;
seg.ptr = (stix_ooch_t*)ptr;
dot = stix_findchar (ptr, len, '.');
dot = stix_findoochar (ptr, len, '.');
if (dot)
{
if (pooldic_gotten) goto wrong_name;
@ -2281,7 +2281,7 @@ static int compile_class_level_variables (stix_t* stix)
{
/* pool dictionary import declaration
* #dcl(#pooldic) ... */
stix_ucs_t last;
stix_oocs_t last;
stix_oop_set_t ns_oop;
stix_oop_association_t ass;
stix_size_t i;
@ -2547,7 +2547,7 @@ static int compile_method_primitive (stix_t* stix)
* method-primitive := "<" "primitive:" integer ">"
*/
stix_ooi_t prim_no;
const stix_uch_t* ptr, * end;
const stix_ooch_t* ptr, * end;
if (!is_token_binary_selector(stix, VOCA_LT))
{
@ -2595,9 +2595,9 @@ static int compile_method_primitive (stix_t* stix)
prim_no = stix_getprimno (stix, &stix->c->tok.name);
if (prim_no <= -1)
{
const stix_uch_t* us;
const stix_ooch_t* us;
/* the primitive is not found */
us = stix_findchar (stix->c->tok.name.ptr, stix->c->tok.name.len, '_');
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;
@ -2642,7 +2642,7 @@ static int compile_method_primitive (stix_t* stix)
return 0;
}
static int get_variable_info (stix_t* stix, const stix_ucs_t* name, const stix_ioloc_t* name_loc, int name_dotted, var_info_t* var)
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;
@ -2656,17 +2656,17 @@ static int get_variable_info (stix_t* stix, const stix_ucs_t* name, const stix_i
* A.B.C - namespace or pool dictionary related reference.
*/
stix_ucs_t last;
stix_oocs_t last;
stix_oop_set_t ns_oop;
stix_oop_association_t ass;
const stix_uch_t* dot;
const stix_ooch_t* dot;
dot = stix_findchar (name->ptr, name->len, '.');
dot = stix_findoochar (name->ptr, name->len, '.');
STIX_ASSERT (dot != STIX_NULL);
if (dot - name->ptr == 4 && stix_equalchars(name->ptr, vocas[VOCA_SELF].str, 4))
{
/* the dotted name begins with self. */
dot = stix_findchar (dot + 1, name->len - 5, '.');
dot = stix_findoochar (dot + 1, name->len - 5, '.');
if (!dot)
{
/* the dotted name is composed of 2 segments only */
@ -2691,7 +2691,7 @@ static int get_variable_info (stix_t* stix, const stix_ucs_t* name, const stix_i
if (preprocess_dotted_name (stix, 1, 1, name, name_loc, &last, &ns_oop) <= -1) return -1;
printf ("checking variable ");
print_ucs (&last);
print_oocs (&last);
printf ("\n");
ass = stix_lookupdic (stix, ns_oop, &last);
if (ass)
@ -3333,7 +3333,7 @@ printf ("\tpush_literal array\n");
return 0;
}
static int compile_expression_primary (stix_t* stix, const stix_ucs_t* ident, const stix_ioloc_t* ident_loc, int ident_dotted, int* to_super)
static int compile_expression_primary (stix_t* stix, const stix_oocs_t* ident, const stix_ioloc_t* ident_loc, int ident_dotted, int* to_super)
{
/*
* expression-primary := identifier | literal | block-constructor | ( "(" method-expression ")" )
@ -3580,7 +3580,7 @@ static int compile_unary_message (stix_t* stix, int to_super)
if (add_symbol_literal(stix, &stix->c->tok.name, &index) <= -1 ||
emit_double_param_instruction(stix, send_message_cmd[to_super], 0, index) <= -1) return -1;
printf ("\tsend unary message %d [", (int)index);
print_ucs (&stix->c->tok.name);
print_oocs (&stix->c->tok.name);
printf ("] with 0 arguments %s\n", (to_super? " to super": ""));
GET_TOKEN (stix);
@ -3598,7 +3598,7 @@ static int compile_binary_message (stix_t* stix, int to_super)
*/
stix_size_t index;
int to_super2;
stix_ucs_t binsel;
stix_oocs_t binsel;
stix_size_t saved_binsels_len, binsel_offset;
STIX_ASSERT (stix->c->tok.type == STIX_IOTOK_BINSEL);
@ -3623,7 +3623,7 @@ static int compile_binary_message (stix_t* stix, int to_super)
if (add_symbol_literal(stix, &binsel, &index) <= -1 ||
emit_double_param_instruction(stix, send_message_cmd[to_super], 1, index) <= -1) goto oops;
printf ("\tsend binary message %d [", (int)index);
print_ucs (&binsel);
print_oocs (&binsel);
printf ("] with 1 arguments %s\n", (to_super? " to super": ""));
stix->c->mth.binsels.len = saved_binsels_len;
@ -3646,7 +3646,7 @@ static int compile_keyword_message (stix_t* stix, int to_super)
stix_size_t index;
int to_super2;
stix_ucs_t kw, kwsel;
stix_oocs_t kw, kwsel;
stix_ioloc_t saved_kwsel_loc;
stix_size_t saved_kwsel_len;
stix_size_t kw_offset;
@ -3688,7 +3688,7 @@ static int compile_keyword_message (stix_t* stix, int to_super)
emit_double_param_instruction(stix, send_message_cmd[to_super], nargs, index) <= -1) goto oops;
printf ("\tsend keyword message %d [", (int)index);
print_ucs (&kwsel);
print_oocs (&kwsel);
printf ("] with %d arguments to %s\n", (int)nargs, (to_super? "super": "self"));
stix->c->mth.kwsels.len = saved_kwsel_len;
return 0;
@ -3814,7 +3814,7 @@ done:
return 0;
}
static int compile_basic_expression (stix_t* stix, const stix_ucs_t* ident, const stix_ioloc_t* ident_loc, int ident_dotted)
static int compile_basic_expression (stix_t* stix, const stix_oocs_t* ident, const stix_ioloc_t* ident_loc, int ident_dotted)
{
/*
* basic-expression := expression-primary message-expression?
@ -3840,7 +3840,7 @@ static int compile_method_expression (stix_t* stix, int pop)
* method-assignment-expression := identifier ":=" method-expression
*/
stix_ucs_t assignee;
stix_oocs_t assignee;
stix_size_t index;
int ret = 0;
@ -3873,7 +3873,7 @@ static int compile_method_expression (stix_t* stix, int pop)
printf ("ASSIGNING TO ....");
assignee.ptr = &stix->c->mth.assignees.ptr[assignee_offset];
print_ucs (&assignee);
print_oocs (&assignee);
printf ("\n");
if (compile_method_expression(stix, 0) <= -1) goto oops;
@ -4296,7 +4296,7 @@ static int compile_method_definition (stix_t* stix)
if (compile_method_name(stix) <= -1) return -1;
printf (">>METHOD ");
print_ucs (&stix->c->mth.name);
print_oocs (&stix->c->mth.name);
printf ("\n");
if (stix->c->tok.type != STIX_IOTOK_LBRACE)
{
@ -4342,7 +4342,7 @@ static int make_defined_class (stix_t* stix)
#if 0
printf ("MAKING ... ");
print_ucs (&stix->c->cls.name);
print_oocs (&stix->c->cls.name);
printf (" instvars %d classvars %d classinstvars %d\n", (int)stix->c->cls.var_count[VAR_INSTANCE], (int)stix->c->cls.var_count[VAR_CLASS], (int)stix->c->cls.var_count[VAR_CLASSINST]);
#endif
if (stix->c->cls.self_oop)
@ -4552,7 +4552,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
int super_is_nil = 0;
printf ("DEFININING CLASS ");
print_ucs (&stix->c->cls.name);
print_oocs (&stix->c->cls.name);
printf ("\n");
if (stix->c->tok.type == STIX_IOTOK_LPAREN)
{
@ -4827,7 +4827,7 @@ static int __compile_pooldic_definition (stix_t* stix)
}
printf ("DEFININING POOL DICTIONARY ");
print_ucs (&stix->c->cls.name);
print_oocs (&stix->c->cls.name);
printf ("\n");
GET_TOKEN (stix);

10
stix/lib/debug.c
View File

@ -76,7 +76,7 @@ void dump_dictionary (stix_t* stix, stix_oop_set_t dic, const char* title)
printf ("--------------------------------------------\n");
}
void print_ucs (const stix_ucs_t* name)
void print_oocs (const stix_oocs_t* name)
{
stix_size_t i;
for (i = 0; i < name->len; i++) printf ("%c", name->ptr[i]);
@ -118,7 +118,7 @@ void print_object (stix_t* stix, stix_oop_t oop)
else
{
stix_oop_class_t c;
stix_ucs_t s;
stix_oocs_t s;
stix_size_t i;
stix_bch_t bcs[32];
stix_size_t ucslen, bcslen;
@ -177,7 +177,7 @@ void print_object (stix_t* stix, stix_oop_t oop)
s.ptr = ((stix_oop_char_t)c->name)->slot;
s.len = STIX_OBJ_GET_SIZE(c->name);
printf ("instance of ");
print_ucs (&s);
print_oocs (&s);
printf ("- (%p)", oop);
}
}
@ -186,7 +186,7 @@ void print_object (stix_t* stix, stix_oop_t oop)
static void __dump_object (stix_t* stix, stix_oop_t oop, int depth)
{
stix_oop_class_t c;
stix_ucs_t s;
stix_oocs_t s;
int i;
for (i = 0; i < depth; i++) printf ("\t");
@ -195,7 +195,7 @@ static void __dump_object (stix_t* stix, stix_oop_t oop, int depth)
c = (stix_oop_class_t)STIX_CLASSOF(stix, oop);
s.ptr = ((stix_oop_char_t)c->name)->slot;
s.len = STIX_OBJ_GET_SIZE(c->name);
print_ucs (&s);
print_oocs (&s);
if (oop == stix->_nil)
{

14
stix/lib/dic.c
View File

@ -52,7 +52,7 @@ static stix_oop_oop_t expand_bucket (stix_t* stix, stix_oop_oop_t oldbuc)
key = (stix_oop_char_t)ass->key;
STIX_ASSERT (STIX_CLASSOF(stix,key) == (stix_oop_t)stix->_symbol);
index = stix_hashuchars(key->slot, STIX_OBJ_GET_SIZE(key)) % newsz;
index = stix_hashchars(key->slot, STIX_OBJ_GET_SIZE(key)) % newsz;
while (newbuc->slot[index] != stix->_nil) index = (index + 1) % newsz;
newbuc->slot[index] = (stix_oop_t)ass;
}
@ -73,7 +73,7 @@ static stix_oop_association_t find_or_upsert (stix_t* stix, stix_oop_set_t dic,
STIX_ASSERT (STIX_CLASSOF(stix,dic->tally) == stix->_small_integer);
STIX_ASSERT (STIX_CLASSOF(stix,dic->bucket) == stix->_array);
index = stix_hashuchars(key->slot, STIX_OBJ_GET_SIZE(key)) % STIX_OBJ_GET_SIZE(dic->bucket);
index = stix_hashchars(key->slot, STIX_OBJ_GET_SIZE(key)) % STIX_OBJ_GET_SIZE(dic->bucket);
while (dic->bucket->slot[index] != stix->_nil)
{
@ -124,7 +124,7 @@ static stix_oop_association_t find_or_upsert (stix_t* stix, stix_oop_set_t dic,
dic->bucket = bucket;
/* recalculate the index for the expanded bucket */
index = stix_hashuchars(key->slot, STIX_OBJ_GET_SIZE(key)) % STIX_OBJ_GET_SIZE(dic->bucket);
index = stix_hashchars(key->slot, STIX_OBJ_GET_SIZE(key)) % STIX_OBJ_GET_SIZE(dic->bucket);
while (dic->bucket->slot[index] != stix->_nil)
index = (index + 1) % STIX_OBJ_GET_SIZE(dic->bucket);
@ -150,7 +150,7 @@ oops:
return STIX_NULL;
}
static stix_oop_association_t lookup (stix_t* stix, stix_oop_set_t dic, const stix_ucs_t* name)
static stix_oop_association_t lookup (stix_t* stix, stix_oop_set_t dic, const stix_oocs_t* name)
{
/* this is special version of stix_getatsysdic() that performs
* lookup using a plain string specified */
@ -161,7 +161,7 @@ static stix_oop_association_t lookup (stix_t* stix, stix_oop_set_t dic, const st
STIX_ASSERT (STIX_CLASSOF(stix,dic->tally) == stix->_small_integer);
STIX_ASSERT (STIX_CLASSOF(stix,dic->bucket) == stix->_array);
index = stix_hashuchars(name->ptr, name->len) % STIX_OBJ_GET_SIZE(dic->bucket);
index = stix_hashchars(name->ptr, name->len) % STIX_OBJ_GET_SIZE(dic->bucket);
while (dic->bucket->slot[index] != stix->_nil)
{
@ -196,7 +196,7 @@ stix_oop_association_t stix_getatsysdic (stix_t* stix, stix_oop_t key)
return find_or_upsert (stix, stix->sysdic, (stix_oop_char_t)key, STIX_NULL);
}
stix_oop_association_t stix_lookupsysdic (stix_t* stix, const stix_ucs_t* name)
stix_oop_association_t stix_lookupsysdic (stix_t* stix, const stix_oocs_t* name)
{
return lookup (stix, stix->sysdic, name);
}
@ -213,7 +213,7 @@ stix_oop_association_t stix_getatdic (stix_t* stix, stix_oop_set_t dic, stix_oop
return find_or_upsert (stix, dic, (stix_oop_char_t)key, STIX_NULL);
}
stix_oop_association_t stix_lookupdic (stix_t* stix, stix_oop_set_t dic, const stix_ucs_t* name)
stix_oop_association_t stix_lookupdic (stix_t* stix, stix_oop_set_t dic, const stix_oocs_t* name)
{
return lookup (stix, dic, name);
}

28
stix/lib/exec.c
View File

@ -350,7 +350,7 @@ printf ("\n");
#endif
}
static stix_oop_method_t find_method (stix_t* stix, stix_oop_t receiver, const stix_ucs_t* message, int super)
static stix_oop_method_t find_method (stix_t* stix, stix_oop_t receiver, const stix_oocs_t* message, int super)
{
stix_oop_class_t cls;
stix_oop_association_t ass;
@ -361,7 +361,7 @@ static stix_oop_method_t find_method (stix_t* stix, stix_oop_t receiver, const s
#if defined(STIX_DEBUG_EXEC)
printf ("==== FINDING METHOD FOR %p [", receiver);
print_ucs (message);
print_oocs (message);
printf ("] in ");
#endif
@ -420,7 +420,7 @@ not_found:
return STIX_NULL;
}
static int activate_initial_context (stix_t* stix, const stix_ucs_t* objname, const stix_ucs_t* mthname)
static int activate_initial_context (stix_t* stix, const stix_oocs_t* objname, const stix_oocs_t* mthname)
{
/* the initial context is a fake context. if objname is 'Stix' and
* mthname is 'main', this function emulates message sending 'Stix main'.
@ -1561,7 +1561,7 @@ static prim_t primitives[] =
};
int stix_getprimno (stix_t* stix, const stix_ucs_t* name)
int stix_getprimno (stix_t* stix, const stix_oocs_t* name)
{
int i;
@ -1577,16 +1577,16 @@ int stix_getprimno (stix_t* stix, const stix_ucs_t* name)
return -1;
}
static stix_prim_impl_t query_prim_module (stix_t* stix, const stix_uch_t* name, stix_oow_t len)
static stix_prim_impl_t query_prim_module (stix_t* stix, const stix_ooch_t* name, stix_oow_t len)
{
stix_rbt_pair_t* pair;
stix_prim_mod_data_t* mdp;
const stix_uch_t* sep;
const stix_ooch_t* sep;
stix_oow_t mod_name_len;
stix_prim_impl_t handler;
int n;
sep = stix_findchar (name, len, '_');
sep = stix_findoochar (name, len, '_');
STIX_ASSERT (sep != STIX_NULL);
mod_name_len = sep - name;
@ -1606,10 +1606,10 @@ static stix_prim_impl_t query_prim_module (stix_t* stix, const stix_uch_t* name,
* 1 for _ at the end when stix_prim_mod_xxx_ is attempted.
* 1 for the terminating '\0'.
*/
stix_uch_t buf[STIX_MOD_NAME_LEN_MAX + 16];
stix_ooch_t buf[STIX_MOD_NAME_LEN_MAX + 16];
/* the terminating null isn't needed in buf here */
stix_copybchtouchars (buf, "stix_prim_mod_", 14);
stix_copybchtooochars (buf, "stix_prim_mod_", 14);
if (mod_name_len > STIX_COUNTOF(buf) - 16)
{
@ -1618,7 +1618,7 @@ static stix_prim_impl_t query_prim_module (stix_t* stix, const stix_uch_t* name,
return STIX_NULL;
}
stix_copyuchars (&buf[14], name, mod_name_len);
stix_copyoochars (&buf[14], name, mod_name_len);
buf[14 + mod_name_len] = '\0';
#if defined(STIX_ENABLE_STATIC_MODULE)
@ -1629,7 +1629,7 @@ static stix_prim_impl_t query_prim_module (stix_t* stix, const stix_uch_t* name,
/* TODO: binary search ... */
for (n = 0; n < STIX_COUNTOF(static_modtab); n++)
{
if (stix_compucstr (static_modtab[n].modname, name) == 0)
if (stix_compoocstr (static_modtab[n].modname, name) == 0)
{
load = static_modtab[n].modload;
break;
@ -2209,7 +2209,7 @@ printf ("\n");
/* b1 -> number of arguments
* b2 -> index to the selector stored in the literal frame
*/
stix_ucs_t mthname;
stix_oocs_t mthname;
stix_oop_t newrcv;
stix_oop_method_t newmth;
stix_oop_char_t selector;
@ -2244,7 +2244,7 @@ printf ("\n");
{
/* TODO: implement doesNotUnderstand: XXXXX instead of returning -1. */
printf ("no such method .........[");
print_ucs (&mthname);
print_oocs (&mthname);
printf ("]\n");
goto oops;
}
@ -2744,7 +2744,7 @@ oops:
return -1;
}
int stix_invoke (stix_t* stix, const stix_ucs_t* objname, const stix_ucs_t* mthname)
int stix_invoke (stix_t* stix, const stix_oocs_t* objname, const stix_oocs_t* mthname)
{
if (activate_initial_context (stix, objname, mthname) <= -1) return -1;
return stix_execute (stix);

3
stix/lib/gc.c
View File

@ -64,7 +64,7 @@ static void compact_symbol_table (stix_t* stix, stix_oop_t _nil)
STIX_ASSERT (STIX_CLASSOF(stix,symbol) == stix->_symbol);
z = stix_hashuchars(symbol->slot, STIX_OBJ_GET_SIZE(symbol)) % bucket_size;
z = stix_hashchars(symbol->slot, STIX_OBJ_GET_SIZE(symbol)) % bucket_size;
/* move an element if necessary */
if ((y > x && (z <= x || z > y)) ||
@ -290,6 +290,7 @@ void stix_gc (stix_t* stix)
stix->_false_class = stix_moveoop (stix, stix->_false_class);
stix->_character = stix_moveoop (stix, stix->_character);
stix->_small_integer = stix_moveoop (stix, stix->_small_integer);
stix->_large_integer = stix_moveoop (stix, stix->_large_integer);
stix->sysdic = (stix_oop_set_t) stix_moveoop (stix, (stix_oop_t)stix->sysdic);
stix->processor = (stix_oop_process_scheduler_t) stix_moveoop (stix, (stix_oop_t)stix->processor);

12
stix/lib/ignite.c
View File

@ -143,6 +143,7 @@ static int ignite_1 (stix_t* stix)
* Does this make sense? */
stix->_character = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_small_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP));
stix->_large_integer = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_OOP));
if (!stix->_apex || !stix->_undefined_object ||
!stix->_object || !stix->_string ||
@ -157,7 +158,7 @@ static int ignite_1 (stix_t* stix)
!stix->_process || !stix->_process_scheduler ||
!stix->_true_class || !stix->_false_class ||
!stix->_character || !stix->_small_integer) return -1;
!stix->_character || !stix->_small_integer || !stix->_large_integer) return -1;
STIX_OBJ_SET_CLASS (stix->_nil, stix->_undefined_object);
return 0;
@ -212,7 +213,7 @@ static int ignite_3 (stix_t* stix)
static struct symbol_name_t
{
stix_oow_t len;
stix_uch_t str[16];
stix_ooch_t str[16];
} symnames[] = {
{ 4, { 'A','p','e','x' } },
{ 15, { 'U','n','d','e','f','i','n','e','d','O','b','j','e','c','t' } },
@ -239,11 +240,12 @@ static int ignite_3 (stix_t* stix)
{ 4, { 'T','r','u','e' } },
{ 5, { 'F','a','l','s','e' } },
{ 9, { 'C','h','a','r','a','c','t','e','r' } },
{ 12, { 'S','m','a','l','l','I','n','t','e','g','e','r' } }
{ 12, { 'S','m','a','l','l','I','n','t','e','g','e','r' } },
{ 12, { 'L','a','r','g','e','I','n','t','e','g','e','r' } }
};
static stix_uch_t str_stix[] = { 'S','t','i','x' };
static stix_uch_t str_processor[] = { 'P', 'r', 'o', 'c', 'e', 's', 's', 'o', 'r' };
static stix_ooch_t str_stix[] = { 'S','t','i','x' };
static stix_ooch_t str_processor[] = { 'P', 'r', 'o', 'c', 'e', 's', 's', 'o', 'r' };
stix_oow_t i;
stix_oop_t sym;

18
stix/lib/main.c
View File

@ -213,7 +213,7 @@ static stix_ssize_t input_handler (stix_t* stix, stix_io_cmd_t cmd, stix_io_arg_
}
}
static void* mod_open (stix_t* stix, const stix_uch_t* name)
static void* mod_open (stix_t* stix, const stix_ooch_t* name)
{
#if defined(USE_LTDL)
/* TODO: support various platforms */
@ -274,7 +274,7 @@ static void mod_close (stix_t* stix, void* handle)
#endif
}
static void* mod_getsym (stix_t* stix, void* handle, const stix_uch_t* name)
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 */
@ -369,16 +369,16 @@ static char* syntax_error_msg[] =
"literal expected"
};
stix_uch_t str_stix[] = { 'S', 't', 'i', 'x' };
stix_uch_t str_my_object[] = { 'M', 'y', 'O', 'b','j','e','c','t' };
stix_uch_t str_main[] = { 'm', 'a', 'i', 'n' };
stix_ooch_t str_stix[] = { 'S', 't', 'i', 'x' };
stix_ooch_t str_my_object[] = { 'M', 'y', 'O', 'b','j','e','c','t' };
stix_ooch_t str_main[] = { 'm', 'a', 'i', 'n' };
int main (int argc, char* argv[])
{
stix_t* stix;
xtn_t* xtn;
stix_ucs_t objname;
stix_ucs_t mthname;
stix_oocs_t objname;
stix_oocs_t mthname;
stix_vmprim_t vmprim;
int i;
@ -457,8 +457,8 @@ int main (int argc, char* argv[])
}
{
stix_uch_t x[] = { 'X', 't', 'r', 'i', 'n', 'g', '\0' };
stix_uch_t y[] = { 'S', 'y', 'm', 'b', 'o', 'l', '\0' };
stix_ooch_t x[] = { 'X', 't', 'r', 'i', 'n', 'g', '\0' };
stix_ooch_t y[] = { 'S', 'y', 'm', 'b', 'o', 'l', '\0' };
stix_oop_t a, b, k;
a = stix_makesymbol (stix, x, 6);

8
stix/lib/obj.c
View File

@ -150,16 +150,16 @@ static stix_oop_t alloc_numeric_array (stix_t* stix, const void* ptr, stix_oow_t
return hdr;
}
stix_oop_t stix_alloccharobj (stix_t* stix, const stix_uch_t* ptr, stix_oow_t len)
stix_oop_t stix_alloccharobj (stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len)
{
return alloc_numeric_array (stix, ptr, len, STIX_OBJ_TYPE_CHAR, STIX_SIZEOF(stix_uch_t), 1);
return alloc_numeric_array (stix, ptr, len, STIX_OBJ_TYPE_CHAR, STIX_SIZEOF(stix_ooch_t), 1);
}
/*
TODO: extra bits must be set ...
stix_oop_t stix_allocmbcharobj (stix_t* stix, const stix_uch_t* ptr, stix_oow_t len)
stix_oop_t stix_allocmbcharobj (stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len)
{
return alloc_numeric_array (stix, ptr, len, STIX_OBJ_TYPE_MBCHAR, STIX_SIZEOF(stix_uch_t), 1);
return alloc_numeric_array (stix, ptr, len, STIX_OBJ_TYPE_MBCHAR, STIX_SIZEOF(stix_ooch_t), 1);
}
*/

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

@ -33,42 +33,204 @@
#if defined(STIX_HAVE_CFG_H)
# include "stix-cfg.h"
#else
# error UNSUPPORTED SYSTEM
#endif
#if defined(EMSCRIPTEN)
# if defined(STIX_SIZEOF___INT128)
# undef STIX_SIZEOF___INT128
# define STIX_SIZEOF___INT128 0
# endif
# if defined(STIX_SIZEOF_LONG) && defined(STIX_SIZEOF_INT) && (STIX_SIZEOF_LONG > STIX_SIZEOF_INT)
/* autoconf doesn't seem to match actual emscripten */
# undef STIX_SIZEOF_LONG
# define STIX_SIZEOF_LONG STIX_SIZEOF_INT
# endif
#endif
/* =========================================================================
* PRIMITIVE TYPE DEFINTIONS
* ========================================================================= */
/* TODO: define these types and macros using autoconf */
typedef unsigned char stix_uint8_t;
typedef signed char stix_int8_t;
#if defined(STIX_SIZEOF_CHAR) && (STIX_SIZEOF_CHAR == 1)
# define STIX_HAVE_UINT8_T
# define STIX_HAVE_INT8_T
typedef unsigned char stix_uint8_t;
typedef signed char stix_int8_t;
#elif defined(STIX_SIZEOF___INT8) && (STIX_SIZEOF___INT8 == 1)
# define STIX_HAVE_UINT8_T
# define STIX_HAVE_INT8_T
typedef unsigned __int8 stix_uint8_t;
typedef signed __int8 stix_int8_t;
#elif defined(STIX_SIZEOF___INT8_T) && (STIX_SIZEOF___INT8_T == 1)
# define STIX_HAVE_UINT8_T
# define STIX_HAVE_INT8_T
typedef unsigned __int8_t stix_uint8_t;
typedef signed __int8_t stix_int8_t;
#else
# define STIX_HAVE_UINT8_T
# define STIX_HAVE_INT8_T
typedef unsigned char stix_uint8_t;
typedef signed char stix_int8_t;
#endif
typedef unsigned short int stix_uint16_t;
typedef signed short int stix_int16_t;
#if defined(STIX_SIZEOF_SHORT) && (STIX_SIZEOF_SHORT == 2)
# define STIX_HAVE_UINT16_T
# define STIX_HAVE_INT16_T
typedef unsigned short int stix_uint16_t;
typedef signed short int stix_int16_t;
#elif defined(STIX_SIZEOF___INT16) && (STIX_SIZEOF___INT16 == 2)
# define STIX_HAVE_UINT16_T
# define STIX_HAVE_INT16_T
typedef unsigned __int16 stix_uint16_t;
typedef signed __int16 stix_int16_t;
#elif defined(STIX_SIZEOF___INT16_T) && (STIX_SIZEOF___INT16_T == 2)
# define STIX_HAVE_UINT16_T
# define STIX_HAVE_INT16_T
typedef unsigned __int16_t stix_uint16_t;
typedef signed __int16_t stix_int16_t;
#else
# define STIX_HAVE_UINT16_T
# define STIX_HAVE_INT16_T
typedef unsigned short int stix_uint16_t;
typedef signed short int stix_int16_t;
#endif
#if defined(__MSDOS__)
#if defined(STIX_SIZEOF_INT) && (STIX_SIZEOF_INT == 4)
# define STIX_HAVE_UINT32_T
# define STIX_HAVE_INT32_T
typedef unsigned int stix_uint32_t;
typedef signed int stix_int32_t;
#elif defined(STIX_SIZEOF_LONG) && (STIX_SIZEOF_LONG == 4)
# define STIX_HAVE_UINT32_T
# define STIX_HAVE_INT32_T
typedef unsigned long stix_uint32_t;
typedef signed long stix_int32_t;
#elif defined(STIX_SIZEOF___INT32) && (STIX_SIZEOF___INT32 == 4)
# define STIX_HAVE_UINT32_T
# define STIX_HAVE_INT32_T
typedef unsigned __int32 stix_uint32_t;
typedef signed __int32 stix_int32_t;
#elif defined(STIX_SIZEOF___INT32_T) && (STIX_SIZEOF___INT32_T == 4)
# define STIX_HAVE_UINT32_T
# define STIX_HAVE_INT32_T
typedef unsigned __int32_t stix_uint32_t;
typedef signed __int32_t stix_int32_t;
#elif defined(__MSDOS__)
# define STIX_HAVE_UINT32_T
# define STIX_HAVE_INT32_T
typedef unsigned long int stix_uint32_t;
typedef signed long int stix_int32_t;
#else
# define STIX_HAVE_UINT32_T
# define STIX_HAVE_INT32_T
typedef unsigned int stix_uint32_t;
typedef signed int stix_int32_t;
#endif
#if defined(_WIN64)
typedef unsigned __int64 stix_uintptr_t;
typedef signed __int64 stix_intptr_t;
typedef unsigned __int64 stix_size_t;
typedef signed __int64 stix_ssize_t;
#if defined(STIX_SIZEOF_INT) && (STIX_SIZEOF_INT == 8)
# define STIX_HAVE_UINT64_T
# define STIX_HAVE_INT64_T
typedef unsigned int stix_uint64_t;
typedef signed int stix_int64_t;
#elif defined(STIX_SIZEOF_LONG) && (STIX_SIZEOF_LONG == 8)
# define STIX_HAVE_UINT64_T
# define STIX_HAVE_INT64_T
typedef unsigned long stix_uint64_t;
typedef signed long stix_int64_t;
#elif defined(STIX_SIZEOF_LONG_LONG) && (STIX_SIZEOF_LONG_LONG == 8)
# define STIX_HAVE_UINT64_T
# define STIX_HAVE_INT64_T
typedef unsigned long long stix_uint64_t;
typedef signed long long stix_int64_t;
#elif defined(STIX_SIZEOF___INT64) && (STIX_SIZEOF___INT64 == 8)
# define STIX_HAVE_UINT64_T
# define STIX_HAVE_INT64_T
typedef unsigned __int64 stix_uint64_t;
typedef signed __int64 stix_int64_t;
#elif defined(STIX_SIZEOF___INT64_T) && (STIX_SIZEOF___INT64_T == 8)
# define STIX_HAVE_UINT64_T
# define STIX_HAVE_INT64_T
typedef unsigned __int64_t stix_uint64_t;
typedef signed __int64_t stix_int64_t;
#elif defined(_WIN64) || defined(_WIN32)
# define STIX_HAVE_UINT64_T
# define STIX_HAVE_INT64_T
typedef unsigned __int64 stix_uint64_t;
typedef signed __int64 stix_int64_t;
#else
typedef unsigned long int stix_uintptr_t;
typedef signed long int stix_intptr_t;
typedef unsigned long int stix_size_t;
typedef signed long int stix_ssize_t;
/* no 64-bit integer */
#endif
#if defined(STIX_SIZEOF_INT) && (STIX_SIZEOF_INT == 16)
# define STIX_HAVE_UINT128_T
# define STIX_HAVE_INT128_T
typedef unsigned int stix_uint128_t;
typedef signed int stix_int128_t;
#elif defined(STIX_SIZEOF_LONG) && (STIX_SIZEOF_LONG == 16)
# define STIX_HAVE_UINT128_T
# define STIX_HAVE_INT128_T
typedef unsigned long stix_uint128_t;
typedef signed long stix_int128_t;
#elif defined(STIX_SIZEOF_LONG_LONG) && (STIX_SIZEOF_LONG_LONG == 16)
# define STIX_HAVE_UINT128_T
# define STIX_HAVE_INT128_T
typedef unsigned long long stix_uint128_t;
typedef signed long long stix_int128_t;
#elif defined(STIX_SIZEOF___INT128) && (STIX_SIZEOF___INT128 == 16)
# define STIX_HAVE_UINT128_T
# define STIX_HAVE_INT128_T
typedef unsigned __int128 stix_uint128_t;
typedef signed __int128 stix_int128_t;
#elif defined(STIX_SIZEOF___INT128_T) && (STIX_SIZEOF___INT128_T == 16)
# define STIX_HAVE_UINT128_T
# define STIX_HAVE_INT128_T
typedef unsigned __int128_t stix_uint128_t;
typedef signed __int128_t stix_int128_t;
#else
/* no 128-bit integer */
#endif
#if defined(STIX_HAVE_UINT8_T) && (STIX_SIZEOF_VOID_P == 1)
# error UNSUPPORTED POINTER SIZE
#elif defined(STIX_HAVE_UINT16_T) && (STIX_SIZEOF_VOID_P == 2)
typedef stix_uint16_t stix_uintptr_t;
typedef stix_int16_t stix_intptr_t;
typedef stix_uint8_t stix_ushortptr_t;
typedef stix_int8_t stix_shortptr_t;
#elif defined(STIX_HAVE_UINT32_T) && (STIX_SIZEOF_VOID_P == 4)
typedef stix_uint32_t stix_uintptr_t;
typedef stix_int32_t stix_intptr_t;
typedef stix_uint16_t stix_ushortptr_t;
typedef stix_int16_t stix_shortptr_t;
#elif defined(STIX_HAVE_UINT64_T) && (STIX_SIZEOF_VOID_P == 8)
typedef stix_uint64_t stix_uintptr_t;
typedef stix_int64_t stix_intptr_t;
typedef stix_uint32_t stix_ushortptr_t;
typedef stix_int32_t stix_shortptr_t;
#elif defined(STIX_HAVE_UINT128_T) && (STIX_SIZEOF_VOID_P == 16)
typedef stix_uint128_t stix_uintptr_t;
typedef stix_int128_t stix_intptr_t;
typedef stix_uint64_t stix_ushortptr_t;
typedef stix_int64_t stix_shortptr_t;
#else
# error UNSUPPORTED POINTER SIZE
#endif
#define STIX_SIZEOF_INTPTR_T STIX_SIZEOF_VOID_P
#define STIX_SIZEOF_UINTPTR_T STIX_SIZEOF_VOID_P
#define STIX_SIZEOF_SHORTPTR_T (STIX_SIZEOF_VOID_P / 2)
#define STIX_SIZEOF_USHORTPTR_T (STIX_SIZEOF_VOID_P / 2)
typedef stix_uintptr_t stix_size_t;
typedef stix_intptr_t stix_ssize_t;
typedef stix_uint8_t stix_byte_t;
typedef char stix_bch_t;
typedef stix_uint16_t stix_uch_t; /* TODO ... wchar_t??? */
typedef stix_int32_t stix_uci_t;
typedef char stix_bch_t;
struct stix_ucs_t
{
@ -78,12 +240,11 @@ struct stix_ucs_t
typedef struct stix_ucs_t stix_ucs_t;
/* =========================================================================
* PRIMITIVE MACROS
* ========================================================================= */
#define STIX_UCI_EOF ((stix_uci_t)-1)
#define STIX_UCI_NL ((stix_uci_t)'\n')
#define STIX_UCI_EOF ((stix_ooci_t)-1)
#define STIX_UCI_NL ((stix_ooci_t)'\n')
#define STIX_SIZEOF(x) (sizeof(x))
#define STIX_COUNTOF(x) (sizeof(x) / sizeof(x[0]))

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

@ -175,13 +175,13 @@ struct stix_ioloc_t
{
unsigned long line; /**< line */
unsigned long colm; /**< column */
const stix_uch_t* file; /**< file specified in #include */
const stix_ooch_t* file; /**< file specified in #include */
};
typedef struct stix_ioloc_t stix_ioloc_t;
struct stix_iolxc_t
{
stix_uci_t c; /**< character */
stix_ooci_t c; /**< character */
stix_ioloc_t l; /**< location */
};
typedef struct stix_iolxc_t stix_iolxc_t;
@ -201,7 +201,7 @@ struct stix_io_arg_t
* It is #STIX_NULL for the main stream and points to a non-NULL string
* for an included stream.
*/
const stix_uch_t* name;
const stix_ooch_t* name;
/**
* [OUT] I/O handle set by a handler.
@ -214,7 +214,7 @@ struct stix_io_arg_t
/**
* [OUT] place data here
*/
stix_uch_t buf[1024];
stix_ooch_t buf[1024];
/**
* [IN] points to the data of the includer. It is #STIX_NULL for the
@ -278,7 +278,7 @@ struct stix_iotok_t
STIX_IOTOK_SEMICOLON
} type;
stix_ucs_t name;
stix_oocs_t name;
stix_size_t name_capa;
stix_ioloc_t loc;
@ -352,7 +352,7 @@ struct stix_synerr_t
{
stix_synerrnum_t num;
stix_ioloc_t loc;
stix_ucs_t tgt;
stix_oocs_t tgt;
};
typedef struct stix_synerr_t stix_synerr_t;
@ -394,8 +394,8 @@ struct stix_compiler_t
stix_synerr_t synerr;
/* temporary space to handle an illegal character */
stix_uch_t ilchr;
stix_ucs_t ilchr_ucs;
stix_ooch_t ilchr;
stix_oocs_t ilchr_ucs;
/* information about a class being compiled */
struct
@ -408,19 +408,19 @@ struct stix_compiler_t
stix_oop_set_t mthdic_oop[2];
stix_oop_set_t ns_oop;
stix_ucs_t fqn;
stix_ucs_t name;
stix_oocs_t fqn;
stix_oocs_t name;
stix_size_t fqn_capa;
stix_ioloc_t fqn_loc;
stix_oop_set_t superns_oop;
stix_ucs_t superfqn;
stix_ucs_t supername;
stix_oocs_t superfqn;
stix_oocs_t supername;
stix_size_t superfqn_capa;
stix_ioloc_t superfqn_loc;
/* instance variable, class variable, class instance variable */
stix_ucs_t vars[3];
stix_oocs_t vars[3];
stix_size_t vars_capa[3];
/* var_count, unlike vars above, includes superclass counts as well.
@ -429,7 +429,7 @@ struct stix_compiler_t
* var_count[2] - number of class instance variables */
stix_size_t var_count[3];
stix_ucs_t pooldic;
stix_oocs_t pooldic;
stix_size_t pooldic_capa;
stix_size_t pooldic_count;
@ -443,28 +443,28 @@ struct stix_compiler_t
int type;
/* method source text */
stix_ucs_t text;
stix_oocs_t text;
stix_size_t text_capa;
/* buffer to store identifier names to be assigned */
stix_ucs_t assignees;
stix_oocs_t assignees;
stix_size_t assignees_capa;
/* buffer to store binary selectors being worked on */
stix_ucs_t binsels;
stix_oocs_t binsels;
stix_size_t binsels_capa;
/* buffer to store keyword selectors being worked on */
stix_ucs_t kwsels;
stix_oocs_t kwsels;
stix_size_t kwsels_capa;
/* method name */
stix_ucs_t name;
stix_oocs_t name;
stix_size_t name_capa;
stix_ioloc_t name_loc;
/* single string containing a space separated list of temporaries */
stix_ucs_t tmprs;
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;
@ -808,6 +808,24 @@ enum stix_bcode_t
extern "C" {
#endif
#if defined(STIX_OOCH_IS_UCH)
# define stix_hashchars(ptr,len) stix_hashuchars(ptr,len)
# define stix_compoocbcstr(str1,str2) stix_compucbcstr(str1,str2)
# define stix_compoocstr(str1,str2) stix_compucstr(str1,str2)
# define stix_copyoochars(dst,src,len) stix_copyuchars(dst,src,len)
# define stix_copybchtooochars(dst,src,len) stix_copybchtouchars(dst,src,len)
# define stix_copyoocstr(dst,len,src) stix_copyucstr(dst,len,src)
# define stix_findoochar(ptr,len,c) stix_finduchar(ptr,len,c)
#else
# define stix_hashchars(ptr,len) stix_hashbchars(ptr,len)
# define stix_compoocbcstr(str1,str2) stix_compbcstr(str1,str2)
# define stix_compoocstr(str1,str2) stix_compbcstr(str1,str2)
# define stix_copyoochars(dst,src,len) stix_copybchars(dst,src,len)
# define stix_copybchtooochars(dst,src,len) stix_copybchars(dst,src,len)
# define stix_copyoocstr(dst,len,src) stix_copybcstr(dst,len,src)
# define stix_findoochar(ptr,len,c) stix_findbchar(ptr,len,c)
#endif
/* ========================================================================= */
/* heap.c */
/* ========================================================================= */
@ -843,22 +861,6 @@ void* stix_allocheapmem (
);
/* ========================================================================= */
/* stix.c */
/* ========================================================================= */
stix_size_t stix_hashbytes (
const stix_byte_t* ptr,
stix_size_t len
);
stix_size_t stix_hashuchars (
const stix_uch_t* ptr,
stix_size_t len
);
#define stix_hashbchars(ptr,len) stix_hashbytes(ptr,len)
/* ========================================================================= */
/* gc.c */
/* ========================================================================= */
@ -895,7 +897,7 @@ stix_oop_t stix_allocoopobjwithtrailer (
stix_oop_t stix_alloccharobj (
stix_t* stix,
const stix_uch_t* ptr,
const stix_ooch_t* ptr,
stix_oow_t len
);
@ -926,19 +928,19 @@ stix_oop_t stix_instantiatewithtrailer (
/* ========================================================================= */
stix_oop_t stix_makesymbol (
stix_t* stix,
const stix_uch_t* ptr,
const stix_ooch_t* ptr,
stix_oow_t len
);
stix_oop_t stix_findsymbol (
stix_t* stix,
const stix_uch_t* ptr,
const stix_ooch_t* ptr,
stix_oow_t len
);
stix_oop_t stix_makestring (
stix_t* stix,
const stix_uch_t* ptr,
const stix_ooch_t* ptr,
stix_oow_t len
);
@ -958,7 +960,7 @@ stix_oop_association_t stix_getatsysdic (
stix_oop_association_t stix_lookupsysdic (
stix_t* stix,
const stix_ucs_t* name
const stix_oocs_t* name
);
stix_oop_association_t stix_putatdic (
@ -977,7 +979,7 @@ stix_oop_association_t stix_getatdic (
stix_oop_association_t stix_lookupdic (
stix_t* stix,
stix_oop_set_t dic,
const stix_ucs_t* name
const stix_oocs_t* name
);
stix_oop_set_t stix_makedic (
@ -1068,7 +1070,7 @@ void stix_getsynerr (
/* ========================================================================= */
int stix_getprimno (
stix_t* stix,
const stix_ucs_t* name
const stix_oocs_t* name
);
/* TODO: remove debugging functions */
@ -1077,7 +1079,7 @@ int stix_getprimno (
/* ========================================================================= */
void dump_symbol_table (stix_t* stix);
void dump_dictionary (stix_t* stix, stix_oop_set_t dic, const char* title);
void print_ucs (const stix_ucs_t* name);
void print_oocs (const stix_oocs_t* name);
void print_object (stix_t* stix, stix_oop_t oop);
void dump_object (stix_t* stix, stix_oop_t oop, const char* title);

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

@ -27,6 +27,22 @@
#include "stix-utl.h"
stix_size_t stix_hashbytes (const stix_byte_t* ptr, stix_size_t len)
{
stix_size_t h = 0;
const stix_uint8_t* bp, * be;
bp = ptr; be = bp + len;
while (bp < be) h = h * 31 + *bp++;
return h;
}
stix_size_t stix_hashuchars (const stix_uch_t* ptr, stix_size_t len)
{
return stix_hashbytes ((const stix_byte_t *)ptr, len * STIX_SIZEOF(*ptr));
}
int stix_equalchars (const stix_uch_t* str1, const stix_uch_t* str2, stix_size_t len)
{
stix_size_t i;
@ -87,6 +103,12 @@ void stix_copyuchars (stix_uch_t* dst, const stix_uch_t* src, stix_size_t len)
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)
{
stix_size_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)
{
stix_size_t i;
@ -125,7 +147,7 @@ stix_size_t stix_copybcstr (stix_bch_t* dst, stix_size_t len, const stix_bch_t*
return p - dst;
}
stix_uch_t* stix_findchar (const stix_uch_t* ptr, stix_size_t len, stix_uch_t c)
stix_uch_t* stix_finduchar (const stix_uch_t* ptr, stix_size_t len, stix_uch_t c)
{
const stix_uch_t* end;
@ -139,3 +161,17 @@ stix_uch_t* stix_findchar (const stix_uch_t* ptr, stix_size_t len, stix_uch_t c)
return STIX_NULL;
}
stix_uch_t* stix_findbchar (const stix_bch_t* ptr, stix_size_t len, stix_bch_t c)
{
const stix_bch_t* end;
end = ptr + len;
while (ptr < end)
{
if (*ptr == c) return (stix_bch_t*)ptr;
ptr++;
}
return STIX_NULL;
}

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

@ -37,6 +37,19 @@ extern "C" {
/* ========================================================================= */
/* stix-utl.c */
/* ========================================================================= */
stix_size_t stix_hashbytes (
const stix_byte_t* ptr,
stix_size_t len
);
stix_size_t stix_hashuchars (
const stix_uch_t* ptr,
stix_size_t len
);
#define stix_hashbchars(ptr,len) stix_hashbytes(ptr,len)
int stix_equalchars (
const stix_uch_t* str1,
const stix_uch_t* str2,
@ -70,18 +83,30 @@ void stix_copyuchars (
stix_size_t len
);
void stix_copybchars (
stix_bch_t* dst,
const stix_bch_t* src,
stix_size_t len
);
void stix_copybchtouchars (
stix_uch_t* dst,
const stix_bch_t* src,
stix_size_t len
);
stix_uch_t* stix_findchar (
stix_uch_t* stix_finduchar (
const stix_uch_t* ptr,
stix_size_t len,
stix_uch_t c
);
stix_uch_t* stix_findbchar (
const stix_bch_t* ptr,
stix_size_t len,
stix_bch_t c
);
stix_size_t stix_copyucstr (
stix_uch_t* dst,
stix_size_t len,

16
stix/lib/stix.c
View File

@ -69,7 +69,7 @@ int stix_init (stix_t* stix, stix_mmgr_t* mmgr, stix_size_t heapsz, const stix_v
stix->newheap = stix_makeheap (stix, heapsz);
if (!stix->newheap) goto oops;
if (stix_rbt_init (&stix->pmtable, mmgr, STIX_SIZEOF(stix_uch_t), 1) <= -1) goto oops;
if (stix_rbt_init (&stix->pmtable, mmgr, STIX_SIZEOF(stix_ooch_t), 1) <= -1) goto oops;
stix_rbt_setstyle (&stix->pmtable, stix_getrbtstyle(STIX_RBT_STYLE_INLINE_COPIERS));
return 0;
@ -215,21 +215,7 @@ void stix_deregcb (stix_t* stix, stix_cb_t* cb)
stix_freemem (stix, cb);
}
stix_size_t stix_hashbytes (const stix_byte_t* ptr, stix_size_t len)
{
stix_size_t h = 0;
const stix_uint8_t* bp, * be;
bp = ptr; be = bp + len;
while (bp < be) h = h * 31 + *bp++;
return h;
}
stix_size_t stix_hashuchars (const stix_uch_t* ptr, stix_size_t len)
{
return stix_hashbytes ((const stix_byte_t *)ptr, len * STIX_SIZEOF(*ptr));
}
void* stix_allocmem (stix_t* stix, stix_size_t size)

15
stix/lib/stix.h
View File

@ -78,9 +78,16 @@ typedef enum stix_trait_t stix_trait_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;
typedef stix_ushortptr_t stix_oosw_t; /* short word - half word */
typedef stix_shortptr_t stix_oosi_t; /* signed short word */
typedef struct stix_obj_t stix_obj_t;
typedef struct stix_obj_t* stix_oop_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
/* these are more specialized types for stix_obj_t */
typedef struct stix_obj_oop_t stix_obj_oop_t;
typedef struct stix_obj_char_t stix_obj_char_t;
@ -96,7 +103,6 @@ typedef struct stix_obj_word_t* stix_oop_word_t;
#define STIX_OOW_BITS (STIX_SIZEOF(stix_oow_t) * 8)
#define STIX_OOP_BITS (STIX_SIZEOF(stix_oop_t) * 8)
/*
* OOP encoding
* An object pointer(OOP) is an ordinary pointer value to an object.
@ -271,7 +277,7 @@ struct stix_obj_oop_t
struct stix_obj_char_t
{
STIX_OBJ_HEADER;
stix_uch_t slot[1];
stix_ooch_t slot[1];
};
struct stix_obj_byte_t
@ -673,6 +679,7 @@ struct stix_t
stix_oop_t _character; /* Character */
stix_oop_t _small_integer; /* SmallInteger */
stix_oop_t _large_integer;
/* == NEVER CHANGE THE ORDER OF FIELDS ABOVE == */
stix_oop_set_t symtab; /* system-wide symbol table. instance of SymbolSet */
@ -821,8 +828,8 @@ STIX_EXPORT int stix_execute (
*/
STIX_EXPORT int stix_invoke (
stix_t* stix,
const stix_ucs_t* objname,
const stix_ucs_t* mthname
const stix_oocs_t* objname,
const stix_oocs_t* mthname
);
/* Temporary OOP management */

14
stix/lib/sym.c
View File

@ -49,7 +49,7 @@ static stix_oop_oop_t expand_bucket (stix_t* stix, stix_oop_oop_t oldbuc)
STIX_ASSERT (STIX_CLASSOF(stix,symbol) == stix->_symbol);
/*STIX_ASSERT (sym->size > 0);*/
index = stix_hashuchars(symbol->slot, STIX_OBJ_GET_SIZE(symbol)) % newsz;
index = stix_hashchars(symbol->slot, STIX_OBJ_GET_SIZE(symbol)) % newsz;
while (newbuc->slot[index] != stix->_nil) index = (index + 1) % newsz;
newbuc->slot[index] = (stix_oop_t)symbol;
}
@ -58,7 +58,7 @@ static stix_oop_oop_t expand_bucket (stix_t* stix, stix_oop_oop_t oldbuc)
return newbuc;
}
static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_uch_t* ptr, stix_oow_t len, int create)
static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len, int create)
{
stix_oow_t index, tally;
stix_oop_char_t symbol;
@ -72,7 +72,7 @@ static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_uch_t* ptr, stix
}
STIX_ASSERT (STIX_CLASSOF(stix,stix->symtab->bucket) == stix->_array);
index = stix_hashuchars(ptr, len) % STIX_OBJ_GET_SIZE(stix->symtab->bucket);
index = stix_hashchars(ptr, len) % STIX_OBJ_GET_SIZE(stix->symtab->bucket);
/* find a matching symbol in the open-addressed symbol table */
while (stix->symtab->bucket->slot[index] != stix->_nil)
@ -114,7 +114,7 @@ static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_uch_t* ptr, stix
stix->symtab->bucket = bucket;
/* recalculate the index for the expanded bucket */
index = stix_hashuchars(ptr, len) % STIX_OBJ_GET_SIZE(stix->symtab->bucket);
index = stix_hashchars(ptr, len) % STIX_OBJ_GET_SIZE(stix->symtab->bucket);
while (stix->symtab->bucket->slot[index] != stix->_nil)
index = (index + 1) % STIX_OBJ_GET_SIZE(stix->symtab->bucket);
@ -132,17 +132,17 @@ static stix_oop_t find_or_make_symbol (stix_t* stix, const stix_uch_t* ptr, stix
return (stix_oop_t)symbol;
}
stix_oop_t stix_makesymbol (stix_t* stix, const stix_uch_t* ptr, stix_oow_t len)
stix_oop_t stix_makesymbol (stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len)
{
return find_or_make_symbol (stix, ptr, len, 1);
}
stix_oop_t stix_findsymbol (stix_t* stix, const stix_uch_t* ptr, stix_oow_t len)
stix_oop_t stix_findsymbol (stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len)
{
return find_or_make_symbol (stix, ptr, len, 0);
}
stix_oop_t stix_makestring (stix_t* stix, const stix_uch_t* ptr, stix_oow_t len)
stix_oop_t stix_makestring (stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len)
{
return stix_instantiate (stix, stix->_string, ptr, len);
}