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

added code that handles pool dictionary defintion

Browse Source
This commit is contained in:
hyunghwan.chung 2015-07-15 08:39:18 +00:00
parent 9e720c40d0
commit 5700b57d57
5 changed files with 124 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
stix/lib/comp.c
View File

@ -2163,13 +2163,14 @@ oops:
return STIX_NULL; return STIX_NULL;
} }
static int preprocess_dotted_name (stix_t* stix, int dont_add_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_ucs_t* fqn, const stix_ioloc_t* fqn_loc, stix_ucs_t* name, stix_oop_set_t* ns_oop)
{ {
const stix_uch_t* ptr, * dot; const stix_uch_t* ptr, * dot;
stix_size_t len; stix_size_t len;
stix_ucs_t seg; stix_ucs_t seg;
stix_oop_set_t dic; stix_oop_set_t dic;
stix_oop_association_t ass; stix_oop_association_t ass;
int pooldic_gotten = 0;
dic = stix->sysdic; dic = stix->sysdic;
ptr = fqn->ptr; ptr = fqn->ptr;
@ -2182,6 +2183,8 @@ static int preprocess_dotted_name (stix_t* stix, int dont_add_ns, const stix_ucs
dot = stix_findchar (ptr, len, '.'); dot = stix_findchar (ptr, len, '.');
if (dot) if (dot)
{ {
if (pooldic_gotten) goto wrong_name;
seg.len = dot - ptr; seg.len = dot - ptr;
if (is_reserved_word(&seg)) goto wrong_name; if (is_reserved_word(&seg)) goto wrong_name;
@ -2197,7 +2200,18 @@ static int preprocess_dotted_name (stix_t* stix, int dont_add_ns, const stix_ucs
} }
else else
{ {
goto wrong_name; if (accept_pooldic_as_ns && STIX_CLASSOF(stix, ass->value) == stix->_pool_dictionary)
{
/* A pool dictionary is treated as if it's a name space.
* However, the pool dictionary can only act as a name space
* if it's the second last segment. */
dic = (stix_oop_set_t)ass->value;
pooldic_gotten = 1;
}
else
{
goto wrong_name;
}
} }
} }
else else
@ -2501,9 +2515,11 @@ static int get_variable_info (stix_t* stix, const stix_ucs_t* name, const stix_i
stix_oop_association_t ass; stix_oop_association_t ass;
/*TODO: handle self.XXX ---------- */ /*TODO: handle self.XXX ---------- */
/* TOOD: handle pool dictionary ---- */ if (preprocess_dotted_name (stix, 1, 1, name, name_loc, &last, &ns_oop) <= -1) return -1;
if (preprocess_dotted_name (stix, 1, name, name_loc, &last, &ns_oop) <= -1) return -1;
printf ("checking variable ");
print_ucs (&last);
printf ("\n");
ass = stix_lookupdic (stix, ns_oop, &last); ass = stix_lookupdic (stix, ns_oop, &last);
if (ass) if (ass)
{ {
@ -2579,6 +2595,7 @@ static int get_variable_info (stix_t* stix, const stix_ucs_t* name, const stix_i
ass = stix_lookupdic (stix, stix->c->cls.ns_oop, name); ass = stix_lookupdic (stix, stix->c->cls.ns_oop, name);
if (!ass && stix->c->cls.ns_oop != stix->sysdic) if (!ass && stix->c->cls.ns_oop != stix->sysdic)
ass = stix_lookupdic (stix, stix->sysdic, name); ass = stix_lookupdic (stix, stix->sysdic, name);
/* TODO: search in the pool dictionary */
if (ass) if (ass)
{ {
var->type = VAR_GLOBAL; var->type = VAR_GLOBAL;
@ -2893,7 +2910,7 @@ static int add_to_arlit_buffer (stix_t* stix, stix_oop_t item)
return 0; return 0;
} }
static int __compile_byte_array_literal (stix_t* stix, stix_oop_t* xlit) static int __read_byte_array_literal (stix_t* stix, stix_oop_t* xlit)
{ {
stix_ooi_t tmp; stix_ooi_t tmp;
stix_oop_t ba; stix_oop_t ba;
@ -2945,7 +2962,7 @@ struct arlit_info_t
typedef struct arlit_info_t arlit_info_t; typedef struct arlit_info_t arlit_info_t;
static int __compile_array_literal (stix_t* stix, stix_oop_t* xlit) static int __read_array_literal (stix_t* stix, stix_oop_t* xlit)
{ {
stix_oop_t lit, a; stix_oop_t lit, a;
stix_size_t i, saved_arlit_count; stix_size_t i, saved_arlit_count;
@ -3018,14 +3035,14 @@ printf ("LARGE NOT IMPLEMENTED IN COMPILE_ARRAY_LITERAL\n");
saved_arlit_count = stix->c->mth.arlit_count; saved_arlit_count = stix->c->mth.arlit_count;
/* TODO: get rid of recursion?? */ /* TODO: get rid of recursion?? */
GET_TOKEN (stix); GET_TOKEN (stix);
if (__compile_array_literal (stix, &lit) <= -1) return -1; if (__read_array_literal (stix, &lit) <= -1) return -1;
stix->c->mth.arlit_count = saved_arlit_count; stix->c->mth.arlit_count = saved_arlit_count;
break; break;
case STIX_IOTOK_BPAREN: /* #[ */ case STIX_IOTOK_BPAREN: /* #[ */
case STIX_IOTOK_LBRACK: /* [ */ case STIX_IOTOK_LBRACK: /* [ */
GET_TOKEN (stix); GET_TOKEN (stix);
if (__compile_byte_array_literal (stix, &lit) <= -1) return -1; if (__read_byte_array_literal (stix, &lit) <= -1) return -1;
break; break;
default: default:
@ -3058,37 +3075,57 @@ done:
return 0; return 0;
} }
static STIX_INLINE int read_byte_array_literal (stix_t* stix, stix_oop_t* xlit)
{
GET_TOKEN (stix); /* skip #[ and read the next token */
return __read_byte_array_literal(stix, xlit);
}
static int compile_byte_array_literal (stix_t* stix) static int compile_byte_array_literal (stix_t* stix)
{ {
stix_oop_t lit; stix_oop_t lit;
stix_size_t index; stix_size_t index;
GET_TOKEN (stix); /* skip #[ and read the next token */ if (read_byte_array_literal(stix, &lit) <= -1 ||
if (__compile_byte_array_literal (stix, &lit) <= -1) return -1; add_literal(stix, lit, &index) <= -1 ||
emit_single_param_instruction(stix, BCODE_PUSH_LITERAL_0, index) <= -1) return -1;
printf ("\tpush_literal byte_array\n"); printf ("\tpush_literal byte_array\n");
if (add_literal (stix, lit, &index) <= -1 ||
emit_single_param_instruction (stix, BCODE_PUSH_LITERAL_0, index) <= -1) return -1;
GET_TOKEN (stix); GET_TOKEN (stix);
return 0; return 0;
} }
static int read_array_literal (stix_t* stix, stix_oop_t* xlit)
{
int x;
stix_size_t saved_arlit_count;
stix->c->in_array = 1;
if (get_token(stix) <= -1)
{
/* skip #( and read the next token */
stix->c->in_array = 0;
return -1;
}
saved_arlit_count = stix->c->mth.arlit_count;
x = __read_array_literal (stix, xlit);
stix->c->mth.arlit_count = saved_arlit_count;
stix->c->in_array = 0;
return x;
}
static int compile_array_literal (stix_t* stix) static int compile_array_literal (stix_t* stix)
{ {
stix_oop_t lit; stix_oop_t lit;
stix_size_t index; stix_size_t index;
int x;
stix->c->in_array = 1; STIX_ASSERT (stix->c->mth.arlit_count == 0);
GET_TOKEN (stix); /* skip #( and read the next token */
x = __compile_array_literal (stix, &lit);
stix->c->in_array = 0;
if (x <= -1) return -1;
if (read_array_literal(stix, &lit) <= -1 ||
add_literal(stix, lit, &index) <= -1 ||
emit_single_param_instruction(stix, BCODE_PUSH_LITERAL_0, index) <= -1) return -1;
printf ("\tpush_literal array\n"); printf ("\tpush_literal array\n");
if (add_literal (stix, lit, &index) <= -1 ||
emit_single_param_instruction (stix, BCODE_PUSH_LITERAL_0, index) <= -1) return -1;
GET_TOKEN (stix); GET_TOKEN (stix);
return 0; return 0;
@ -4256,7 +4293,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
stix->c->cls.fqn_loc = stix->c->tok.loc; stix->c->cls.fqn_loc = stix->c->tok.loc;
if (stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED) if (stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED)
{ {
if (preprocess_dotted_name(stix, extend, &stix->c->cls.fqn, &stix->c->cls.fqn_loc, &stix->c->cls.name, &stix->c->cls.ns_oop) <= -1) return -1; if (preprocess_dotted_name(stix, extend, 0, &stix->c->cls.fqn, &stix->c->cls.fqn_loc, &stix->c->cls.name, &stix->c->cls.ns_oop) <= -1) return -1;
} }
else else
{ {
@ -4298,7 +4335,7 @@ static int __compile_class_definition (stix_t* stix, int extend)
{ {
int super_is_nil = 0; int super_is_nil = 0;
printf ("DEFININING.."); printf ("DEFININING CLASS ");
print_ucs (&stix->c->cls.name); print_ucs (&stix->c->cls.name);
printf ("\n"); printf ("\n");
if (stix->c->tok.type == STIX_IOTOK_LPAREN) if (stix->c->tok.type == STIX_IOTOK_LPAREN)
@ -4327,7 +4364,7 @@ printf ("\n");
if (stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED) if (stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED)
{ {
if (preprocess_dotted_name(stix, 1, &stix->c->cls.superfqn, &stix->c->cls.superfqn_loc, &stix->c->cls.supername, &stix->c->cls.superns_oop) <= -1) return -1; if (preprocess_dotted_name(stix, 1, 0, &stix->c->cls.superfqn, &stix->c->cls.superfqn_loc, &stix->c->cls.supername, &stix->c->cls.superns_oop) <= -1) return -1;
} }
else else
{ {
@ -4547,7 +4584,7 @@ static int __compile_pooldic_definition (stix_t* stix)
if (stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED) if (stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED)
{ {
if (preprocess_dotted_name(stix, 0, &stix->c->cls.fqn, &stix->c->cls.fqn_loc, &stix->c->cls.name, &stix->c->cls.ns_oop) <= -1) return -1; if (preprocess_dotted_name(stix, 0, 0, &stix->c->cls.fqn, &stix->c->cls.fqn_loc, &stix->c->cls.name, &stix->c->cls.ns_oop) <= -1) return -1;
} }
else else
{ {
@ -4568,6 +4605,10 @@ static int __compile_pooldic_definition (stix_t* stix)
return -1; return -1;
} }
printf ("DEFININING POOL DICTIONARY ");
print_ucs (&stix->c->cls.name);
printf ("\n");
GET_TOKEN (stix); GET_TOKEN (stix);
while (stix->c->tok.type == STIX_IOTOK_SYMLIT) while (stix->c->tok.type == STIX_IOTOK_SYMLIT)
@ -4589,51 +4630,73 @@ static int __compile_pooldic_definition (stix_t* stix)
{ {
case STIX_IOTOK_NIL: case STIX_IOTOK_NIL:
lit = stix->_nil; lit = stix->_nil;
goto simple_literal; goto add_literal;
case STIX_IOTOK_TRUE: case STIX_IOTOK_TRUE:
lit = stix->_true; lit = stix->_true;
goto simple_literal; goto add_literal;
case STIX_IOTOK_FALSE: case STIX_IOTOK_FALSE:
lit = stix->_false; lit = stix->_false;
goto simple_literal; goto add_literal;
case STIX_IOTOK_CHARLIT: case STIX_IOTOK_CHARLIT:
STIX_ASSERT (stix->c->tok.name.len == 1); STIX_ASSERT (stix->c->tok.name.len == 1);
lit = STIX_OOP_FROM_CHAR(stix->c->tok.name.ptr[0]); lit = STIX_OOP_FROM_CHAR(stix->c->tok.name.ptr[0]);
goto simple_literal; goto add_literal;
case STIX_IOTOK_STRLIT: case STIX_IOTOK_STRLIT:
lit = stix_instantiate (stix, stix->_string, stix->c->tok.name.ptr, stix->c->tok.name.len); lit = stix_instantiate (stix, stix->_string, stix->c->tok.name.ptr, stix->c->tok.name.len);
if (!lit) return -1; if (!lit) return -1;
goto simple_literal; goto add_literal;
case STIX_IOTOK_SYMLIT: case STIX_IOTOK_SYMLIT:
lit = stix_makesymbol (stix, stix->c->tok.name.ptr, stix->c->tok.name.len); lit = stix_makesymbol (stix, stix->c->tok.name.ptr, stix->c->tok.name.len);
if (!lit) return -1; if (!lit) return -1;
goto simple_literal; goto add_literal;
case STIX_IOTOK_NUMLIT: case STIX_IOTOK_NUMLIT:
case STIX_IOTOK_RADNUMLIT: case STIX_IOTOK_RADNUMLIT:
goto simple_literal; {
stix_ooi_t tmp;
#if 0 if (string_to_smint(stix, &stix->c->tok.name, stix->c->tok.type == STIX_IOTOK_RADNUMLIT, &tmp) <= -1)
case STIX_IOTOK_BPAREN: /* byte array */ {
case STIX_IOTOK_APAREN: /* array */ /* the token reader reads a valid token. no other errors
* than the range error must not occur */
STIX_ASSERT (stix->errnum == STIX_ERANGE);
printf ("NOT IMPLEMENTED LARGE_INTEGER or ERROR?\n");
stix->errnum = STIX_ENOIMPL;
return -1;
}
else
{
lit = STIX_OOP_FROM_SMINT(tmp);
}
goto add_literal;
}
case STIX_IOTOK_BPAREN: /* #[ */
if (read_byte_array_literal(stix, &lit) <= -1) return -1;
goto add_literal;
case STIX_IOTOK_APAREN: /* #( */
if (read_array_literal(stix, &lit) <= -1) return -1;
goto add_literal;
add_literal:
/*
* for this definition, #pooldic MyPoolDic { #a := 10. #b := 20 },
* arlit_buffer contains (#a 10 #b 20) when the 'while' loop is over. */
if (add_to_arlit_buffer(stix, lit) <= -1) return -1;
GET_TOKEN (stix);
break; break;
TODO:
#endif
default: default:
set_syntax_error (stix, STIX_SYNERR_LITERAL, &stix->c->tok.loc, &stix->c->tok.name); set_syntax_error (stix, STIX_SYNERR_LITERAL, &stix->c->tok.loc, &stix->c->tok.name);
return -1; return -1;
simple_literal:
if (add_to_arlit_buffer(stix, lit) <= -1) return -1;
GET_TOKEN (stix);
break;
} }
/*if (stix->c->tok.type == STIX_IOTOK_RBRACE) goto done; /*if (stix->c->tok.type == STIX_IOTOK_RBRACE) goto done;
@ -4686,7 +4749,6 @@ static int compile_pooldic_definition (stix_t* stix)
STIX_MEMSET (&stix->c->cls.fqn_loc, 0, STIX_SIZEOF(stix->c->cls.fqn_loc)); STIX_MEMSET (&stix->c->cls.fqn_loc, 0, STIX_SIZEOF(stix->c->cls.fqn_loc));
stix->c->cls.mthdic_oop[0] = STIX_NULL; stix->c->cls.mthdic_oop[0] = STIX_NULL;
stix->c->cls.ns_oop = STIX_NULL; stix->c->cls.ns_oop = STIX_NULL;
stix->c->mth.literal_count = 0;
stix->c->mth.balit_count = 0; stix->c->mth.balit_count = 0;
stix->c->mth.arlit_count = 0; stix->c->mth.arlit_count = 0;
@ -4695,9 +4757,9 @@ static int compile_pooldic_definition (stix_t* stix)
/* reset these oops plus literal pointers not to confuse gc_compiler() */ /* reset these oops plus literal pointers not to confuse gc_compiler() */
stix->c->cls.mthdic_oop[0] = STIX_NULL; stix->c->cls.mthdic_oop[0] = STIX_NULL;
stix->c->cls.ns_oop = STIX_NULL; stix->c->cls.ns_oop = STIX_NULL;
stix->c->mth.literal_count = 0;
stix->c->mth.balit_count = 0; stix->c->mth.balit_count = 0;
stix->c->mth.arlit_count = 0; stix->c->mth.arlit_count = 0;
return n; return n;
} }
@ -4784,16 +4846,12 @@ static void gc_compiler (stix_t* stix)
for (i = 0; i < stix->c->mth.literal_count; i++) for (i = 0; i < stix->c->mth.literal_count; i++)
{ {
if (STIX_OOP_IS_POINTER(stix->c->mth.literals[i])) stix->c->mth.literals[i] = stix_moveoop (stix, stix->c->mth.literals[i]);
{
stix->c->mth.literals[i] = stix_moveoop (stix, stix->c->mth.literals[i]);
}
} }
for (i = 0; i < stix->c->mth.arlit_count; i++) for (i = 0; i < stix->c->mth.arlit_count; i++)
{ {
if (STIX_OOP_IS_POINTER(stix->c->mth.arlit[i])) stix->c->mth.arlit[i] = stix_moveoop (stix, stix->c->mth.arlit[i]);
stix->c->mth.arlit[i] = stix_moveoop (stix, stix->c->mth.arlit[i]);
} }
} }
} }

2
stix/lib/debug.c
View File

@ -283,7 +283,7 @@ static void __dump_object (stix_t* stix, stix_oop_t oop, int depth)
printf (" #["); /* TODO: different symbol for word array ?? */ printf (" #["); /* TODO: different symbol for word array ?? */
for (i = 0; i < STIX_OBJ_GET_SIZE(oop); i++) for (i = 0; i < STIX_OBJ_GET_SIZE(oop); i++)
{ {
printf (" %ld", ((stix_oop_word_t)oop)->slot[i]); printf (" %ld", (long int)((stix_oop_word_t)oop)->slot[i]);
} }
printf ("]"); printf ("]");
} }

17
stix/lib/dic.c
View File

@ -61,7 +61,7 @@ static stix_oop_oop_t expand_bucket (stix_t* stix, stix_oop_oop_t oldbuc)
return newbuc; return newbuc;
} }
static stix_oop_association_t find_or_insert (stix_t* stix, stix_oop_set_t dic, stix_oop_char_t key, stix_oop_t value) static stix_oop_association_t find_or_upsert (stix_t* stix, stix_oop_set_t dic, stix_oop_char_t key, stix_oop_t value)
{ {
stix_oow_t index, tally; stix_oow_t index, tally;
stix_oop_association_t ass; stix_oop_association_t ass;
@ -85,15 +85,18 @@ static stix_oop_association_t find_or_insert (stix_t* stix, stix_oop_set_t dic,
if (STIX_OBJ_GET_SIZE(key) == STIX_OBJ_GET_SIZE(ass->key) && if (STIX_OBJ_GET_SIZE(key) == STIX_OBJ_GET_SIZE(ass->key) &&
stix_equalchars (key->slot, ((stix_oop_char_t)ass->key)->slot, STIX_OBJ_GET_SIZE(key))) stix_equalchars (key->slot, ((stix_oop_char_t)ass->key)->slot, STIX_OBJ_GET_SIZE(key)))
{ {
/* the value of STIX_NULL indicates no insertion or update. */
if (value) ass->value = value;
return ass; return ass;
} }
index = (index + 1) % STIX_OBJ_GET_SIZE(dic->bucket); index = (index + 1) % STIX_OBJ_GET_SIZE(dic->bucket);
} }
if (value == STIX_NULL) if (!value)
{ {
/* when value is STIX_NULL, perform no insertion */ /* when value is STIX_NULL, perform no insertion.
* the value of STIX_NULL indicates no insertion or update. */
stix->errnum = STIX_ENOENT; stix->errnum = STIX_ENOENT;
return STIX_NULL; return STIX_NULL;
} }
@ -184,13 +187,13 @@ static stix_oop_association_t lookup (stix_t* stix, stix_oop_set_t dic, const st
stix_oop_association_t stix_putatsysdic (stix_t* stix, stix_oop_t key, stix_oop_t value) stix_oop_association_t stix_putatsysdic (stix_t* stix, stix_oop_t key, stix_oop_t value)
{ {
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol); STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
return find_or_insert (stix, stix->sysdic, (stix_oop_char_t)key, value); return find_or_upsert (stix, stix->sysdic, (stix_oop_char_t)key, value);
} }
stix_oop_association_t stix_getatsysdic (stix_t* stix, stix_oop_t key) stix_oop_association_t stix_getatsysdic (stix_t* stix, stix_oop_t key)
{ {
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol); STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
return find_or_insert (stix, stix->sysdic, (stix_oop_char_t)key, STIX_NULL); 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_ucs_t* name)
@ -201,13 +204,13 @@ stix_oop_association_t stix_lookupsysdic (stix_t* stix, const stix_ucs_t* name)
stix_oop_association_t stix_putatdic (stix_t* stix, stix_oop_set_t dic, stix_oop_t key, stix_oop_t value) stix_oop_association_t stix_putatdic (stix_t* stix, stix_oop_set_t dic, stix_oop_t key, stix_oop_t value)
{ {
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol); STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
return find_or_insert (stix, dic, (stix_oop_char_t)key, value); return find_or_upsert (stix, dic, (stix_oop_char_t)key, value);
} }
stix_oop_association_t stix_getatdic (stix_t* stix, stix_oop_set_t dic, stix_oop_t key) stix_oop_association_t stix_getatdic (stix_t* stix, stix_oop_set_t dic, stix_oop_t key)
{ {
STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol); STIX_ASSERT (STIX_CLASSOF(stix,key) == stix->_symbol);
return find_or_insert (stix, dic, (stix_oop_char_t)key, STIX_NULL); 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_ucs_t* name)

3
stix/lib/gc.c
View File

@ -89,8 +89,7 @@ stix_oop_t stix_moveoop (stix_t* stix, stix_oop_t oop)
if (!oop) return oop; if (!oop) return oop;
#endif #endif
STIX_ASSERT (STIX_OOP_IS_POINTER(oop)); if (!STIX_OOP_IS_POINTER(oop)) return oop;
/*if (STIX_OOP_IS_POINTER(oop)) return oop;*/
if (STIX_OBJ_GET_FLAGS_MOVED(oop)) if (STIX_OBJ_GET_FLAGS_MOVED(oop))
{ {

3
stix/lib/stix.c
View File

@ -31,6 +31,9 @@ stix_t* stix_open (stix_mmgr_t* mmgr, stix_size_t xtnsize, stix_size_t heapsize,
{ {
stix_t* stix; stix_t* stix;
/* if this assertion fails, correct the type definition in stix.h */
STIX_ASSERT (STIX_SIZEOF(stix_oow_t) == STIX_SIZEOF(stix_oop_t));
stix = STIX_MMGR_ALLOC (mmgr, STIX_SIZEOF(*stix) + xtnsize); stix = STIX_MMGR_ALLOC (mmgr, STIX_SIZEOF(*stix) + xtnsize);
if (stix) if (stix)
{ {