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

added more code to stix_genpfmethod(). still incomplete

Browse Source
This commit is contained in:
hyunghwan.chung 2016-12-03 18:08:31 +00:00
parent 7b5fc708f7
commit b4a513cf40
9 changed files with 210 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
stix/kernel/Stdio.st
View File

@ -21,18 +21,18 @@
#method(#class) open: name for: mode #method(#class) open: name for: mode
{ {
^(super new: 1) open: name for: mode ^(self new) open: name for: mode
} }
#method open: name for: mode ## #method open: name for: mode
{ ## {
<primitive: #stdio_open> ## <primitive: #stdio_open>
} ## }
#method close ## #method close
{ ## {
<primitive: #stdio_close> ## <primitive: #stdio_close>
} ## }
} }
#extend Stdio #extend Stdio

116
stix/lib/comp.c
View File

@ -45,12 +45,6 @@ enum class_mod_t
CLASS_INDEXED = (1 << 0) CLASS_INDEXED = (1 << 0)
}; };
enum mth_type_t
{
MTH_INSTANCE,
MTH_CLASS
};
enum var_type_t enum var_type_t
{ {
/* NEVER Change the order and the value of 3 items below. /* NEVER Change the order and the value of 3 items below.
@ -1985,20 +1979,20 @@ 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) static STIX_INLINE int add_pool_dictionary (stix_t* stix, const stix_oocs_t* name, stix_oop_set_t pooldic_oop)
{ {
if (stix->c->cls.pooldic_count >= stix->c->cls.pooldic_oop_capa) if (stix->c->cls.pooldic_count >= stix->c->cls.pooldic_imp_oops_capa)
{ {
stix_oow_t new_capa; stix_oow_t new_capa;
stix_oop_set_t* tmp; stix_oop_set_t* tmp;
new_capa = STIX_ALIGN(stix->c->cls.pooldic_oop_capa + 1, POOLDIC_OOP_BUFFER_ALIGN); new_capa = STIX_ALIGN(stix->c->cls.pooldic_imp_oops_capa + 1, POOLDIC_OOP_BUFFER_ALIGN);
tmp = stix_reallocmem (stix, stix->c->cls.pooldic_oops, new_capa * STIX_SIZEOF(stix_oop_set_t)); tmp = stix_reallocmem (stix, stix->c->cls.pooldic_imp_oops, new_capa * STIX_SIZEOF(stix_oop_set_t));
if (!tmp) return -1; if (!tmp) return -1;
stix->c->cls.pooldic_oop_capa = new_capa; stix->c->cls.pooldic_imp_oops_capa = new_capa;
stix->c->cls.pooldic_oops = tmp; stix->c->cls.pooldic_imp_oops = tmp;
} }
stix->c->cls.pooldic_oops[stix->c->cls.pooldic_count] = pooldic_oop; stix->c->cls.pooldic_imp_oops[stix->c->cls.pooldic_count] = pooldic_oop;
stix->c->cls.pooldic_count++; stix->c->cls.pooldic_count++;
/* TODO: check if pooldic_count overflows */ /* TODO: check if pooldic_count overflows */
@ -2195,7 +2189,11 @@ static int add_method_name_fragment (stix_t* stix, const stix_oocs_t* name)
static int method_exists (stix_t* stix, const stix_oocs_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 */ /* check if the current class contains a method of the given name */
#ifdef MTHDIC
return stix_lookupdic (stix, stix->c->cls.mthdic_oop[stix->c->mth.type], name) != STIX_NULL; return stix_lookupdic (stix, stix->c->cls.mthdic_oop[stix->c->mth.type], name) != STIX_NULL;
#else
return stix_lookupdic (stix, stix->c->cls.self_oop->mthdic[stix->c->mth.type], name) != STIX_NULL;
#endif
} }
static int add_temporary_variable (stix_t* stix, const stix_oocs_t* name) static int add_temporary_variable (stix_t* stix, const stix_oocs_t* name)
@ -2365,7 +2363,7 @@ static int resolve_pooldic (stix_t* stix, int dotted, const stix_oocs_t* name)
/* check if the same dictionary pool has been declared for import */ /* check if the same dictionary pool has been declared for import */
for (i = 0; i < stix->c->cls.pooldic_count; i++) for (i = 0; i < stix->c->cls.pooldic_count; i++)
{ {
if ((stix_oop_set_t)ass->value == stix->c->cls.pooldic_oops[i]) if ((stix_oop_set_t)ass->value == stix->c->cls.pooldic_imp_oops[i])
{ {
set_syntax_error (stix, STIX_SYNERR_POOLDICDUP, TOKEN_LOC(stix), name); set_syntax_error (stix, STIX_SYNERR_POOLDICDUP, TOKEN_LOC(stix), name);
return -1; return -1;
@ -2391,7 +2389,7 @@ static int import_pool_dictionary (stix_t* stix, stix_oop_set_t ns_oop, const st
/* check if the same dictionary pool has been declared for import */ /* check if the same dictionary pool has been declared for import */
for (i = 0; i < stix->c->cls.pooldic_count; i++) for (i = 0; i < stix->c->cls.pooldic_count; i++)
{ {
if ((stix_oop_set_t)ass->value == stix->c->cls.pooldic_oops[i]) if ((stix_oop_set_t)ass->value == stix->c->cls.pooldic_imp_oops[i])
{ {
set_syntax_error (stix, STIX_SYNERR_POOLDICDUP, tok_loc, tok_name); set_syntax_error (stix, STIX_SYNERR_POOLDICDUP, tok_loc, tok_name);
return -1; return -1;
@ -2897,7 +2895,7 @@ static int get_variable_info (stix_t* stix, const stix_oocs_t* name, const stix_
switch (var->type) switch (var->type)
{ {
case VAR_INSTANCE: case VAR_INSTANCE:
if (stix->c->mth.type == MTH_CLASS) if (stix->c->mth.type == STIX_METHOD_CLASS)
{ {
/* a class method cannot access an instance variable */ /* a class method cannot access an instance variable */
set_syntax_error (stix, STIX_SYNERR_VARINACC, name_loc, name); set_syntax_error (stix, STIX_SYNERR_VARINACC, name_loc, name);
@ -2918,7 +2916,7 @@ static int get_variable_info (stix_t* stix, const stix_oocs_t* name, const stix_
case VAR_CLASSINST: case VAR_CLASSINST:
/* class instance variable can be accessed by only class methods */ /* class instance variable can be accessed by only class methods */
if (stix->c->mth.type == MTH_INSTANCE) if (stix->c->mth.type == STIX_METHOD_INSTANCE)
{ {
/* an instance method cannot access a class-instance variable */ /* an instance method cannot access a class-instance variable */
set_syntax_error (stix, STIX_SYNERR_VARINACC, name_loc, name); set_syntax_error (stix, STIX_SYNERR_VARINACC, name_loc, name);
@ -2958,7 +2956,7 @@ static int get_variable_info (stix_t* stix, const stix_oocs_t* name, const stix_
/* attempt to find the variable in pool dictionaries */ /* attempt to find the variable in pool dictionaries */
for (i = 0; i < stix->c->cls.pooldic_count; i++) for (i = 0; i < stix->c->cls.pooldic_count; i++)
{ {
ass = stix_lookupdic (stix, stix->c->cls.pooldic_oops[i], name); ass = stix_lookupdic (stix, stix->c->cls.pooldic_imp_oops[i], name);
if (ass) if (ass)
{ {
if (ass2) if (ass2)
@ -4344,7 +4342,7 @@ static int add_compiled_method (stix_t* stix)
else if (stix->c->mth.pftype == 2) else if (stix->c->mth.pftype == 2)
{ {
preamble_code = STIX_METHOD_PREAMBLE_NAMED_PRIMITIVE; preamble_code = STIX_METHOD_PREAMBLE_NAMED_PRIMITIVE;
preamble_index = stix->c->mth.pfnum; preamble_index = stix->c->mth.pfnum; /* index to literal frame */
} }
else if (stix->c->mth.pftype == 3) else if (stix->c->mth.pftype == 3)
{ {
@ -4385,7 +4383,11 @@ need to write code to collect string.
stix_poptmps (stix, tmp_count); tmp_count = 0; stix_poptmps (stix, tmp_count); tmp_count = 0;
#ifdef MTHDIC
if (!stix_putatdic(stix, stix->c->cls.mthdic_oop[stix->c->mth.type], (stix_oop_t)name, (stix_oop_t)mth)) goto oops; if (!stix_putatdic(stix, stix->c->cls.mthdic_oop[stix->c->mth.type], (stix_oop_t)name, (stix_oop_t)mth)) goto oops;
#else
if (!stix_putatdic(stix, stix->c->cls.self_oop->mthdic[stix->c->mth.type], (stix_oop_t)name, (stix_oop_t)mth)) goto oops;
#endif
return 0; return 0;
@ -4397,7 +4399,7 @@ oops:
static int compile_method_definition (stix_t* stix) static int compile_method_definition (stix_t* stix)
{ {
/* clear data required to compile a method */ /* clear data required to compile a method */
stix->c->mth.type = MTH_INSTANCE; stix->c->mth.type = STIX_METHOD_INSTANCE;
stix->c->mth.text.len = 0; stix->c->mth.text.len = 0;
stix->c->mth.assignees.len = 0; stix->c->mth.assignees.len = 0;
stix->c->mth.binsels.len = 0; stix->c->mth.binsels.len = 0;
@ -4423,7 +4425,7 @@ static int compile_method_definition (stix_t* stix)
if (is_token_symbol(stix, VOCA_CLASS)) if (is_token_symbol(stix, VOCA_CLASS))
{ {
/* #method(#class) */ /* #method(#class) */
stix->c->mth.type = MTH_CLASS; stix->c->mth.type = STIX_METHOD_CLASS;
GET_TOKEN (stix); GET_TOKEN (stix);
} }
@ -4544,12 +4546,20 @@ static int make_defined_class (stix_t* stix)
/* TOOD: good dictionary size */ /* TOOD: good dictionary size */
tmp = (stix_oop_t)stix_makedic (stix, stix->_method_dictionary, INSTANCE_METHOD_DICTIONARY_SIZE); tmp = (stix_oop_t)stix_makedic (stix, stix->_method_dictionary, INSTANCE_METHOD_DICTIONARY_SIZE);
if (!tmp) return -1; if (!tmp) return -1;
stix->c->cls.mthdic_oop[MTH_INSTANCE] = (stix_oop_set_t)tmp; #ifdef MTHDIC
stix->c->cls.mthdic_oop[STIX_METHOD_INSTANCE] = (stix_oop_set_t)tmp;
#else
stix->c->cls.self_oop->mthdic[STIX_METHOD_INSTANCE] = (stix_oop_set_t)tmp;
#endif
/* TOOD: good dictionary size */ /* TOOD: good dictionary size */
tmp = (stix_oop_t)stix_makedic (stix, stix->_method_dictionary, CLASS_METHOD_DICTIONARY_SIZE); tmp = (stix_oop_t)stix_makedic (stix, stix->_method_dictionary, CLASS_METHOD_DICTIONARY_SIZE);
if (!tmp) return -1; if (!tmp) return -1;
stix->c->cls.mthdic_oop[MTH_CLASS] = (stix_oop_set_t)tmp; #ifdef MTHDIC
stix->c->cls.mthdic_oop[STIX_METHOD_CLASS] = (stix_oop_set_t)tmp;
#else
stix->c->cls.self_oop->mthdic[STIX_METHOD_CLASS] = (stix_oop_set_t)tmp;
#endif
/* TODO: initialize more fields??? whatelse. */ /* TODO: initialize more fields??? whatelse. */
@ -4814,7 +4824,9 @@ static int __compile_class_definition (stix_t* stix, int extend)
return -1; return -1;
} }
if (TOKEN_NAME_LEN(stix) < 1 || TOKEN_NAME_LEN(stix) > STIX_MOD_NAME_LEN_MAX) if (TOKEN_NAME_LEN(stix) < 1 ||
TOKEN_NAME_LEN(stix) > STIX_MOD_NAME_LEN_MAX ||
stix_findoochar(TOKEN_NAME_PTR(stix), TOKEN_NAME_LEN(stix), '_'))
{ {
set_syntax_error (stix, STIX_SYNERR_MODNAME, TOKEN_LOC(stix), TOKEN_NAME(stix)); set_syntax_error (stix, STIX_SYNERR_MODNAME, TOKEN_LOC(stix), TOKEN_NAME(stix));
return -1; return -1;
@ -4860,9 +4872,12 @@ static int __compile_class_definition (stix_t* stix, int extend)
return -1; return -1;
} }
#ifdef MTHDIC
/* use the method dictionary of an existing class object */ /* use the method dictionary of an existing class object */
stix->c->cls.mthdic_oop[MTH_INSTANCE] = stix->c->cls.self_oop->mthdic[STIX_CLASS_MTHDIC_INSTANCE]; stix->c->cls.mthdic_oop[STIX_METHOD_INSTANCE] = stix->c->cls.self_oop->mthdic[STIX_METHOD_INSTANCE];
stix->c->cls.mthdic_oop[MTH_CLASS] = stix->c->cls.self_oop->mthdic[STIX_CLASS_MTHDIC_CLASS]; stix->c->cls.mthdic_oop[STIX_METHOD_CLASS] = stix->c->cls.self_oop->mthdic[STIX_METHOD_CLASS];
#endif
/* load the pooldic definition from the existing class object */ /* load the pooldic definition from the existing class object */
pds = stix->c->cls.self_oop->pooldics; pds = stix->c->cls.self_oop->pooldics;
@ -4870,7 +4885,6 @@ static int __compile_class_definition (stix_t* stix, int extend)
{ {
stix_ooch_t* ptr, * end; stix_ooch_t* ptr, * end;
STIX_ASSERT (STIX_CLASSOF(stix, pds) == stix->_string); STIX_ASSERT (STIX_CLASSOF(stix, pds) == stix->_string);
ptr = pds->slot; ptr = pds->slot;
@ -4947,12 +4961,15 @@ static int __compile_class_definition (stix_t* stix, int extend)
return -1; return -1;
} }
#ifdef MTHDIC
if (!extend) if (!extend)
{ {
/* link the method dictionaries created to the actual class object */
/* TODO: anything else to set? */ /* TODO: anything else to set? */
stix->c->cls.self_oop->mthdic[STIX_CLASS_MTHDIC_INSTANCE] = stix->c->cls.mthdic_oop[MTH_INSTANCE]; stix->c->cls.self_oop->mthdic[STIX_CLASS_MTHDIC_INSTANCE] = stix->c->cls.mthdic_oop[STIX_METHOD_INSTANCE];
stix->c->cls.self_oop->mthdic[STIX_CLASS_MTHDIC_CLASS] = stix->c->cls.mthdic_oop[MTH_CLASS]; stix->c->cls.self_oop->mthdic[STIX_CLASS_MTHDIC_CLASS] = stix->c->cls.mthdic_oop[STIX_METHOD_CLASS];
} }
#endif
GET_TOKEN (stix); GET_TOKEN (stix);
return 0; return 0;
@ -4984,8 +5001,10 @@ static int compile_class_definition (stix_t* stix, int extend)
stix->c->cls.self_oop = STIX_NULL; stix->c->cls.self_oop = STIX_NULL;
stix->c->cls.super_oop = STIX_NULL; stix->c->cls.super_oop = STIX_NULL;
stix->c->cls.mthdic_oop[MTH_INSTANCE] = STIX_NULL; #ifdef MTHDIC
stix->c->cls.mthdic_oop[MTH_CLASS] = STIX_NULL; stix->c->cls.mthdic_oop[STIX_METHOD_INSTANCE] = STIX_NULL;
stix->c->cls.mthdic_oop[STIX_METHOD_CLASS] = STIX_NULL;
#endif
stix->c->cls.ns_oop = STIX_NULL; stix->c->cls.ns_oop = STIX_NULL;
stix->c->cls.superns_oop = STIX_NULL; stix->c->cls.superns_oop = STIX_NULL;
stix->c->mth.literal_count = 0; stix->c->mth.literal_count = 0;
@ -4998,8 +5017,10 @@ static int compile_class_definition (stix_t* stix, int extend)
/* 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.self_oop = STIX_NULL; stix->c->cls.self_oop = STIX_NULL;
stix->c->cls.super_oop = STIX_NULL; stix->c->cls.super_oop = STIX_NULL;
stix->c->cls.mthdic_oop[MTH_INSTANCE] = STIX_NULL; #ifdef MTHDIC
stix->c->cls.mthdic_oop[MTH_CLASS] = STIX_NULL; stix->c->cls.mthdic_oop[STIX_METHOD_INSTANCE] = STIX_NULL;
stix->c->cls.mthdic_oop[STIX_METHOD_CLASS] = STIX_NULL;
#endif
stix->c->cls.ns_oop = STIX_NULL; stix->c->cls.ns_oop = STIX_NULL;
stix->c->cls.superns_oop = STIX_NULL; stix->c->cls.superns_oop = STIX_NULL;
stix->c->mth.literal_count = 0; stix->c->mth.literal_count = 0;
@ -5152,19 +5173,21 @@ static int __compile_pooldic_definition (stix_t* stix)
/*TODO: tally and arlit_count range check */ /*TODO: tally and arlit_count range check */
/*if (!STIX_IN_SMOOI_RANGE(tally)) ERROR??*/ /*if (!STIX_IN_SMOOI_RANGE(tally)) ERROR??*/
stix->c->cls.mthdic_oop[0] = stix_makedic (stix, stix->_pool_dictionary, STIX_ALIGN(tally + 10, POOL_DICTIONARY_SIZE_ALIGN)); /* i use mthdic_oop[0] when compling #pooldic. it's not a real method dictionary.
if (!stix->c->cls.mthdic_oop[0]) return -1; * i just use it not to declare another field into the compiler */
stix->c->cls.pooldic_oop = stix_makedic (stix, stix->_pool_dictionary, STIX_ALIGN(tally + 10, POOL_DICTIONARY_SIZE_ALIGN));
if (!stix->c->cls.pooldic_oop) return -1;
for (i = 0; i < stix->c->mth.arlit_count; i += 2) for (i = 0; i < stix->c->mth.arlit_count; i += 2)
{ {
/* TODO: handle duplicate keys? */ /* TODO: handle duplicate keys? */
if (!stix_putatdic(stix, stix->c->cls.mthdic_oop[0], stix->c->mth.arlit[i], stix->c->mth.arlit[i + 1])) return -1; if (!stix_putatdic(stix, stix->c->cls.pooldic_oop, stix->c->mth.arlit[i], stix->c->mth.arlit[i + 1])) return -1;
} }
/* eveything seems ok. register the pool dictionary to the main /* eveything seems ok. register the pool dictionary to the main
* system dictionary or to the name space it belongs to */ * system dictionary or to the name space it belongs to */
lit = stix_makesymbol (stix, stix->c->cls.name.ptr, stix->c->cls.name.len); lit = stix_makesymbol (stix, stix->c->cls.name.ptr, stix->c->cls.name.len);
if (!lit || !stix_putatdic (stix, stix->c->cls.ns_oop, lit, (stix_oop_t)stix->c->cls.mthdic_oop[0])) return -1; if (!lit || !stix_putatdic (stix, stix->c->cls.ns_oop, lit, (stix_oop_t)stix->c->cls.pooldic_oop)) return -1;
return 0; return 0;
} }
@ -5176,7 +5199,7 @@ static int compile_pooldic_definition (stix_t* stix)
* i'll be reusing some fields reserved for compling a class */ * i'll be reusing some fields reserved for compling a class */
stix->c->cls.name.len = 0; stix->c->cls.name.len = 0;
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.pooldic_oop = STIX_NULL;
stix->c->cls.ns_oop = STIX_NULL; stix->c->cls.ns_oop = STIX_NULL;
stix->c->mth.balit_count = 0; stix->c->mth.balit_count = 0;
stix->c->mth.arlit_count = 0; stix->c->mth.arlit_count = 0;
@ -5184,7 +5207,7 @@ static int compile_pooldic_definition (stix_t* stix)
n = __compile_pooldic_definition (stix); n = __compile_pooldic_definition (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.pooldic_oop = STIX_NULL;
stix->c->cls.ns_oop = STIX_NULL; stix->c->cls.ns_oop = STIX_NULL;
stix->c->mth.balit_count = 0; stix->c->mth.balit_count = 0;
stix->c->mth.arlit_count = 0; stix->c->mth.arlit_count = 0;
@ -5258,11 +5281,16 @@ static void gc_compiler (stix_t* stix)
if (stix->c->cls.super_oop) if (stix->c->cls.super_oop)
stix->c->cls.super_oop = stix_moveoop (stix, stix->c->cls.super_oop); stix->c->cls.super_oop = stix_moveoop (stix, stix->c->cls.super_oop);
if (stix->c->cls.mthdic_oop[MTH_INSTANCE]) #ifdef MTHDIC
stix->c->cls.mthdic_oop[MTH_INSTANCE] = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.mthdic_oop[MTH_INSTANCE]); if (stix->c->cls.mthdic_oop[STIX_METHOD_INSTANCE])
stix->c->cls.mthdic_oop[STIX_METHOD_INSTANCE] = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.mthdic_oop[STIX_METHOD_INSTANCE]);
if (stix->c->cls.mthdic_oop[MTH_CLASS]) if (stix->c->cls.mthdic_oop[STIX_METHOD_CLASS])
stix->c->cls.mthdic_oop[MTH_CLASS] = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.mthdic_oop[MTH_CLASS]); stix->c->cls.mthdic_oop[STIX_METHOD_CLASS] = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.mthdic_oop[STIX_METHOD_CLASS]);
#endif
if (stix->c->cls.pooldic_oop)
stix->c->cls.pooldic_oop = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.pooldic_oop);
if (stix->c->cls.ns_oop) if (stix->c->cls.ns_oop)
stix->c->cls.ns_oop = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.ns_oop); stix->c->cls.ns_oop = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.ns_oop);
@ -5272,7 +5300,7 @@ static void gc_compiler (stix_t* stix)
for (i = 0; i < stix->c->cls.pooldic_count; i++) for (i = 0; i < stix->c->cls.pooldic_count; i++)
{ {
stix->c->cls.pooldic_oops[i] = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.pooldic_oops[i]); stix->c->cls.pooldic_imp_oops[i] = (stix_oop_set_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.pooldic_imp_oops[i]);
} }
for (i = 0; i < stix->c->mth.literal_count; i++) for (i = 0; i < stix->c->mth.literal_count; i++)
@ -5306,7 +5334,7 @@ static void fini_compiler (stix_t* stix)
} }
if (stix->c->cls.pooldic.ptr) stix_freemem (stix, stix->c->cls.pooldic.ptr); if (stix->c->cls.pooldic.ptr) stix_freemem (stix, stix->c->cls.pooldic.ptr);
if (stix->c->cls.pooldic_oops) stix_freemem (stix, stix->c->cls.pooldic_oops); if (stix->c->cls.pooldic_imp_oops) stix_freemem (stix, stix->c->cls.pooldic_imp_oops);
if (stix->c->mth.text.ptr) stix_freemem (stix, stix->c->mth.text.ptr); if (stix->c->mth.text.ptr) stix_freemem (stix, stix->c->mth.text.ptr);
if (stix->c->mth.assignees.ptr) stix_freemem (stix, stix->c->mth.assignees.ptr); if (stix->c->mth.assignees.ptr) stix_freemem (stix, stix->c->mth.assignees.ptr);

22
stix/lib/exec.c
View File

@ -992,13 +992,13 @@ static stix_oop_method_t find_method (stix_t* stix, stix_oop_t receiver, const s
{ {
/* receiver is a class object (an instance of Class) */ /* receiver is a class object (an instance of Class) */
c = receiver; c = receiver;
dic_no = STIX_CLASS_MTHDIC_CLASS; dic_no = STIX_METHOD_CLASS;
} }
else else
{ {
/* receiver is not a class object. so take its class */ /* receiver is not a class object. so take its class */
c = (stix_oop_t)cls; c = (stix_oop_t)cls;
dic_no = STIX_CLASS_MTHDIC_INSTANCE; dic_no = STIX_METHOD_INSTANCE;
} }
STIX_ASSERT (c != stix->_nil); STIX_ASSERT (c != stix->_nil);
@ -1039,7 +1039,7 @@ not_found:
{ {
/* the object is an instance of Class. find the method /* the object is an instance of Class. find the method
* in an instance method dictionary of Class also */ * in an instance method dictionary of Class also */
mthdic = ((stix_oop_class_t)cls)->mthdic[STIX_CLASS_MTHDIC_INSTANCE]; mthdic = ((stix_oop_class_t)cls)->mthdic[STIX_METHOD_INSTANCE];
STIX_ASSERT ((stix_oop_t)mthdic != stix->_nil); STIX_ASSERT ((stix_oop_t)mthdic != stix->_nil);
STIX_ASSERT (STIX_CLASSOF(stix, mthdic) == stix->_method_dictionary); STIX_ASSERT (STIX_CLASSOF(stix, mthdic) == stix->_method_dictionary);
@ -2893,7 +2893,7 @@ static int start_method (stix_t* stix, stix_oop_method_t method, stix_oow_t narg
STIX_ASSERT (STIX_OBJ_GET_FLAGS_EXTRA(name)); STIX_ASSERT (STIX_OBJ_GET_FLAGS_EXTRA(name));
STIX_ASSERT (STIX_CLASSOF(stix,name) == stix->_symbol); STIX_ASSERT (STIX_CLASSOF(stix,name) == stix->_symbol);
handler = stix_querymodforpfimpl (stix, ((stix_oop_char_t)name)->slot, STIX_OBJ_GET_SIZE(name)); handler = stix_querymod (stix, ((stix_oop_char_t)name)->slot, STIX_OBJ_GET_SIZE(name));
} }
if (handler) if (handler)
@ -2915,15 +2915,19 @@ static int start_method (stix_t* stix, stix_oop_method_t method, stix_oow_t narg
return -1; /* hard primitive failure */ return -1; /* hard primitive failure */
} }
if (n >= 1) break; /* primitive ok*/ if (n >= 1) break; /* primitive ok*/
}
/* soft primitive failure or handler not found. /* soft primitive failure */
* if handler is not found, 0 must be printed in the debug message. */ STIX_DEBUG1 (stix, "Soft failure indicated by primitive function %p\n", handler);
STIX_DEBUG1 (stix, "Soft failure indicated by primitive function %p\n", handler); }
else
{
/* no handler found */
STIX_DEBUG0 (stix, "Soft failure for non-existent primitive function\n");
}
#if defined(STIX_USE_OBJECT_TRAILER) #if defined(STIX_USE_OBJECT_TRAILER)
STIX_ASSERT (STIX_OBJ_GET_FLAGS_TRAILER(method)); STIX_ASSERT (STIX_OBJ_GET_FLAGS_TRAILER(method));
if (method->slot[STIX_OBJ_GET_SIZE(method)] == 0) /* this trailer size field not a small integer */ if (STIX_METHOD_GET_CODE_SIZE(method) == 0) /* this trailer size field not a small integer */
#else #else
if (method->code == stix->_nil) if (method->code == stix->_nil)
#endif #endif

2
stix/lib/main.c
View File

@ -411,7 +411,7 @@ static void log_write (stix_t* stix, stix_oow_t mask, const stix_ooch_t* msg, st
struct tm tm, *tmp; struct tm tm, *tmp;
time_t now; time_t now;
/*if (mask & STIX_LOG_GC) return;*/ /* don't show gc logs */ if (mask & STIX_LOG_GC) return; /* don't show gc logs */
/* TODO: beautify the log message. /* TODO: beautify the log message.
* do classification based on mask. */ * do classification based on mask. */

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

@ -45,7 +45,7 @@
#define STIX_USE_MAKE_BLOCK #define STIX_USE_MAKE_BLOCK
/* this is for gc debugging */ /* this is for gc debugging */
/*#define STIX_DEBUG_GC*/ #define STIX_DEBUG_GC
#define STIX_DEBUG_COMPILER #define STIX_DEBUG_COMPILER
/*#define STIX_DEBUG_VM_PROCESSOR*/ /*#define STIX_DEBUG_VM_PROCESSOR*/
/*#define STIX_DEBUG_VM_EXEC*/ /*#define STIX_DEBUG_VM_EXEC*/
@ -479,8 +479,10 @@ struct stix_compiler_t
stix_oop_class_t self_oop; stix_oop_class_t self_oop;
stix_oop_t super_oop; /* this may be nil. so the type is stix_oop_t */ stix_oop_t super_oop; /* this may be nil. so the type is stix_oop_t */
stix_oop_set_t mthdic_oop[2]; #ifdef MTHDIC
stix_oop_set_t mthdic_oop[2]; /* used when compiling a method definition */
#endif
stix_oop_set_t pooldic_oop; /* used when compiling a pooldic definition */
stix_oop_set_t ns_oop; stix_oop_set_t ns_oop;
stix_oocs_t fqn; stix_oocs_t fqn;
stix_oocs_t name; stix_oocs_t name;
@ -503,18 +505,20 @@ struct stix_compiler_t
* var_count[2] - number of class instance variables */ * var_count[2] - number of class instance variables */
stix_oow_t var_count[3]; stix_oow_t var_count[3];
/* buffer to hold pooldic import declaration */
stix_oocs_t pooldic; stix_oocs_t pooldic;
stix_oow_t pooldic_capa; stix_oow_t pooldic_capa;
stix_oow_t pooldic_count; stix_oow_t pooldic_count;
stix_oop_set_t* pooldic_oops; /* used to hold imported pool dictionarie objects */
stix_oow_t pooldic_oop_capa; stix_oop_set_t* pooldic_imp_oops;
stix_oow_t pooldic_imp_oops_capa;
} cls; } cls;
/* information about a function being comipled */ /* information about a method being comipled */
struct struct
{ {
int type; stix_method_type_t type;
/* method source text */ /* method source text */
stix_oocs_t text; stix_oocs_t text;
@ -590,16 +594,8 @@ struct stix_oochbuf_t
stix_oow_t capa; stix_oow_t capa;
}; };
struct stix_decoder_t
{
stix_oochbuf_t fltout;
stix_bchbuf_t fltfmt;
};
#endif #endif
#if defined(STIX_USE_OBJECT_TRAILER) #if defined(STIX_USE_OBJECT_TRAILER)
/* let it point to the trailer of the method */ /* let it point to the trailer of the method */
# define SET_ACTIVE_METHOD_CODE(stix) ((stix)->active_code = (stix_oob_t*)&(stix)->active_method->slot[STIX_OBJ_GET_SIZE((stix)->active_method) + 1 - STIX_METHOD_NAMED_INSTVARS]) # define SET_ACTIVE_METHOD_CODE(stix) ((stix)->active_code = (stix_oob_t*)&(stix)->active_method->slot[STIX_OBJ_GET_SIZE((stix)->active_method) + 1 - STIX_METHOD_NAMED_INSTVARS])
@ -1268,10 +1264,10 @@ int stix_importmod (
); );
/* /*
* The stix_querymodforpfimpl() function finds a primitive function in modules * The stix_querymod() function finds a primitive function in modules
* with a full primitive identifier. * with a full primitive identifier.
*/ */
stix_pfimpl_t stix_querymodforpfimpl ( stix_pfimpl_t stix_querymod (
stix_t* stix, stix_t* stix,
const stix_ooch_t* pfid, const stix_ooch_t* pfid,
stix_oow_t pfidlen stix_oow_t pfidlen

87
stix/lib/stix.c
View File

@ -505,7 +505,7 @@ stix_mod_data_t* stix_openmod (stix_t* stix, const stix_ooch_t* name, stix_oow_t
/* attempt to find an external module */ /* attempt to find an external module */
STIX_MEMSET (&md, 0, STIX_SIZEOF(md)); STIX_MEMSET (&md, 0, STIX_SIZEOF(md));
stix_copyoochars (md.name, name, namelen); stix_copyoochars ((stix_ooch_t*)md.mod.name, name, namelen);
if (stix->vmprim.dl_open && stix->vmprim.dl_getsym && stix->vmprim.dl_close) if (stix->vmprim.dl_open && stix->vmprim.dl_getsym && stix->vmprim.dl_close)
{ {
md.handle = stix->vmprim.dl_open (stix, &buf[MOD_PREFIX_LEN]); md.handle = stix->vmprim.dl_open (stix, &buf[MOD_PREFIX_LEN]);
@ -551,7 +551,7 @@ stix_mod_data_t* stix_openmod (stix_t* stix, const stix_ooch_t* name, stix_oow_t
mdp->pair = pair; mdp->pair = pair;
STIX_DEBUG2 (stix, "Opened a module [%S] - %p\n", mdp->name, mdp->handle); STIX_DEBUG2 (stix, "Opened a module [%S] - %p\n", mdp->mod.name, mdp->handle);
/* the module loader must ensure to set a proper query handler */ /* the module loader must ensure to set a proper query handler */
STIX_ASSERT (mdp->mod.query != STIX_NULL); STIX_ASSERT (mdp->mod.query != STIX_NULL);
@ -566,14 +566,14 @@ void stix_closemod (stix_t* stix, stix_mod_data_t* mdp)
if (mdp->handle) if (mdp->handle)
{ {
stix->vmprim.dl_close (stix, mdp->handle); stix->vmprim.dl_close (stix, mdp->handle);
STIX_DEBUG2 (stix, "Closed a module [%S] - %p\n", mdp->name, mdp->handle); STIX_DEBUG2 (stix, "Closed a module [%S] - %p\n", mdp->mod.name, mdp->handle);
mdp->handle = STIX_NULL; mdp->handle = STIX_NULL;
} }
if (mdp->pair) if (mdp->pair)
{ {
/*mdp->pair = STIX_NULL;*/ /* this reset isn't needed as the area will get freed by stix_rbt_delete()) */ /*mdp->pair = STIX_NULL;*/ /* this reset isn't needed as the area will get freed by stix_rbt_delete()) */
stix_rbt_delete (&stix->modtab, mdp->name, stix_countoocstr(mdp->name)); stix_rbt_delete (&stix->modtab, mdp->mod.name, stix_countoocstr(mdp->mod.name));
} }
} }
@ -583,6 +583,11 @@ int stix_importmod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, st
stix_mod_data_t* mdp; stix_mod_data_t* mdp;
int r = 0; int r = 0;
/* stix_openmod(), stix_closemod(), etc calls a user-defined callback.
* i need to protect _class in case the user-defined callback allocates
* a OOP memory chunk and GC occurs */
stix_pushtmp (stix, &_class);
pair = stix_rbt_search (&stix->modtab, name, len); pair = stix_rbt_search (&stix->modtab, name, len);
if (pair) if (pair)
{ {
@ -601,7 +606,7 @@ int stix_importmod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, st
if (!mdp->mod.import) if (!mdp->mod.import)
{ {
STIX_DEBUG1 (stix, "Cannot import module [%S] - importing not supported by the module\n", mdp->name); STIX_DEBUG1 (stix, "Cannot import module [%S] - importing not supported by the module\n", mdp->mod.name);
stix->errnum = STIX_ENOIMPL; stix->errnum = STIX_ENOIMPL;
r = -1; r = -1;
goto done; goto done;
@ -609,7 +614,7 @@ int stix_importmod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, st
if (mdp->mod.import (stix, &mdp->mod, _class) <= -1) if (mdp->mod.import (stix, &mdp->mod, _class) <= -1)
{ {
STIX_DEBUG1 (stix, "Cannot import module [%S] - module's import() returned failure\n", mdp->name); STIX_DEBUG1 (stix, "Cannot import module [%S] - module's import() returned failure\n", mdp->mod.name);
r = -1; r = -1;
goto done; goto done;
} }
@ -621,10 +626,11 @@ done:
stix_closemod (stix, mdp); stix_closemod (stix, mdp);
} }
stix_poptmp (stix);
return r; return r;
} }
stix_pfimpl_t stix_querymodforpfimpl (stix_t* stix, const stix_ooch_t* pfid, stix_oow_t pfidlen) stix_pfimpl_t stix_querymod (stix_t* stix, const stix_ooch_t* pfid, stix_oow_t pfidlen)
{ {
/* primitive function identifier /* primitive function identifier
* _funcname * _funcname
@ -666,41 +672,66 @@ stix_pfimpl_t stix_querymodforpfimpl (stix_t* stix, const stix_ooch_t* pfid, sti
if ((handler = mdp->mod.query (stix, &mdp->mod, sep + 1)) == STIX_NULL) if ((handler = mdp->mod.query (stix, &mdp->mod, sep + 1)) == STIX_NULL)
{ {
/* the primitive function is not found. keep the module open */ /* the primitive function is not found. keep the module open */
STIX_DEBUG2 (stix, "Cannot find a primitive function [%S] in a module [%S]\n", sep + 1, mdp->name); STIX_DEBUG2 (stix, "Cannot find a primitive function [%S] in a module [%S]\n", sep + 1, mdp->mod.name);
stix->errnum = STIX_ENOENT; /* TODO: proper error code and handling */ stix->errnum = STIX_ENOENT; /* TODO: proper error code and handling */
return STIX_NULL; return STIX_NULL;
} }
STIX_DEBUG3 (stix, "Found a primitive function [%S] in a module [%S] - %p\n", sep + 1, mdp->name, handler); STIX_DEBUG3 (stix, "Found a primitive function [%S] in a module [%S] - %p\n", sep + 1, mdp->mod.name, handler);
return handler; return handler;
} }
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* add a new primitive method */ /* add a new primitive method */
int stix_addmethod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, stix_pfimpl_t func) int stix_genpfmethod (stix_t* stix, stix_mod_t* mod, stix_oop_t _class, stix_method_type_t type, const stix_ooch_t* mthname, const stix_ooch_t* pfname)
{ {
/* NOTE: this function is a subset of add_compiled_method() in comp.c */ /* NOTE: this function is a subset of add_compiled_method() in comp.c */
stix_oop_char_t nsym; stix_oop_char_t mnsym, pfidsym;
stix_oop_method_t mth; stix_oop_method_t mth;
stix_oop_class_t cls; stix_oop_class_t cls;
stix_oow_t tmp_count = 0, i; stix_oow_t tmp_count = 0, i;
stix_ooi_t arg_count = 0; stix_ooi_t arg_count = 0;
stix_oocs_t cs;
STIX_ASSERT (STIX_CLASSOF(stix, _class) == stix->_class); STIX_ASSERT (STIX_CLASSOF(stix, _class) == stix->_class);
cls = (stix_oop_class_t)_class; cls = (stix_oop_class_t)_class;
stix_pushtmp (stix, (stix_oop_t*)&cls); tmp_count++;
STIX_ASSERT (STIX_CLASSOF(stix, (stix_oop_t)cls->mthdic[type]) == stix->_method_dictionary);
/* TODO: check if name is a valid method name */ for (i = 0; mthname[i]; i++)
for (i = 0; name[i]; i++)
{ {
if (name[i] == ':') arg_count++; if (mthname[i] == ':') arg_count++;
}
/* TODO: check if name is a valid method name - more checks... */
/* TOOD: if the method name is a binary selector, it can still have an argument.. so the check below is invalid... */
if (arg_count > 0 && mthname[i - 1] != ':')
{
STIX_DEBUG2 (stix, "Cannot generate primitive function method [%S] in [%O] - invalid name\n", mthname, cls->name);
stix->errnum = STIX_EINVAL;
goto oops;
} }
nsym = (stix_oop_char_t)stix_makesymbol (stix, name, i);
if (!nsym) return -1;
stix_pushtmp (stix, (stix_oop_t*)&name); tmp_count++; cs.ptr = (stix_ooch_t*)mthname;
cs.len = i;
if (stix_lookupdic (stix, cls->mthdic[type], &cs) != STIX_NULL)
{
STIX_DEBUG2 (stix, "Cannot generate primitive function method [%S] in [%O] - duplicate\n", mthname, cls->name);
stix->errnum = STIX_EEXIST;
goto oops;
}
mnsym = (stix_oop_char_t)stix_makesymbol (stix, mthname, i);
if (!mnsym) goto oops;
stix_pushtmp (stix, (stix_oop_t*)&mnsym); tmp_count++;
/* TODO:... */
/* pfid => mod->name + '_' + pfname */
pfidsym = (stix_oop_char_t)stix_makesymbol (stix, pfname, stix_countoocstr(pfname));
if (!pfidsym) goto oops;
stix_pushtmp (stix, (stix_oop_t*)&pfidsym); tmp_count++;
#if defined(STIX_USE_OBJECT_TRAILER) #if defined(STIX_USE_OBJECT_TRAILER)
mth = (stix_oop_method_t)stix_instantiatewithtrailer (stix, stix->_method, 1, STIX_NULL, 0); mth = (stix_oop_method_t)stix_instantiatewithtrailer (stix, stix->_method, 1, STIX_NULL, 0);
@ -709,23 +740,23 @@ int stix_addmethod (stix_t* stix, stix_oop_t _class, const stix_ooch_t* name, st
#endif #endif
if (!mth) goto oops; if (!mth) goto oops;
/* store the symbol name to the literal frame */ /* store the primitive function name symbol to the literal frame */
mth->slot[0] = (stix_oop_t)nsym; mth->slot[0] = (stix_oop_t)pfidsym;
/* add the primitive as a name primitive with index of -1. /* premable should contain the index to the literal frame - 0 */
* set the preamble_data to the pointer to the primitive function. */
mth->owner = cls; mth->owner = cls;
mth->name = nsym; mth->name = mnsym;
mth->preamble = STIX_SMOOI_TO_OOP(STIX_METHOD_MAKE_PREAMBLE(STIX_METHOD_PREAMBLE_NAMED_PRIMITIVE, -1)); mth->preamble = STIX_SMOOI_TO_OOP(STIX_METHOD_MAKE_PREAMBLE(STIX_METHOD_PREAMBLE_NAMED_PRIMITIVE, 0));
mth->preamble_data[0] = STIX_SMOOI_TO_OOP((stix_oow_t)func >> (STIX_OOW_BITS / 2)); mth->preamble_data[0] = STIX_SMOOI_TO_OOP(0);
mth->preamble_data[1] = STIX_SMOOI_TO_OOP((stix_oow_t)func & STIX_LBMASK(stix_oow_t, STIX_OOW_BITS / 2)); mth->preamble_data[1] = STIX_SMOOI_TO_OOP(0);
mth->tmpr_count = STIX_SMOOI_TO_OOP(arg_count); mth->tmpr_count = STIX_SMOOI_TO_OOP(arg_count);
mth->tmpr_nargs = STIX_SMOOI_TO_OOP(arg_count); mth->tmpr_nargs = STIX_SMOOI_TO_OOP(arg_count);
stix_poptmps (stix, tmp_count); tmp_count = 0; stix_poptmps (stix, tmp_count); tmp_count = 0;
/* TODO: class method? */ /* TODO: emit BCODE_RETURN_NIL ? */
/* instance method */
if (!stix_putatdic (stix, cls->mthdic[STIX_CLASS_MTHDIC_INSTANCE], (stix_oop_t)nsym, (stix_oop_t)mth)) goto oops; if (!stix_putatdic (stix, cls->mthdic[type], (stix_oop_t)mnsym, (stix_oop_t)mth)) goto oops;
return 0; return 0;
oops: oops:

43
stix/lib/stix.h
View File

@ -52,6 +52,7 @@ enum stix_errnum_t
STIX_ESYSMEM, /**< insufficient system memory */ STIX_ESYSMEM, /**< insufficient system memory */
STIX_EOOMEM, /**< insufficient object memory */ STIX_EOOMEM, /**< insufficient object memory */
STIX_EINVAL, /**< invalid parameter or data */ STIX_EINVAL, /**< invalid parameter or data */
STIX_EEXIST, /**< existing/duplicate data */
STIX_ETOOBIG, /**< data too large */ STIX_ETOOBIG, /**< data too large */
STIX_EMSGSND, /**< message sending error. even doesNotUnderstand: is not found */ STIX_EMSGSND, /**< message sending error. even doesNotUnderstand: is not found */
STIX_ERANGE, /**< range error. overflow and underflow */ STIX_ERANGE, /**< range error. overflow and underflow */
@ -159,6 +160,17 @@ typedef struct stix_obj_word_t* stix_oop_word_t;
#endif #endif
enum stix_method_type_t
{
STIX_METHOD_INSTANCE,
STIX_METHOD_CLASS,
/* --------------------------- */
STIX_METHOD_TYPE_COUNT
};
typedef enum stix_method_type_t stix_method_type_t;
/* /*
* OOP encoding * OOP encoding
* An object pointer(OOP) is an ordinary pointer value to an object. * An object pointer(OOP) is an ordinary pointer value to an object.
@ -424,13 +436,11 @@ struct stix_class_t
/* [0] - instance methods, MethodDictionary /* [0] - instance methods, MethodDictionary
* [1] - class methods, MethodDictionary */ * [1] - class methods, MethodDictionary */
stix_oop_set_t mthdic[2]; stix_oop_set_t mthdic[STIX_METHOD_TYPE_COUNT];
/* indexed part afterwards */ /* indexed part afterwards */
stix_oop_t slot[1]; /* class instance variables and class variables. */ stix_oop_t slot[1]; /* class instance variables and class variables. */
}; };
#define STIX_CLASS_MTHDIC_INSTANCE 0
#define STIX_CLASS_MTHDIC_CLASS 1
#define STIX_ASSOCIATION_NAMED_INSTVARS 2 #define STIX_ASSOCIATION_NAMED_INSTVARS 2
typedef struct stix_association_t stix_association_t; typedef struct stix_association_t stix_association_t;
@ -757,6 +767,7 @@ typedef void (*stix_mod_unload_t) (
struct stix_mod_t struct stix_mod_t
{ {
const stix_ooch_t name[STIX_MOD_NAME_LEN_MAX + 1];
stix_mod_import_t import; stix_mod_import_t import;
stix_mod_query_t query; stix_mod_query_t query;
stix_mod_unload_t unload; stix_mod_unload_t unload;
@ -765,7 +776,6 @@ struct stix_mod_t
struct stix_mod_data_t struct stix_mod_data_t
{ {
stix_ooch_t name[STIX_MOD_NAME_LEN_MAX + 1];
void* handle; void* handle;
stix_rbt_pair_t* pair; /* internal backreference to stix->modtab */ stix_rbt_pair_t* pair; /* internal backreference to stix->modtab */
stix_mod_t mod; stix_mod_t mod;
@ -1081,10 +1091,6 @@ STIX_EXPORT void stix_gc (
stix_t* stix stix_t* stix
); );
STIX_EXPORT stix_oow_t stix_getpayloadbytes (
stix_t* stix,
stix_oop_t oop
);
/** /**
* The stix_instantiate() function creates a new object of the class * The stix_instantiate() function creates a new object of the class
@ -1176,6 +1182,22 @@ STIX_EXPORT void stix_freemem (
); );
/* =========================================================================
* PRIMITIVE METHOD MANIPULATION
* ========================================================================= */
STIX_EXPORT int stix_genpfmethod (
stix_t* stix,
stix_mod_t* mod,
stix_oop_t _class,
stix_method_type_t type,
const stix_ooch_t* mthname,
const stix_ooch_t* name
);
/* =========================================================================
* STRING ENCODING CONVERSION
* ========================================================================= */
#if defined(STIX_OOCH_IS_UCH) #if defined(STIX_OOCH_IS_UCH)
# define stix_oocstobcs(stix,oocs,oocslen,bcs,bcslen) stix_ucstobcs(stix,oocs,oocslen,bcs,bcslen) # define stix_oocstobcs(stix,oocs,oocslen,bcs,bcslen) stix_ucstobcs(stix,oocs,oocslen,bcs,bcslen)
# define stix_bcstooocs(stix,bcs,bcslen,oocs,oocslen) stix_bcstoucs(stix,bcs,bcslen,oocs,oocslen) # define stix_bcstooocs(stix,bcs,bcslen,oocs,oocslen) stix_bcstoucs(stix,bcs,bcslen,oocs,oocslen)
@ -1201,6 +1223,11 @@ STIX_EXPORT int stix_ucstobcs (
stix_oow_t* bcslen stix_oow_t* bcslen
); );
/* =========================================================================
* STIX VM LOGGING
* ========================================================================= */
STIX_EXPORT stix_ooi_t stix_logbfmt ( STIX_EXPORT stix_ooi_t stix_logbfmt (
stix_t* stix, stix_t* stix,
stix_oow_t mask, stix_oow_t mask,

32
stix/mod/console.c
View File

@ -302,37 +302,5 @@ int stix_mod_console (stix_t* stix, stix_mod_t* mod)
mod->query = query; mod->query = query;
mod->unload = unload; mod->unload = unload;
mod->ctx = STIX_NULL; mod->ctx = STIX_NULL;
#if 0
#include 'Stix.st'.
#import 'Console'.
c = stix_findclass (stix, "Console");
if (!c) c = stix_makeclass (stix, "Console", "x y"); <- provides an API to create a simple class
stix_addmethod (stix, c, "open", pf_open);
stix_addmethod (stix, c, "close:", pf_close);
stix_addmethod (stix, c, "setCursorTo:", pf_setcursor);
stix_addmethod (stix, c, "clear", pf_clear );
stix_addmethod (stix, c, "write", pf_write );
/* GRAMMER ENHANCEMENT */
fun abc (a, b, c) <----- this style, register C style method
{
}
fun abc: a with: b c: c <----- smalltalk style
{
}
abc->def (a, b, c) <------- use -> as an c style method indicator
abc abc: a with: b c: c
#endif
return 0; return 0;
} }

20
stix/mod/stdio.c
View File

@ -128,10 +128,18 @@ static fnctab_t fnctab[] =
{ "puts", pf_puts } { "puts", pf_puts }
}; };
static stix_ooch_t voca_open_for[] = { 'o','p','e','n',':','f','o','r',':','\0' };
static stix_ooch_t voca_open[] = { 'o','p','e','n','\0' };
static stix_ooch_t voca_close[] = { 'c','l','o','s','e','\0' };
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
static int import (stix_t* stix, stix_mod_t* mod, stix_oop_t _class) static int import (stix_t* stix, stix_mod_t* mod, stix_oop_t _class)
{ {
stix_pushtmp (stix, &_class);
stix_genpfmethod (stix, mod, _class, STIX_METHOD_INSTANCE, voca_open_for, voca_open);
stix_genpfmethod (stix, mod, _class, STIX_METHOD_CLASS, voca_close, voca_close);
stix_poptmp (stix);
return 0; return 0;
} }
@ -186,18 +194,6 @@ int stix_mod_stdio (stix_t* stix, stix_mod_t* mod)
#include 'Stix.st'. #include 'Stix.st'.
#import 'Console'. #import 'Console'.
c = stix_findclass (stix, "Console");
if (!c) c = stix_makeclass (stix, "Console", "x y"); <- provides an API to create a simple class
stix_addmethod (stix, c, "open", pf_open);
stix_addmethod (stix, c, "close:", pf_close);
stix_addmethod (stix, c, "setCursorTo:", pf_setcursor);
stix_addmethod (stix, c, "clear", pf_clear );
stix_addmethod (stix, c, "write", pf_write );
/* GRAMMER ENHANCEMENT */ /* GRAMMER ENHANCEMENT */
fun abc (a, b, c) <----- this style, register C style method fun abc (a, b, c) <----- this style, register C style method
{ {