From f2ec2d5fd2846bf6d42e775038fbcbb04c1066bc Mon Sep 17 00:00:00 2001 From: "hyunghwan.chung" Date: Fri, 10 Jul 2015 14:06:07 +0000 Subject: [PATCH] did some preparatory work to support namespaces --- stix/lib/comp.c | 269 +++++++++++++++++++++++++++++++++++-------- stix/lib/gc.c | 1 + stix/lib/ignite.c | 18 +-- stix/lib/stix-prv.h | 1 + stix/lib/stix.h | 3 +- stix/lib/test-005.st | 7 +- 6 files changed, 239 insertions(+), 60 deletions(-) diff --git a/stix/lib/comp.c b/stix/lib/comp.c index 4c69128..2d1d496 100644 --- a/stix/lib/comp.c +++ b/stix/lib/comp.c @@ -90,6 +90,7 @@ static struct voca_t { 4, { 'm','a','i','n' } }, { 6, { 'm','e','t','h','o','d' } }, { 3, { 'm','t','h' } }, + { 9, { 'n','a','m','e','s','p','a','c','e' } }, { 3, { 'n','i','l' } }, { 7, { 'p','o','i','n','t','e','r' } }, { 10, { 'p','r','i','m','i','t','i','v','e',':' } }, @@ -120,6 +121,7 @@ enum voca_id_t VOCA_MAIN, VOCA_METHOD, VOCA_MTH, + VOCA_NAMESPACE, VOCA_NIL, VOCA_POINTER, VOCA_PRIMITIVE_COLON, @@ -240,12 +242,12 @@ static STIX_INLINE int is_token_symbol (stix_t* stix, voca_id_t id) return stix->c->tok.type == STIX_IOTOK_SYMLIT && does_token_name_match(stix, id); } -static STIX_INLINE int is_token_ident (stix_t* stix, voca_id_t id) +static STIX_INLINE int is_token_reserved_word (stix_t* stix, voca_id_t id) { return stix->c->tok.type == STIX_IOTOK_IDENT && does_token_name_match(stix, id); } -static STIX_INLINE int is_token_binsel (stix_t* stix, voca_id_t id) +static STIX_INLINE int is_token_binary_selector (stix_t* stix, voca_id_t id) { return stix->c->tok.type == STIX_IOTOK_BINSEL && does_token_name_match(stix, id); } @@ -597,7 +599,7 @@ static int get_char (stix_t* stix) static int skip_spaces (stix_t* stix) { - while (is_spacechar(stix->c->curinp->lxc.c)) GET_CHAR (stix); + while (is_spacechar(stix->c->lxc.c)) GET_CHAR (stix); return 0; } @@ -678,7 +680,6 @@ static int get_ident (stix_t* stix, stix_uci_t char_read_ahead) ADD_TOKEN_CHAR(stix, char_read_ahead); } -get_more: do { ADD_TOKEN_CHAR (stix, c); @@ -688,44 +689,85 @@ get_more: if (c == ':') { + read_more_kwsym: ADD_TOKEN_CHAR (stix, c); stix->c->tok.type = STIX_IOTOK_KEYWORD; GET_CHAR_TO (stix, c); - if (stix->c->in_array && is_alnumchar(c)) + if (stix->c->in_array && is_alphachar(c)) { - /* [NOTE] - * for an input like #(abc:def 1 2 3), abc:def is returned as - * a keyword. it would not be a real keyword even if it were - * prefixed with #. it is because it doesn't end with a colon. - */ - goto get_more; + /* when reading an array literal, read as many characters as + * would compose a normal keyword symbol literal */ + do + { + ADD_TOKEN_CHAR (stix, c); + GET_CHAR_TO (stix, c); + } + while (is_alnumchar(c)); + + if (c == ':') goto read_more_kwsym; + else + { + /* the last character is not a colon */ + set_syntax_error (stix, STIX_SYNERR_COLON, &stix->c->lxc.l, STIX_NULL); + return -1; + } } } else { + if (c == '.') + { + stix_iolxc_t period; + + period = stix->c->lxc; + + read_more_seg: + GET_CHAR_TO (stix, c); + + if (is_alphachar(c)) + { + stix->c->tok.type = STIX_IOTOK_IDENT_DOTTED; + + ADD_TOKEN_CHAR (stix, '.'); + do + { + ADD_TOKEN_CHAR (stix, c); + GET_CHAR_TO (stix, c); + } + while (is_alnumchar(c)); + + if (c == '.') goto read_more_seg; + } + else + { + unget_char (stix, &stix->c->lxc); + stix->c->lxc = period; + } + } + /* handle reserved words */ - if (is_token_ident(stix, VOCA_SELF)) + if (is_token_reserved_word(stix, VOCA_SELF)) { stix->c->tok.type = STIX_IOTOK_SELF; } - else if (is_token_ident(stix, VOCA_SUPER)) + else if (is_token_reserved_word(stix, VOCA_SUPER)) { stix->c->tok.type = STIX_IOTOK_SUPER; } - else if (is_token_ident(stix, VOCA_NIL)) + else if (is_token_reserved_word(stix, VOCA_NIL)) { stix->c->tok.type = STIX_IOTOK_NIL; } - else if (is_token_ident(stix, VOCA_TRUE)) + else if (is_token_reserved_word(stix, VOCA_TRUE)) { stix->c->tok.type = STIX_IOTOK_TRUE; } - else if (is_token_ident(stix, VOCA_FALSE)) + else if (is_token_reserved_word(stix, VOCA_FALSE)) { stix->c->tok.type = STIX_IOTOK_FALSE; } - else if (is_token_ident(stix, VOCA_THIS_CONTEXT)) + else if (is_token_reserved_word(stix, VOCA_THIS_CONTEXT)) { stix->c->tok.type = STIX_IOTOK_THIS_CONTEXT; } @@ -1029,7 +1071,6 @@ static int get_string (stix_t* stix, stix_uch_t end_char, stix_uch_t esc_char, i return 0; } - static int get_binsel (stix_t* stix) { /* @@ -1210,9 +1251,6 @@ retry: } else if (is_alphachar(c)) { - int colon_required = 0; - - nextword: do { ADD_TOKEN_CHAR (stix, c); @@ -1222,22 +1260,59 @@ retry: if (c == ':') { + /* keyword symbol - e.g. #ifTrue:ifFalse: */ + read_more_word: ADD_TOKEN_CHAR (stix, c); GET_CHAR_TO (stix, c); - if (is_alphachar(c)) + if (is_alphachar(c)) { - /* if a colon is found in the middle of a symbol, - * the last charater is expected to be a colon as well */ - colon_required =1; - goto nextword; + do + { + ADD_TOKEN_CHAR (stix, c); + GET_CHAR_TO (stix, c); + } + while (is_alnumchar(c)); + + if (c == ':') goto read_more_word; + else + { + /* if a colon is found in the middle of a symbol, + * the last charater is expected to be a colon as well. + * but, the last character is not a colon */ + set_syntax_error (stix, STIX_SYNERR_COLON, &stix->c->lxc.l, STIX_NULL); + return -1; + } } } - else if (colon_required) + else if (c == '.') { - /* the last character is not a colon */ - set_syntax_error (stix, STIX_SYNERR_COLON, &stix->c->lxc.l, STIX_NULL); - return -1; + /* dotted symbol e.g. #Planet.Earth.Object */ + + stix_iolxc_t period; + + period = stix->c->lxc; + + read_more_seg: + GET_CHAR_TO (stix, c); + + if (is_alphachar(c)) + { + ADD_TOKEN_CHAR (stix, '.'); + do + { + ADD_TOKEN_CHAR (stix, c); + GET_CHAR_TO (stix, c); + } + while (is_alnumchar(c)); + + if (c == '.') goto read_more_seg; + } + else + { + unget_char (stix, &stix->c->lxc); + stix->c->lxc = period; + } } } else @@ -1331,6 +1406,9 @@ retry: break; } +printf ("TOKEN: ["); +print_ucs (&stix->c->tok.name); +printf ("]\n"); return 0; } @@ -1390,6 +1468,15 @@ static int begin_include (stix_t* stix) goto oops; } + GET_TOKEN (stix); + if (stix->c->tok.type != STIX_IOTOK_PERIOD) + { + /* check if a period is following the includee name */ + set_syntax_error (stix, STIX_SYNERR_PERIOD, &stix->c->tok.loc, &stix->c->tok.name); + goto oops; + } + + /* switch to theincludee's stream */ stix->c->curinp = arg; /* stix->c->depth.incl++; */ @@ -2135,7 +2222,7 @@ static int compile_method_temporaries (stix_t* stix) * variable-list := identifier* */ - if (!is_token_binsel(stix, VOCA_VBAR)) + if (!is_token_binary_selector(stix, VOCA_VBAR)) { /* return without doing anything if | is not found. * this is not an error condition */ @@ -2163,7 +2250,7 @@ static int compile_method_temporaries (stix_t* stix) GET_TOKEN (stix); } - if (!is_token_binsel(stix, VOCA_VBAR)) + if (!is_token_binary_selector(stix, VOCA_VBAR)) { set_syntax_error (stix, STIX_SYNERR_VBAR, &stix->c->tok.loc, &stix->c->tok.name); return -1; @@ -2181,7 +2268,7 @@ static int compile_method_primitive (stix_t* stix) stix_ooi_t prim_no; const stix_uch_t* ptr, * end; - if (!is_token_binsel(stix, VOCA_LT)) + if (!is_token_binary_selector(stix, VOCA_LT)) { /* return if < is not seen. it is not an error condition */ return 0; @@ -2224,7 +2311,7 @@ static int compile_method_primitive (stix_t* stix) stix->c->mth.prim_no = prim_no; GET_TOKEN (stix); - if (!is_token_binsel(stix, VOCA_GT)) + if (!is_token_binary_selector(stix, VOCA_GT)) { set_syntax_error (stix, STIX_SYNERR_GT, &stix->c->tok.loc, &stix->c->tok.name); return -1; @@ -2234,12 +2321,23 @@ 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, var_info_t* var) +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) { stix_ssize_t index; STIX_MEMSET (var, 0, STIX_SIZEOF(*var)); + if (name_dotted) + { + /* if a name is dotted, + * + * self.XXX - instance variable + * A.B.C - namespace or pool dictionary related reference. + */ +printf ("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"); + return -1; + } + index = find_temporary_variable (stix, name); if (index >= 0) { @@ -2330,7 +2428,7 @@ static int compile_block_temporaries (stix_t* stix) * variable-list := identifier* */ - if (!is_token_binsel(stix, VOCA_VBAR)) + if (!is_token_binary_selector(stix, VOCA_VBAR)) { /* return without doing anything if | is not found. * this is not an error condition */ @@ -2357,7 +2455,7 @@ static int compile_block_temporaries (stix_t* stix) GET_TOKEN (stix); } - if (!is_token_binsel(stix, VOCA_VBAR)) + if (!is_token_binary_selector(stix, VOCA_VBAR)) { set_syntax_error (stix, STIX_SYNERR_VBAR, &stix->c->tok.loc, &stix->c->tok.name); return -1; @@ -2446,7 +2544,7 @@ static int compile_block_expression (stix_t* stix) } while (stix->c->tok.type == STIX_IOTOK_COLON); - if (!is_token_binsel(stix, VOCA_VBAR)) + if (!is_token_binary_selector(stix, VOCA_VBAR)) { set_syntax_error (stix, STIX_SYNERR_VBAR, &stix->c->tok.loc, &stix->c->tok.name); return -1; @@ -2711,6 +2809,7 @@ printf ("LARGE NOT IMPLEMENTED IN COMPILE_ARRAY_LITERAL\n"); break; case STIX_IOTOK_IDENT: + case STIX_IOTOK_IDENT_DOTTED: case STIX_IOTOK_BINSEL: case STIX_IOTOK_KEYWORD: case STIX_IOTOK_SYMLIT: @@ -2813,7 +2912,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* to_super) +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) { /* * expression-primary := identifier | literal | block-constructor | ( "(" method-expression ")" ) @@ -2830,7 +2929,7 @@ static int compile_expression_primary (stix_t* stix, const stix_ucs_t* ident, co /* the caller has read the identifier and the next word */ handle_ident: - if (get_variable_info(stix, ident, ident_loc, &var) <= -1) return -1; + if (get_variable_info(stix, ident, ident_loc, ident_dotted, &var) <= -1) return -1; switch (var.type) { @@ -2899,6 +2998,7 @@ printf ("\tpush object %d\n", (int)index); { switch (stix->c->tok.type) { + case STIX_IOTOK_IDENT_DOTTED: case STIX_IOTOK_IDENT: ident = &stix->c->tok.name; ident_loc = &stix->c->tok.loc; @@ -3091,7 +3191,7 @@ static int compile_binary_message (stix_t* stix, int to_super) GET_TOKEN (stix); - if (compile_expression_primary(stix, STIX_NULL, STIX_NULL, &to_super2) <= -1) goto oops; + if (compile_expression_primary(stix, STIX_NULL, STIX_NULL, 0, &to_super2) <= -1) goto oops; if (stix->c->tok.type == STIX_IOTOK_IDENT && compile_unary_message(stix, to_super2) <= -1) goto oops; @@ -3141,7 +3241,7 @@ static int compile_keyword_message (stix_t* stix, int to_super) GET_TOKEN (stix); - if (compile_expression_primary(stix, STIX_NULL, STIX_NULL, &to_super2) <= -1) goto oops; + if (compile_expression_primary(stix, STIX_NULL, STIX_NULL, 0, &to_super2) <= -1) goto oops; if (stix->c->tok.type == STIX_IOTOK_IDENT && compile_unary_message(stix, to_super2) <= -1) goto oops; if (stix->c->tok.type == STIX_IOTOK_BINSEL && compile_binary_message(stix, to_super2) <= -1) goto oops; @@ -3293,14 +3393,14 @@ done: return 0; } -static int compile_basic_expression (stix_t* stix, const stix_ucs_t* ident, const stix_ioloc_t* ident_loc) +static int compile_basic_expression (stix_t* stix, const stix_ucs_t* ident, const stix_ioloc_t* ident_loc, int ident_dotted) { /* * basic-expression := expression-primary message-expression? */ int to_super; - if (compile_expression_primary(stix, ident, ident_loc, &to_super) <= -1) return -1; + if (compile_expression_primary(stix, ident, ident_loc, ident_dotted, &to_super) <= -1) return -1; if (stix->c->tok.type != STIX_IOTOK_EOF && stix->c->tok.type != STIX_IOTOK_RBRACE && stix->c->tok.type != STIX_IOTOK_PERIOD && @@ -3326,10 +3426,12 @@ static int compile_method_expression (stix_t* stix, int pop) STIX_ASSERT (pop == 0 || pop == 1); STIX_MEMSET (&assignee, 0, STIX_SIZEOF(assignee)); - if (stix->c->tok.type == STIX_IOTOK_IDENT) + if (stix->c->tok.type == STIX_IOTOK_IDENT || + stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED) { stix_ioloc_t assignee_loc; stix_size_t assignee_offset; + int assignee_dotted; /* store the assignee name to the internal buffer * to make it valid after the token buffer has been overwritten */ @@ -3338,6 +3440,7 @@ static int compile_method_expression (stix_t* stix, int pop) if (clone_assignee(stix, &assignee, &assignee_offset) <= -1) return -1; assignee_loc = stix->c->tok.loc; + assignee_dotted = (stix->c->tok.type == STIX_IOTOK_IDENT_DOTTED); GET_TOKEN (stix); if (stix->c->tok.type == STIX_IOTOK_ASSIGN) @@ -3361,7 +3464,7 @@ printf ("\n"); * assignee to update the actual pointer after the recursive * compile_method_expression() call */ assignee.ptr = &stix->c->mth.assignees.ptr[assignee_offset]; - if (get_variable_info(stix, &assignee, &assignee_loc, &var) <= -1) goto oops; + if (get_variable_info(stix, &assignee, &assignee_loc, assignee_dotted, &var) <= -1) goto oops; switch (var.type) { @@ -3427,14 +3530,17 @@ printf ("\t%s_into_object %d\n", (pop? "pop":"store"), (int)index); } else { + /* what is held in assignee is not an assignee any more. + * potentially it is a variable or object reference + * to be pused on to the stack */ assignee.ptr = &stix->c->mth.assignees.ptr[assignee_offset]; - if (compile_basic_expression(stix, &assignee, &assignee_loc) <= -1) goto oops; + if (compile_basic_expression(stix, &assignee, &assignee_loc, assignee_dotted) <= -1) goto oops; } } else { assignee.len = 0; - if (compile_basic_expression(stix, STIX_NULL, STIX_NULL) <= -1) goto oops; + if (compile_basic_expression(stix, STIX_NULL, STIX_NULL, 0) <= -1) goto oops; } stix->c->mth.assignees.len -= assignee.len; @@ -4207,6 +4313,66 @@ static int compile_class_definition (stix_t* stix, int extend) return n; } +static int compile_namespace (stix_t* stix) +{ + /* the name sapce path must not contain any space between segments + * #namespace Abc.Def .Hij + * Abc.Def comprises a valid name space. a period before Hij acts + * as a terminator for the namespace declaration. Hij itself causes + * a syntax error */ + + stix_iotok_t seg_tok; + + if (stix->c->tok.type != STIX_IOTOK_IDENT) + { + set_syntax_error (stix, STIX_SYNERR_IDENT, &stix->c->tok.loc, &stix->c->tok.name); + return -1; + } + + seg_tok = stix->c->tok; + +/*clone_nameseg_segment ().*/ + + GET_TOKEN (stix); + while (stix->c->tok.type == STIX_IOTOK_PERIOD) + { + GET_TOKEN (stix); + if (stix->c->tok.type != STIX_IOTOK_IDENT) goto ok; + + if (stix->c->tok.loc.line == seg_tok.loc.line && + stix->c->tok.loc.colm == seg_tok.loc.colm + seg_tok.name.len + 1) + { + stix_oop_association_t ass; + + ass = stix_lookupsysdic (stix, &seg_tok.name); + if (ass == STIX_NULL || STIX_CLASSOF(stix, ass->value) != stix->_namespace) + { + /* unknown name space */ + /*set_syntax_error (stix, STIX_SYNERR_UNKNOW*/ + return -1; + } + + seg_tok = stix->c->tok; + GET_TOKEN (stix); + } + else + { + goto ok; + } + } + + set_syntax_error (stix, STIX_SYNERR_PERIOD, &stix->c->tok.loc, &stix->c->tok.name); + return -1; + +ok: +/* + name = stix_makesymbol (stix, seg_tok.name); + ns = stix_instantiate (stix, stix->_namespace, XXXXXXXXXXX); + stix_putatdic (stix, dic, name, ns); +*/ + return 0; +} + static int compile_stream (stix_t* stix) { GET_CHAR (stix); @@ -4237,6 +4403,13 @@ static int compile_stream (stix_t* stix) GET_TOKEN (stix); if (compile_class_definition(stix, 1) <= -1) return -1; } + else if (is_token_symbol(stix, VOCA_NAMESPACE)) + { + /* #namespace Planet + * #namespace Planet.Earth */ + GET_TOKEN (stix); + if (compile_namespace(stix) <= -1) return -1; + } #if 0 else if (is_token_symbol(stix, VOCA_MAIN)) { diff --git a/stix/lib/gc.c b/stix/lib/gc.c index ae0db1c..36ba9b5 100644 --- a/stix/lib/gc.c +++ b/stix/lib/gc.c @@ -278,6 +278,7 @@ void stix_gc (stix_t* stix) stix->_symbol = stix_moveoop (stix, stix->_symbol); stix->_symbol_set = stix_moveoop (stix, stix->_symbol_set); stix->_system_dictionary = stix_moveoop (stix, stix->_system_dictionary); + stix->_namespace = stix_moveoop (stix, stix->_namespace); stix->_method_dictionary = stix_moveoop (stix, stix->_method_dictionary); stix->_method = stix_moveoop (stix, stix->_method); stix->_association = stix_moveoop (stix, stix->_association); diff --git a/stix/lib/ignite.c b/stix/lib/ignite.c index fca4c5b..97d7906 100644 --- a/stix/lib/ignite.c +++ b/stix/lib/ignite.c @@ -126,12 +126,13 @@ static int ignite_1 (stix_t* stix) stix->_symbol_set = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP)); stix->_system_dictionary = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP)); + stix->_namespace = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP)); stix->_method_dictionary = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_SET_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP)); stix->_method = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_METHOD_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP)); stix->_association = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_ASSOCIATION_NAMED_INSTVARS, 0, STIX_OBJ_TYPE_OOP)); stix->_method_context = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CONTEXT_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP)); - stix->_block_context = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CONTEXT_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP)); + stix->_block_context = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(STIX_CONTEXT_NAMED_INSTVARS, 1, STIX_OBJ_TYPE_OOP)); stix->_true_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP)); stix->_false_class = alloc_kernel_class (stix, 0, STIX_CLASS_SPEC_MAKE(0, 0, STIX_OBJ_TYPE_OOP)); /* TOOD: what is a proper spec for Character and SmallInteger? @@ -144,15 +145,13 @@ static int ignite_1 (stix_t* stix) !stix->_object || !stix->_string || !stix->_symbol || !stix->_array || - !stix->_byte_array || !stix->_symbol_set || - !stix->_system_dictionary || + !stix->_byte_array || !stix->_symbol_set || !stix->_system_dictionary || - !stix->_method_dictionary || !stix->_method || - !stix->_association || !stix->_method_context || - !stix->_block_context || + !stix->_namespace || !stix->_method_dictionary || + !stix->_method || !stix->_association || !stix->_method_context || - !stix->_true_class || !stix->_false_class || - !stix->_character || !stix->_small_integer) return -1; + !stix->_block_context || !stix->_true_class || + !stix->_false_class || !stix->_character || !stix->_small_integer) return -1; STIX_OBJ_SET_CLASS (stix->_nil, stix->_nil_object); return 0; @@ -214,12 +213,13 @@ static int ignite_3 (stix_t* stix) { 9, { 'S','y','m','b','o','l','S','e','t' } }, { 16, { 'S','y','s','t','e','m','D','i','c','t','i','o','n','a','r','y' } }, + { 9, { 'N','a','m','e','s','p','a','c','e' } }, { 16, { 'M','e','t','h','o','d','D','i','c','t','i','o','n','a','r','y' } }, { 14, { 'C','o','m','p','i','l','e','d','M','e','t','h','o','d' } }, { 11, { 'A','s','s','o','c','i','a','t','i','o','n' } }, { 13, { 'M','e','t','h','o','d','C','o','n','t','e','x','t' } }, - { 12, { 'B','l','o','c','k','C','o','n','t','e','x','t' } }, + { 12, { 'B','l','o','c','k','C','o','n','t','e','x','t' } }, { 4, { 'T','r','u','e' } }, { 5, { 'F','a','l','s','e' } }, { 9, { 'C','h','a','r','a','c','t','e','r' } }, diff --git a/stix/lib/stix-prv.h b/stix/lib/stix-prv.h index 681031a..7c714a9 100644 --- a/stix/lib/stix-prv.h +++ b/stix/lib/stix-prv.h @@ -255,6 +255,7 @@ struct stix_iotok_t STIX_IOTOK_FALSE, STIX_IOTOK_THIS_CONTEXT, STIX_IOTOK_IDENT, + STIX_IOTOK_IDENT_DOTTED, STIX_IOTOK_BINSEL, STIX_IOTOK_KEYWORD, STIX_IOTOK_PRIMITIVE, diff --git a/stix/lib/stix.h b/stix/lib/stix.h index 2ec64a5..e9afc46 100644 --- a/stix/lib/stix.h +++ b/stix/lib/stix.h @@ -774,12 +774,13 @@ struct stix_t stix_oop_t _symbol_set; /* SymbolSet */ stix_oop_t _system_dictionary; /* SystemDictionary */ + stix_oop_t _namespace; /* Namespace */ stix_oop_t _method_dictionary; /* MethodDictionary */ stix_oop_t _method; /* CompiledMethod */ stix_oop_t _association; /* Association */ stix_oop_t _method_context; /* MethodContext */ - stix_oop_t _block_context; /* BlockContext */ + stix_oop_t _block_context; /* BlockContext */ stix_oop_t _true_class; /* True */ stix_oop_t _false_class; /* False */ stix_oop_t _character; /* Character */ diff --git a/stix/lib/test-005.st b/stix/lib/test-005.st index 9eadade..80da876 100644 --- a/stix/lib/test-005.st +++ b/stix/lib/test-005.st @@ -1,5 +1,5 @@ -#include 'Stix.st' +#include 'Stix.st'. ################################################################# ## MAIN @@ -33,6 +33,7 @@ #dcl(#classinst) t1 t2. } + #class MyObject(TestObject) { #dcl(#class) C B A. @@ -51,12 +52,14 @@ ^false } - #method yyy: aBlock { | a | a := aBlock value. ^a + 99. + + + ##a := Stix.MyCOM.HashTable new. } #method xxx: aBlock