From bb3b6c4270adc6ad6661bb70ea3cfd413eead093 Mon Sep 17 00:00:00 2001 From: "hyunghwan.chung" Date: Wed, 27 May 2015 17:16:50 +0000 Subject: [PATCH] added more compiler code --- stix/lib/comp.c | 653 +++++++++++++++++++++++++------------------- stix/lib/main.c | 2 - stix/lib/stix-prv.h | 61 +++-- stix/lib/stix.h | 3 + 4 files changed, 407 insertions(+), 312 deletions(-) diff --git a/stix/lib/comp.c b/stix/lib/comp.c index 7804b56..b6292e7 100644 --- a/stix/lib/comp.c +++ b/stix/lib/comp.c @@ -52,16 +52,31 @@ typedef enum stix_stack_operand_t stix_stack_operand_t; enum class_mod_t { - CLASS_INDEXED = (1 << 0), - CLASS_EXTEND = (1 << 1) + CLASS_INDEXED = (1 << 0), + CLASS_EXTENDED = (1 << 1) }; -enum dcl_mod_t +enum mth_mod_t { - DCL_CLASS = (1 << 0), - DCL_CLASSINST = (1 << 1) + MTH_CLASS = (1 << 0) }; +enum var_type_t +{ + VAR_INSTANCE, + VAR_CLASS, + VAR_CLASSINST +}; +typedef enum var_type_t var_type_t; + +struct var_info_t +{ + var_type_t type; + stix_size_t pos; + stix_oop_class_t cls; /* useful if type is VAR_CLASS. note STIX_NULL indicates the self class. */ +}; +typedef struct var_info_t var_info_t; + static struct ksym_t { stix_oow_t len; @@ -74,11 +89,10 @@ static struct ksym_t { 3, { 'd','c','l' } }, { 7, { 'd','e','c','l','a','r','e' } }, { 5, { 'f','a','l','s','e' } }, - { 3, { 'f','u','n' } }, - { 8, { 'f','u','n','c','t','i','o','n' } }, { 7, { 'i','n','c','l','u','d','e' } }, - { 8, { 'i','n','s','t','a','n','c','e' } }, { 4, { 'm','a','i','n' } }, + { 6, { 'm','e','t','h','o','d' } }, + { 3, { 'm','t','h' } }, { 3, { 'n','i','l' } }, { 7, { 'p','o','i','n','t','e','r' } }, { 10, { 'p','r','i','m','i','t','i','v','e',':' } }, @@ -101,11 +115,10 @@ enum ksym_id_t KSYM_DCL, KSYM_DECLARE, KSYM_FALSE, - KSYM_FUN, - KSYM_FUNCTION, KSYM_INCLUDE, - KSYM_INSTANCE, KSYM_MAIN, + KSYM_METHOD, + KSYM_MTH, KSYM_NIL, KSYM_POINTER, KSYM_PRIMITIVE_COLON, @@ -215,7 +228,7 @@ static STIX_INLINE int does_token_name_match (stix_t* stix, ksym_id_t id) stix_equalchars(stix->c->tok.name.ptr, ksyms[id].str, ksyms[id].len); } -static STIX_INLINE int is_token_ksym (stix_t* stix, ksym_id_t id) +static STIX_INLINE int is_token_symbol (stix_t* stix, ksym_id_t id) { return stix->c->tok.type == STIX_IOTOK_SYMLIT && does_token_name_match(stix, id); } @@ -1804,133 +1817,193 @@ static int parse_unary_message (stix_t* fsc, int is_super) static STIX_INLINE int set_class_name (stix_t* stix, const stix_ucs_t* name) { - return copy_string_to (stix, name, &stix->c->_class.name, &stix->c->_class.name_capa, 0, '\0'); + return copy_string_to (stix, name, &stix->c->cls.name, &stix->c->cls.name_capa, 0, '\0'); } static STIX_INLINE int set_superclass_name (stix_t* stix, const stix_ucs_t* name) { - return copy_string_to (stix, name, &stix->c->_class.supername, &stix->c->_class.supername_capa, 0, '\0'); + return copy_string_to (stix, name, &stix->c->cls.supername, &stix->c->cls.supername_capa, 0, '\0'); } -static STIX_INLINE int append_class_level_variable (stix_t* stix, int index, const stix_ucs_t* name) +static STIX_INLINE int append_class_level_variable (stix_t* stix, var_type_t index, const stix_ucs_t* name) { int n; - n = copy_string_to (stix, name, &stix->c->_class.vars[index], &stix->c->_class.vars_capa[index], 1, ' '); + n = copy_string_to (stix, name, &stix->c->cls.vars[index], &stix->c->cls.vars_capa[index], 1, ' '); if (n >= 0) { - stix->c->_class.var_count[index]++; + stix->c->cls.var_count[index]++; /* TODO: check if it exceeds STIX_MAX_NAMED_INSTVARS, STIX_MAX_CLASSVARS, STIX_MAX_CLASSINSTVARS */ } return n; } -static stix_ssize_t find_class_level_variable (stix_t* stix, int index, 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) { - /* this function is called when the compiler compiles a new class - * definition. so the current class object being compile doesn't - * exsist in the system dictionary (except the partially defined kernel - * objects). - */ stix_ssize_t pos; stix_oop_t super; stix_oop_char_t v; + stix_oop_char_t* vv; stix_ucs_t hs; + int index; -/* TODO: find it in other types of variables */ -/* THIS FUNCTION IS NOT COMPLETE */ - pos = find_word_in_string(&stix->c->_class.vars[index], name); - super = stix->c->_class.super_oop; - if (pos >= 0) goto done; + if (self) + { + STIX_ASSERT (STIX_CLASSOF(stix, self) == stix->_class); + + /* NOTE the loop here assumes the right order of + * instvars + * classvars + * classinstvars + */ + vv = &self->instvars; + for (index = VAR_INSTANCE; index <= VAR_CLASSINST; index++) + { + v = vv[index]; + hs.ptr = v->slot; + hs.len = STIX_OBJ_GET_SIZE(v); + + pos = find_word_in_string(&hs, name); + if (pos >= 0) + { + super = self->superclass; + goto done; + } + } + + super = self->superclass; + } + else + { + /* the class definition is not available yet */ + for (index = VAR_INSTANCE; index <= VAR_CLASSINST; index++) + { + pos = find_word_in_string(&stix->c->cls.vars[index], name); + + if (pos >= 0) + { + super = stix->c->cls.super_oop; + goto done; + } + } + super = stix->c->cls.super_oop; + } while (super != stix->_nil) { STIX_ASSERT (STIX_CLASSOF(stix, super) == stix->_class); - v = ((stix_oop_class_t)super)->instvars; -/* TODO: v = ((stix_oop_class_t)super)->classvars; */ - hs.ptr = v->slot; - hs.len = STIX_OBJ_GET_SIZE(v); + /* NOTE the loop here assumes the right order of + * instvars + * classvars + * classinstvars + */ + vv = &((stix_oop_class_t)super)->instvars; + for (index = VAR_INSTANCE; index <= VAR_CLASSINST; index++) + { + v = vv[index]; + hs.ptr = v->slot; + hs.len = STIX_OBJ_GET_SIZE(v); + + pos = find_word_in_string(&hs, name); + if (pos >= 0) + { + super = ((stix_oop_class_t)super)->superclass; + goto done; + } + } - pos = find_word_in_string(&hs, name); super = ((stix_oop_class_t)super)->superclass; - if (pos >= 0) goto done; } return -1; done: + /* 'self' may be STIX_NULL if STIX_NULL has been given for it. + * the caller must take good care when interpreting the meaning of + * this field */ + var->cls = self; + if (super != stix->_nil) { stix_oow_t spec; STIX_ASSERT (STIX_CLASSOF(stix, super) == stix->_class); - spec = STIX_OOP_TO_SMINT(((stix_oop_class_t)super)->spec); - pos += STIX_CLASS_SPEC_NAMED_INSTVAR(spec); + switch (index) + { + case VAR_INSTANCE: + /* each class has the number of named instance variables + * accumulated for inheritance. the position found in the + * local variable string can be adjusted by adding the + * number in the superclass */ + spec = STIX_OOP_TO_SMINT(((stix_oop_class_t)super)->spec); + pos += STIX_CLASS_SPEC_NAMED_INSTVAR(spec); + break; + + case VAR_CLASS: + /* no adjustment is needed. + * a class object is composed of three parts. + * fixed-part | classinst-variables | class-variabes + * the position returned here doesn't consider + * class instance variables that can be potentially + * placed before the class variables. */ + var->cls = (stix_oop_class_t)super; + break; + + case VAR_CLASSINST: + spec = STIX_OOP_TO_SMINT(((stix_oop_class_t)super)->selfspec); + pos += STIX_CLASS_SELFSPEC_CLASSINSTVAR(spec); + break; + } } + var->type = index; + var->pos = pos; return pos; } -static int append_function_name (stix_t* stix, const stix_ucs_t* name) +static int append_method_name (stix_t* stix, const stix_ucs_t* name) { - /* function name segments are concatenated without any delimiters */ - return copy_string_to (stix, name, &stix->c->fun.name, &stix->c->fun.name_capa, 1, '\0'); + /* method name segments are concatenated without any delimiters */ + return copy_string_to (stix, name, &stix->c->mth.name, &stix->c->mth.name_capa, 1, '\0'); } static int append_temporary (stix_t* stix, const stix_ucs_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->fun.tmprs, &stix->c->fun.tmprs_capa, 1, ' '); + return copy_string_to (stix, name, &stix->c->mth.tmprs, &stix->c->mth.tmprs_capa, 1, ' '); } static STIX_INLINE stix_ssize_t find_temporary (stix_t* stix, const stix_ucs_t* name) { - return find_word_in_string(&stix->c->fun.tmprs, name); + return find_word_in_string(&stix->c->mth.tmprs, name); } static int compile_class_level_variables (stix_t* stix) { - int dcl_mod = 0; - int dcl_index = 0; + var_type_t dcl_type = VAR_INSTANCE; if (stix->c->tok.type == STIX_IOTOK_LPAREN) { - /* variable modifier */ - do - { - GET_TOKEN (stix); + /* process variable modifiers */ + GET_TOKEN (stix); - if (is_token_ksym(stix, KSYM_CLASS)) - { - /* #dcl(#class) */ - dcl_mod &= ~(DCL_CLASS | DCL_CLASSINST); - dcl_mod |= DCL_CLASS; - dcl_index = 1; - } - else if (is_token_ksym(stix, KSYM_CLASSINST)) - { - /* #dcl(#classinst) */ - dcl_mod &= ~(DCL_CLASS | DCL_CLASSINST); - dcl_mod |= DCL_CLASSINST; - dcl_index = 2; - } - else if (is_token_ksym(stix, KSYM_INSTANCE)) - { - /* #dcl(#instance) */ - dcl_mod &= ~(DCL_CLASS | DCL_CLASSINST); - dcl_index = 0; - } - else - { - break; - } + if (is_token_symbol(stix, KSYM_CLASS)) + { + /* #dcl(#class) */ + dcl_type = VAR_CLASS; + GET_TOKEN (stix); + } + else if (is_token_symbol(stix, KSYM_CLASSINST)) + { + /* #dcl(#classinst) */ + dcl_type = VAR_CLASSINST; + GET_TOKEN (stix); } - while (1); if (stix->c->tok.type != STIX_IOTOK_RPAREN) { @@ -1945,18 +2018,48 @@ static int compile_class_level_variables (stix_t* stix) { if (stix->c->tok.type == STIX_IOTOK_IDENT) { - if (find_class_level_variable(stix, dcl_index, &stix->c->tok.name) >= 0) + var_info_t var; + + if (find_class_level_variable(stix, STIX_NULL, &stix->c->tok.name, &var) >= 0) { +printf ("duplicate variable name type %d pos %lu\n", var.type, var.pos); set_syntax_error (stix, STIX_SYNERR_VARNAMEDUP, &stix->c->tok.loc, &stix->c->tok.name); return -1; } - if (append_class_level_variable(stix, dcl_index, &stix->c->tok.name) <= -1) return -1; - /* TODO - if (stix->c->_class->self_oop => is kernel object, and - check the number of instance variable??? class variable??/ class instance variable ? - */ + if (stix->c->cls.self_oop) + { + stix_oow_t spec, limit; + + /* it is an internally defined kernel class object */ + switch (dcl_type) + { + case VAR_INSTANCE: + spec = STIX_OOP_TO_SMINT(stix->c->cls.self_oop->spec); + limit = STIX_CLASS_SPEC_NAMED_INSTVAR(spec); + break; + + case VAR_CLASS: + spec = STIX_OOP_TO_SMINT(stix->c->cls.self_oop->selfspec); + limit = STIX_CLASS_SELFSPEC_CLASSVAR(spec); + break; + + case VAR_CLASSINST: + spec = STIX_OOP_TO_SMINT(stix->c->cls.self_oop->selfspec); + limit = STIX_CLASS_SELFSPEC_CLASSINSTVAR(spec); + break; + } + + if (stix->c->cls.var_count[dcl_type] >= limit) + { +/* THIS IS NOT QUITE RIGHT... Do differetn calculation.... */ +printf ("TOO MANY XXXXXXXXXXXXXXXXXXXXXXXXX duplicate variable name type %d pos %lu\n", var.type, var.pos); + return -1; + } + } + + if (append_class_level_variable(stix, dcl_type, &stix->c->tok.name) <= -1) return -1; } else { @@ -1977,22 +2080,22 @@ static int compile_class_level_variables (stix_t* stix) return 0; } -static int compile_unary_function_name (stix_t* stix) +static int compile_unary_method_name (stix_t* stix) { - STIX_ASSERT (stix->c->fun.name.len == 0); - STIX_ASSERT (stix->c->fun.tmpr_nargs == 0); + STIX_ASSERT (stix->c->mth.name.len == 0); + STIX_ASSERT (stix->c->mth.tmpr_nargs == 0); - if (append_function_name (stix, &stix->c->tok.name) <= -1) return -1; + if (append_method_name (stix, &stix->c->tok.name) <= -1) return -1; GET_TOKEN (stix); return 0; } -static int compile_binary_function_name (stix_t* stix) +static int compile_binary_method_name (stix_t* stix) { - STIX_ASSERT (stix->c->fun.name.len == 0); - STIX_ASSERT (stix->c->fun.tmpr_nargs == 0); + STIX_ASSERT (stix->c->mth.name.len == 0); + STIX_ASSERT (stix->c->mth.tmpr_nargs == 0); - if (append_function_name (stix, &stix->c->tok.name) <= -1) return -1; + if (append_method_name (stix, &stix->c->tok.name) <= -1) return -1; GET_TOKEN (stix); /* collect the argument name */ @@ -2003,26 +2106,26 @@ static int compile_binary_function_name (stix_t* stix) return -1; } - STIX_ASSERT (stix->c->fun.tmpr_nargs == 0); + STIX_ASSERT (stix->c->mth.tmpr_nargs == 0); /* no duplication check is performed against instance variable names or * class variable names. a duplcate name will shade a previsouly defined * variable. */ if (append_temporary(stix, &stix->c->tok.name) <= -1) return -1; - stix->c->fun.tmpr_nargs++; + stix->c->mth.tmpr_nargs++; GET_TOKEN (stix); return 0; } -static int compile_keyword_function_name (stix_t* stix) +static int compile_keyword_method_name (stix_t* stix) { - STIX_ASSERT (stix->c->fun.name.len == 0); - STIX_ASSERT (stix->c->fun.tmpr_nargs == 0); + STIX_ASSERT (stix->c->mth.name.len == 0); + STIX_ASSERT (stix->c->mth.tmpr_nargs == 0); do { - if (append_function_name(stix, &stix->c->tok.name) <= -1) return -1; + if (append_method_name(stix, &stix->c->tok.name) <= -1) return -1; GET_TOKEN (stix); if (stix->c->tok.type != STIX_IOTOK_IDENT) @@ -2039,7 +2142,7 @@ static int compile_keyword_function_name (stix_t* stix) } if (append_temporary(stix, &stix->c->tok.name) <= -1) return -1; - stix->c->fun.tmpr_nargs++; + stix->c->mth.tmpr_nargs++; GET_TOKEN (stix); } @@ -2048,37 +2151,37 @@ static int compile_keyword_function_name (stix_t* stix) return 0; } -static int compile_function_name (stix_t* stix) +static int compile_method_name (stix_t* stix) { /* - * function-name := unary-function-name | binary-function-name | keyword-function-name - * unary-function-name := unary-selector - * binary-function-name := binary-selector selector-argument - * keyword-function-name := (keyword selector-argument)+ + * method-name := unary-method-name | binary-method-name | keyword-method-name + * unary-method-name := unary-selector + * binary-method-name := binary-selector selector-argument + * keyword-method-name := (keyword selector-argument)+ * selector-argument := identifier * unary-selector := identifier */ int n; - STIX_ASSERT (stix->c->fun.tmpr_count == 0); + STIX_ASSERT (stix->c->mth.tmpr_count == 0); switch (stix->c->tok.type) { case STIX_IOTOK_IDENT: - n = compile_unary_function_name(stix); + n = compile_unary_method_name(stix); break; case STIX_IOTOK_BINSEL: - n = compile_binary_function_name(stix); + n = compile_binary_method_name(stix); break; case STIX_IOTOK_KEYWORD: - n = compile_keyword_function_name(stix); + n = compile_keyword_method_name(stix); break; default: - /* illegal function name */ - set_syntax_error (stix, STIX_SYNERR_FUNNAME, &stix->c->tok.loc, &stix->c->tok.name); + /* illegal method name */ + set_syntax_error (stix, STIX_SYNERR_MTHNAME, &stix->c->tok.loc, &stix->c->tok.name); n = -1; } @@ -2090,14 +2193,14 @@ static int compile_function_name (stix_t* stix) /* the total number of temporaries is equal to the number of * arguments after having processed the message pattern. it's because * stix treats arguments the same as temporaries */ - stix->c->fun.tmpr_count = stix->c->fun.tmpr_nargs; + stix->c->mth.tmpr_count = stix->c->mth.tmpr_nargs; return n; } -static int compile_class_function_temporaries (stix_t* stix) +static int compile_class_method_temporaries (stix_t* stix) { /* - * function-temporaries := "|" variable-list "|" + * method-temporaries := "|" variable-list "|" * variable-list := identifier* */ @@ -2118,7 +2221,7 @@ static int compile_class_function_temporaries (stix_t* stix) } if (append_temporary(stix, &stix->c->tok.name) <= -1) return -1; - stix->c->fun.tmpr_count++; + stix->c->mth.tmpr_count++; GET_TOKEN (stix); } @@ -2133,10 +2236,10 @@ static int compile_class_function_temporaries (stix_t* stix) return 0; } -static int compile_class_function_primitive (stix_t* stix) +static int compile_class_method_primitive (stix_t* stix) { /* - * function-primitive := "<" "primitive:" integer ">" + * method-primitive := "<" "primitive:" integer ">" */ if (!is_token_binsel(stix, KSYM_LT)) @@ -2171,7 +2274,7 @@ static int compile_class_function_primitive (stix_t* stix) return -1; } - STIX_STRTOI (stix->c->fun.prim_no, stix->tok.name.buffer, STIX_NULL, 10); + STIX_STRTOI (stix->c->mth.prim_no, stix->tok.name.buffer, STIX_NULL, 10); if (prim_no < 0 || prim_no > 0xFF) { stix->errnum = STIX_FSC_ERROR_PRIMITIVE_NUMBER_RANGE; @@ -2192,11 +2295,11 @@ static int compile_class_function_primitive (stix_t* stix) return 0; } -static int compile_class_function_expression (stix_t* stix) +static int compile_class_method_expression (stix_t* stix) { /* - * function-expression := assignment-expression | basic-expression - * assignment-expression := identifier ":=" function-expression + * method-expression := assignment-expression | basic-expression + * assignment-expression := identifier ":=" method-expression * basic-expression := expression-primary (message cascaded-message)? */ @@ -2242,32 +2345,32 @@ static int compile_class_function_expression (stix_t* stix) return -1; } -static int compile_class_function_statement (stix_t* stix) +static int compile_class_method_statement (stix_t* stix) { if (stix->c->tok.type == STIX_IOTOK_RETURN) { GET_TOKEN (stix); - if (compile_class_function_expression(stix) <= -1) return -1; + if (compile_class_method_expression(stix) <= -1) return -1; #if 0 EMIT_RETURN_FROM_MESSAGE (stix); #endif } else { - if (compile_class_function_expression(stix) <= -1) return -1; + if (compile_class_method_expression(stix) <= -1) return -1; } return 0; } -static int compile_class_function_statements (stix_t* stix) +static int compile_class_method_statements (stix_t* stix) { /* - * function-statements := function-statement ("." | ("." function-statements))* - * function-statement := function-return | function-expression - * function-return := "^" function-expression - * function-expression := ... + * method-statements := method-statement ("." | ("." method-statements))* + * method-statement := method-return | method-expression + * method-return := "^" method-expression + * method-expression := ... */ if (stix->c->tok.type != STIX_IOTOK_EOF && @@ -2275,7 +2378,7 @@ static int compile_class_function_statements (stix_t* stix) { do { - if (compile_class_function_statement(stix) <= -1) return -1; + if (compile_class_method_statement(stix) <= -1) return -1; if (stix->c->tok.type == STIX_IOTOK_PERIOD) { @@ -2298,16 +2401,39 @@ static int compile_class_function_statements (stix_t* stix) return 0; } -static int compile_class_function (stix_t* stix) +static int compile_class_method (stix_t* stix) { /* clear data required to compile a method */ - stix->c->fun.name.len = 0; - stix->c->fun.tmprs.len = 0; - stix->c->fun.tmpr_count = 0; - stix->c->fun.tmpr_nargs = 0; - stix->c->fun.code.len = 0; + stix->c->mth.flags = 0; + stix->c->mth.name.len = 0; + stix->c->mth.tmprs.len = 0; + stix->c->mth.tmpr_count = 0; + stix->c->mth.tmpr_nargs = 0; + stix->c->mth.code.len = 0; - if (compile_function_name(stix) <= -1) return -1; + if (stix->c->tok.type == STIX_IOTOK_LPAREN) + { + /* process method modifiers */ + GET_TOKEN (stix); + + if (is_token_symbol(stix, KSYM_CLASS)) + { + /* #method(#class) */ + stix->c->mth.flags |= MTH_CLASS; + GET_TOKEN (stix); + } + + if (stix->c->tok.type != STIX_IOTOK_RPAREN) + { + /* ) expected */ + set_syntax_error (stix, STIX_SYNERR_RPAREN, &stix->c->tok.loc, &stix->c->tok.name); + return -1; + } + + GET_TOKEN (stix); + } + + if (compile_method_name(stix) <= -1) return -1; if (stix->c->tok.type != STIX_IOTOK_LBRACE) { @@ -2318,10 +2444,9 @@ static int compile_class_function (stix_t* stix) GET_TOKEN (stix); - - if (compile_class_function_temporaries(stix) <= -1 || - compile_class_function_primitive(stix) <= -1 || - compile_class_function_statements(stix) <= -1 /*|| + if (compile_class_method_temporaries(stix) <= -1 || + compile_class_method_primitive(stix) <= -1 || + compile_class_method_statements(stix) <= -1 /*|| finish_method(stix) <= -1*/) return -1; if (stix->c->tok.type != STIX_IOTOK_RBRACE) @@ -2344,26 +2469,26 @@ static int make_defined_class (stix_t* stix) int just_made = 0; - spec = STIX_CLASS_SPEC_MAKE (stix->c->_class.var_count[0], - ((stix->c->_class.flags & CLASS_INDEXED)? 1: 0), - stix->c->_class.indexed_type); - self_spec = STIX_CLASS_SELFSPEC_MAKE(stix->c->_class.var_count[1], stix->c->_class.var_count[2]); + spec = STIX_CLASS_SPEC_MAKE (stix->c->cls.var_count[0], + ((stix->c->cls.flags & CLASS_INDEXED)? 1: 0), + stix->c->cls.indexed_type); + self_spec = STIX_CLASS_SELFSPEC_MAKE(stix->c->cls.var_count[1], stix->c->cls.var_count[2]); -print_ucs (&stix->c->_class.name); -printf (" instvars %d classvars %d classinstvars %d\n", (int)stix->c->_class.var_count[0], (int)stix->c->_class.var_count[1], (int)stix->c->_class.var_count[2]); +print_ucs (&stix->c->cls.name); +printf (" instvars %d classvars %d classinstvars %d\n", (int)stix->c->cls.var_count[0], (int)stix->c->cls.var_count[1], (int)stix->c->cls.var_count[2]); - if (stix->c->_class.self_oop) + if (stix->c->cls.self_oop) { - STIX_ASSERT (STIX_CLASSOF(stix, stix->c->_class.self_oop) == stix->_class); - STIX_ASSERT (STIX_OBJ_GET_FLAGS_KERNEL (stix->c->_class.self_oop) == 1); + STIX_ASSERT (STIX_CLASSOF(stix, stix->c->cls.self_oop) == stix->_class); + STIX_ASSERT (STIX_OBJ_GET_FLAGS_KERNEL (stix->c->cls.self_oop) == 1); - if (spec != STIX_OOP_TO_SMINT(stix->c->_class.self_oop->spec) || - self_spec != STIX_OOP_TO_SMINT(stix->c->_class.self_oop->selfspec)) + if (spec != STIX_OOP_TO_SMINT(stix->c->cls.self_oop->spec) || + self_spec != STIX_OOP_TO_SMINT(stix->c->cls.self_oop->selfspec)) { /* it conflicts with internal defintion */ printf (" DDDDDDDDDD CONFLICTING CLASS DEFINITION DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD %lu %lu %lu %lu\n", (unsigned long)spec, (unsigned long)self_spec, - (unsigned long)STIX_OOP_TO_SMINT(stix->c->_class.self_oop->spec), (unsigned long)STIX_OOP_TO_SMINT(stix->c->_class.self_oop->selfspec) + (unsigned long)STIX_OOP_TO_SMINT(stix->c->cls.self_oop->spec), (unsigned long)STIX_OOP_TO_SMINT(stix->c->cls.self_oop->selfspec) ); /* TODO: set syntax error */ return -1; @@ -2374,42 +2499,42 @@ printf (" DDDDDDDDDD CONFLICTING CLASS DEFINITION DDDDDDDDDDDDDDDDDDDDDDDDDDDDDD /* the class variables and class instance variables are placed * inside the class object after the fixed part. */ tmp = stix_instantiate (stix, stix->_class, STIX_NULL, - stix->c->_class.var_count[1] + stix->c->_class.var_count[2]); + stix->c->cls.var_count[1] + stix->c->cls.var_count[2]); if (!tmp) return -1; just_made = 1; - stix->c->_class.self_oop = (stix_oop_class_t)tmp; + stix->c->cls.self_oop = (stix_oop_class_t)tmp; - STIX_ASSERT (STIX_CLASSOF(stix, stix->c->_class.self_oop) == stix->_class); + STIX_ASSERT (STIX_CLASSOF(stix, stix->c->cls.self_oop) == stix->_class); - stix->c->_class.self_oop->spec = STIX_OOP_FROM_SMINT(spec); - stix->c->_class.self_oop->selfspec = STIX_OOP_FROM_SMINT(self_spec); + stix->c->cls.self_oop->spec = STIX_OOP_FROM_SMINT(spec); + stix->c->cls.self_oop->selfspec = STIX_OOP_FROM_SMINT(self_spec); } - STIX_OBJ_SET_FLAGS_KERNEL (stix->c->_class.self_oop, 2); + STIX_OBJ_SET_FLAGS_KERNEL (stix->c->cls.self_oop, 2); - tmp = stix_makesymbol(stix, stix->c->_class.name.ptr, stix->c->_class.name.len); + tmp = stix_makesymbol(stix, stix->c->cls.name.ptr, stix->c->cls.name.len); if (!tmp) return -1; - stix->c->_class.self_oop->name = (stix_oop_char_t)tmp; + stix->c->cls.self_oop->name = (stix_oop_char_t)tmp; - tmp = stix_makestring(stix, stix->c->_class.vars[0].ptr, stix->c->_class.vars[0].len); + tmp = stix_makestring(stix, stix->c->cls.vars[0].ptr, stix->c->cls.vars[0].len); if (!tmp) return -1; - stix->c->_class.self_oop->instvars = (stix_oop_char_t)tmp; + stix->c->cls.self_oop->instvars = (stix_oop_char_t)tmp; - tmp = stix_makestring(stix, stix->c->_class.vars[1].ptr, stix->c->_class.vars[1].len); + tmp = stix_makestring(stix, stix->c->cls.vars[1].ptr, stix->c->cls.vars[1].len); if (!tmp) return -1; - stix->c->_class.self_oop->classvars = (stix_oop_char_t)tmp; + stix->c->cls.self_oop->classvars = (stix_oop_char_t)tmp; - tmp = stix_makestring(stix, stix->c->_class.vars[2].ptr, stix->c->_class.vars[2].len); + tmp = stix_makestring(stix, stix->c->cls.vars[2].ptr, stix->c->cls.vars[2].len); if (!tmp) return -1; - stix->c->_class.self_oop->classinstvars = (stix_oop_char_t)tmp; + stix->c->cls.self_oop->classinstvars = (stix_oop_char_t)tmp; -/* TODO: initialize more fields??? method_dictionary. function dictionary */ +/* TODO: initialize more fields??? method_dictionary. */ if (just_made) { /* register the class to the system dictionary */ - if (!stix_putatsysdic(stix, (stix_oop_t)stix->c->_class.self_oop->name, (stix_oop_t)stix->c->_class.self_oop)) return -1; + if (!stix_putatsysdic(stix, (stix_oop_t)stix->c->cls.self_oop->name, (stix_oop_t)stix->c->cls.self_oop)) return -1; } return 0; @@ -2419,16 +2544,16 @@ static int __compile_class_definition (stix_t* stix) { /* * class-definition := #class class-modifier? "{" class-body "}" - * class-modifier := "(" (#byte | #character | #word | #pointer)* ")" - * class-body := (variable-definition | function-definition)* + * class-modifier := "(" (#byte | #character | #word | #pointer)? ")" + * class-body := variable-definition* method-definition* * * variable-definition := (#dcl | #declare) variable-modifier? variable-list "." - * variable-modifier := "(" (#class | #classinst | #instance)* ")" + * variable-modifier := "(" (#class | #classinst)? ")" * variable-list := identifier* * - * function-definition := (#fun | #function) function-modifier? function-actual-definition - * function-modifier := "(" (#class | #instance) ")" - * function-actual-definition := function-name "{" function-tempraries? function-primitive? function-statements* "}" + * method-definition := (#mth | #method) method-modifier? method-actual-definition + * method-modifier := "(" (#class | #instance)? ")" + * method-actual-definition := method-name "{" method-tempraries? method-primitive? method-statements* "}" */ stix_ioloc_t class_name_loc; stix_oop_association_t ass; @@ -2437,52 +2562,36 @@ static int __compile_class_definition (stix_t* stix) { /* process class modifiers */ - do + GET_TOKEN (stix); + + if (is_token_symbol(stix, KSYM_BYTE)) { - int this_flag = 0; - + /* #class(#byte) */ + stix->c->cls.flags |= CLASS_INDEXED; + stix->c->cls.indexed_type = STIX_OBJ_TYPE_BYTE; GET_TOKEN (stix); - -/* TODO: should i check if #byte, #character, #word, #pointer have already been specified? */ - if (is_token_ksym(stix, KSYM_BYTE)) - { - /* #class(#byte) */ - this_flag = CLASS_INDEXED; - stix->c->_class.indexed_type = STIX_OBJ_TYPE_BYTE; - } - else if (is_token_ksym(stix, KSYM_CHARACTER)) - { - /* #class(#character) */ - this_flag = CLASS_INDEXED; - stix->c->_class.indexed_type = STIX_OBJ_TYPE_CHAR; - } - else if (is_token_ksym(stix, KSYM_WORD)) - { - /* #class(#word) */ - this_flag = CLASS_INDEXED; - stix->c->_class.indexed_type = STIX_OBJ_TYPE_WORD; - } - else if (is_token_ksym(stix, KSYM_POINTER)) - { - /* #class(#pointer) */ - this_flag = CLASS_INDEXED; - stix->c->_class.indexed_type = STIX_OBJ_TYPE_OOP; - } - /* place other modifiers here */ - else - { - break; - } - - STIX_ASSERT (this_flag != 0); - if (stix->c->_class.flags & this_flag) - { - set_syntax_error (stix, STIX_SYNERR_CLASSMODDUP, &stix->c->tok.loc, &stix->c->tok.name); - return -1; - } - stix->c->_class.flags |= this_flag; - } - while (1); + } + else if (is_token_symbol(stix, KSYM_CHARACTER)) + { + /* #class(#character) */ + stix->c->cls.flags |= CLASS_INDEXED; + stix->c->cls.indexed_type = STIX_OBJ_TYPE_CHAR; + GET_TOKEN (stix); + } + else if (is_token_symbol(stix, KSYM_WORD)) + { + /* #class(#word) */ + stix->c->cls.flags |= CLASS_INDEXED; + stix->c->cls.indexed_type = STIX_OBJ_TYPE_WORD; + GET_TOKEN (stix); + } + else if (is_token_symbol(stix, KSYM_POINTER)) + { + /* #class(#pointer) */ + stix->c->cls.flags |= CLASS_INDEXED; + stix->c->cls.indexed_type = STIX_OBJ_TYPE_OOP; + GET_TOKEN (stix); + } if (stix->c->tok.type != STIX_IOTOK_RPAREN) { @@ -2510,9 +2619,9 @@ static int __compile_class_definition (stix_t* stix) printf ("DEFININING..\n"); { int i; -for (i = 0; i < stix->c->_class.name.len; i++) +for (i = 0; i < stix->c->cls.name.len; i++) { -printf ("%c", stix->c->_class.name.ptr[i]); +printf ("%c", stix->c->cls.name.ptr[i]); } printf ("\n"); } @@ -2549,10 +2658,7 @@ printf ("\n"); GET_TOKEN (stix); -printf ("FINDING......................["); print_ucs (&stix->c->_class.name); printf ("]\n"); -dump_system_dictionary(stix); - ass = (stix_oop_association_t)stix_lookupsysdic(stix, &stix->c->_class.name); -printf ("FINDING dONE.........................\n"); + ass = (stix_oop_association_t)stix_lookupsysdic(stix, &stix->c->cls.name); if (ass) { if (STIX_CLASSOF(stix, ass->value) != stix->_class || @@ -2561,33 +2667,33 @@ printf ("FINDING dONE.........................\n"); /* the object found with the name is not a class object * or the the class object found is a fully defined kernel * class object */ - set_syntax_error (stix, STIX_SYNERR_CLASSDUP, &class_name_loc, &stix->c->_class.name); + set_syntax_error (stix, STIX_SYNERR_CLASSDUP, &class_name_loc, &stix->c->cls.name); return -1; } - stix->c->_class.self_oop = (stix_oop_class_t)ass->value; + stix->c->cls.self_oop = (stix_oop_class_t)ass->value; } else { /* no class of such a name is found. it's a new definition, * which is normal for most new classes. */ - STIX_ASSERT (stix->c->_class.self_oop == STIX_NULL); + STIX_ASSERT (stix->c->cls.self_oop == STIX_NULL); } if (super_is_nil) { - stix->c->_class.super_oop = stix->_nil; + stix->c->cls.super_oop = stix->_nil; } else { - ass = (stix_oop_association_t)stix_lookupsysdic(stix, &stix->c->_class.supername); + ass = (stix_oop_association_t)stix_lookupsysdic(stix, &stix->c->cls.supername); if (ass && STIX_CLASSOF(stix, ass->value) == stix->_class && STIX_OBJ_GET_FLAGS_KERNEL(ass->value) != 1) { /* the value found must be a class and it must not be * an incomplete internal class object */ - stix->c->_class.super_oop = ass->value; + stix->c->cls.super_oop = ass->value; } else { @@ -2595,7 +2701,7 @@ printf ("FINDING dONE.........................\n"); * the object found with the name is not a class object. or, * the class object found is a internally defined kernel * class object. */ - set_syntax_error (stix, STIX_SYNERR_CLASSUNDEF, &superclass_name_loc, &stix->c->_class.supername); + set_syntax_error (stix, STIX_SYNERR_CLASSUNDEF, &superclass_name_loc, &stix->c->cls.supername); return -1; } } @@ -2603,7 +2709,7 @@ printf ("FINDING dONE.........................\n"); else { /* extending class */ - if (stix->c->_class.flags != 0) + if (stix->c->cls.flags != 0) { /* the class definition specified with modifiers cannot extend * an existing class. the superclass must be specified enclosed @@ -2613,26 +2719,26 @@ printf ("FINDING dONE.........................\n"); return -1; } - stix->c->_class.flags |= CLASS_EXTEND; + stix->c->cls.flags |= CLASS_EXTENDED; - ass = (stix_oop_association_t)stix_lookupsysdic(stix, &stix->c->_class.name); + ass = (stix_oop_association_t)stix_lookupsysdic(stix, &stix->c->cls.name); if (ass && STIX_CLASSOF(stix, ass->value) != stix->_class && STIX_OBJ_GET_FLAGS_KERNEL(ass->value) != 1) { - stix->c->_class.self_oop = (stix_oop_class_t)ass->value; + stix->c->cls.self_oop = (stix_oop_class_t)ass->value; } else { /* only an existing class can be extended. */ - set_syntax_error (stix, STIX_SYNERR_CLASSUNDEF, &class_name_loc, &stix->c->_class.name); + set_syntax_error (stix, STIX_SYNERR_CLASSUNDEF, &class_name_loc, &stix->c->cls.name); return -1; } - stix->c->_class.super_oop = stix->c->_class.self_oop->superclass; + stix->c->cls.super_oop = stix->c->cls.self_oop->superclass; - STIX_ASSERT ((stix_oop_t)stix->c->_class.super_oop == stix->_nil || - STIX_CLASSOF(stix, stix->c->_class.super_oop) == stix->_class); + STIX_ASSERT ((stix_oop_t)stix->c->cls.super_oop == stix->_nil || + STIX_CLASSOF(stix, stix->c->cls.super_oop) == stix->_class); } if (stix->c->tok.type != STIX_IOTOK_LBRACE) @@ -2641,39 +2747,26 @@ printf ("FINDING dONE.........................\n"); return -1; } - if (stix->c->_class.super_oop != stix->_nil) + if (stix->c->cls.super_oop != stix->_nil) { /* adjust the instance variable count and the class instance variable * count to include that of a superclass */ stix_oop_class_t c; stix_oow_t spec, self_spec; - c = (stix_oop_class_t)stix->c->_class.super_oop; + c = (stix_oop_class_t)stix->c->cls.super_oop; spec = STIX_OOP_TO_SMINT(c->spec); self_spec = STIX_OOP_TO_SMINT(c->selfspec); - stix->c->_class.var_count[0] = STIX_CLASS_SPEC_NAMED_INSTVAR(spec); - stix->c->_class.var_count[2] = STIX_CLASS_SELFSPEC_CLASSINSTVAR(self_spec); + stix->c->cls.var_count[0] = STIX_CLASS_SPEC_NAMED_INSTVAR(spec); + stix->c->cls.var_count[2] = STIX_CLASS_SELFSPEC_CLASSINSTVAR(self_spec); } GET_TOKEN (stix); - while (is_token_ksym(stix, KSYM_DCL) || is_token_ksym(stix, KSYM_DECLARE)) + if (stix->c->cls.flags & CLASS_EXTENDED) { - if (stix->c->_class.flags & CLASS_EXTEND) - { - /* you cannot specify variables when extending a class */ - set_syntax_error (stix, STIX_SYNERR_DCLBANNED, &stix->c->tok.loc, STIX_NULL); - return -1; - } - - /* variable definition. #dcl or #declare */ - GET_TOKEN (stix); - if (compile_class_level_variables(stix) <= -1) return -1; - } - - if (stix->c->_class.flags & CLASS_EXTEND) - { - if (is_token_ksym(stix, KSYM_DCL) || is_token_ksym(stix, KSYM_DECLARE)) + /* when a class is extended, a new variable cannot be added */ + if (is_token_symbol(stix, KSYM_DCL) || is_token_symbol(stix, KSYM_DECLARE)) { set_syntax_error (stix, STIX_SYNERR_DCLBANNED, &stix->c->tok.loc, &stix->c->tok.name); return -1; @@ -2682,7 +2775,7 @@ printf ("FINDING dONE.........................\n"); else { /* a new class including an internally defined class object */ - while (is_token_ksym(stix, KSYM_DCL) || is_token_ksym(stix, KSYM_DECLARE)) + while (is_token_symbol(stix, KSYM_DCL) || is_token_symbol(stix, KSYM_DECLARE)) { /* variable definition. #dcl or #declare */ GET_TOKEN (stix); @@ -2692,11 +2785,11 @@ printf ("FINDING dONE.........................\n"); if (make_defined_class(stix) <= -1) return -1; } - while (is_token_ksym(stix, KSYM_FUN) || is_token_ksym(stix, KSYM_FUNCTION)) + while (is_token_symbol(stix, KSYM_MTH) || is_token_symbol(stix, KSYM_METHOD)) { - /* function definition. #fun or #function */ + /* method definition. #mth or #method */ GET_TOKEN (stix); - if (compile_class_function(stix) <= -1) return -1; + if (compile_class_method(stix) <= -1) return -1; } if (stix->c->tok.type != STIX_IOTOK_RBRACE) @@ -2715,21 +2808,21 @@ static int compile_class_definition (stix_t* stix) stix_size_t i; /* reset the structure to hold information about a class to be compiled */ - stix->c->_class.flags = 0; - stix->c->_class.name.len = 0; - stix->c->_class.supername.len = 0; - for (i = 0; i < STIX_COUNTOF(stix->c->_class.var_count); i++) - stix->c->_class.var_count[i] = 0; + stix->c->cls.flags = 0; + stix->c->cls.name.len = 0; + stix->c->cls.supername.len = 0; + for (i = 0; i < STIX_COUNTOF(stix->c->cls.var_count); i++) + stix->c->cls.var_count[i] = 0; - stix->c->_class.self_oop = STIX_NULL; - stix->c->_class.super_oop = STIX_NULL; + stix->c->cls.self_oop = STIX_NULL; + stix->c->cls.super_oop = STIX_NULL; /* do main compilation work */ n = __compile_class_definition (stix); /* reset these oops not to confuse gc_compiler() */ - stix->c->_class.self_oop = STIX_NULL; - stix->c->_class.super_oop = STIX_NULL; + stix->c->cls.self_oop = STIX_NULL; + stix->c->cls.super_oop = STIX_NULL; return n; } @@ -2741,7 +2834,7 @@ static int compile_stream (stix_t* stix) while (stix->c->tok.type != STIX_IOTOK_EOF) { - if (is_token_ksym(stix, KSYM_INCLUDE)) + if (is_token_symbol(stix, KSYM_INCLUDE)) { /* #include 'xxxx' */ GET_TOKEN (stix); @@ -2752,14 +2845,14 @@ static int compile_stream (stix_t* stix) } if (begin_include(stix) <= -1) return -1; } - else if (is_token_ksym(stix, KSYM_CLASS)) + else if (is_token_symbol(stix, KSYM_CLASS)) { /* #class Selfclass(Superclass) { } */ GET_TOKEN (stix); if (compile_class_definition(stix) <= -1) return -1; } #if 0 - else if (is_token_ksym(stix, KSYM_MAIN)) + else if (is_token_symbol(stix, KSYM_MAIN)) { /* #main */ /* TODO: implement this */ @@ -2782,11 +2875,11 @@ static void gc_compiler (stix_t* stix) /* called when garbage collection is performed */ if (stix->c) { - if (stix->c->_class.self_oop) - stix->c->_class.self_oop = (stix_oop_class_t)stix_moveoop (stix, (stix_oop_t)stix->c->_class.self_oop); + if (stix->c->cls.self_oop) + stix->c->cls.self_oop = (stix_oop_class_t)stix_moveoop (stix, (stix_oop_t)stix->c->cls.self_oop); - if (stix->c->_class.super_oop) - stix->c->_class.super_oop = stix_moveoop (stix, stix->c->_class.super_oop); + if (stix->c->cls.super_oop) + stix->c->cls.super_oop = stix_moveoop (stix, stix->c->cls.super_oop); } } @@ -2801,17 +2894,17 @@ static void fini_compiler (stix_t* stix) if (stix->c->tok.name.ptr) stix_freemem (stix, stix->c->tok.name.ptr); - if (stix->c->_class.name.ptr) stix_freemem (stix, stix->c->_class.name.ptr); - if (stix->c->_class.supername.ptr) stix_freemem (stix, stix->c->_class.supername.ptr); + if (stix->c->cls.name.ptr) stix_freemem (stix, stix->c->cls.name.ptr); + if (stix->c->cls.supername.ptr) stix_freemem (stix, stix->c->cls.supername.ptr); - for (i = 0; i < STIX_COUNTOF(stix->c->_class.vars); i++) + for (i = 0; i < STIX_COUNTOF(stix->c->cls.vars); i++) { - if (stix->c->_class.vars[i].ptr) stix_freemem (stix, stix->c->_class.vars[i].ptr); + if (stix->c->cls.vars[i].ptr) stix_freemem (stix, stix->c->cls.vars[i].ptr); } - if (stix->c->fun.tmprs.ptr) stix_freemem (stix, stix->c->fun.tmprs.ptr); - if (stix->c->fun.name.ptr) stix_freemem (stix, stix->c->fun.name.ptr); - if (stix->c->fun.code.ptr) stix_freemem (stix, stix->c->fun.code.ptr); + if (stix->c->mth.tmprs.ptr) stix_freemem (stix, stix->c->mth.tmprs.ptr); + if (stix->c->mth.name.ptr) stix_freemem (stix, stix->c->mth.name.ptr); + if (stix->c->mth.code.ptr) stix_freemem (stix, stix->c->mth.code.ptr); stix_freemem (stix, stix->c); stix->c = STIX_NULL; diff --git a/stix/lib/main.c b/stix/lib/main.c index e066ca7..44ed2bd 100644 --- a/stix/lib/main.c +++ b/stix/lib/main.c @@ -232,8 +232,6 @@ static char* syntax_error_msg[] = "integer expected", "primitive: expected", "wrong directive", - "wrong class modifier", - "duplicate class modifier", "undefined class", "duplicate class", "#dcl not allowed", diff --git a/stix/lib/stix-prv.h b/stix/lib/stix-prv.h index cdc601f..1712977 100644 --- a/stix/lib/stix-prv.h +++ b/stix/lib/stix-prv.h @@ -259,33 +259,31 @@ typedef struct stix_iotok_t stix_iotok_t; enum stix_synerrnum_t { STIX_SYNERR_NOERR, - STIX_SYNERR_ILCHR, /* illegal character */ - STIX_SYNERR_CMTNC, /* comment not closed */ - STIX_SYNERR_STRNC, /* string not closed */ - STIX_SYNERR_CLTNT, /* character literal not terminated */ - STIX_SYNERR_HLTNT, /* hased literal not terminated */ - STIX_SYNERR_CLNMS, /* colon missing */ - STIX_SYNERR_STRING, /* string expected */ - STIX_SYNERR_LBRACE, /* { expected */ - STIX_SYNERR_RBRACE, /* } expected */ - STIX_SYNERR_LPAREN, /* ( expected */ - STIX_SYNERR_RPAREN, /* ) expected */ - STIX_SYNERR_PERIOD, /* . expected */ - STIX_SYNERR_VBAR, /* | expected */ - STIX_SYNERR_GT, /* > expected */ - STIX_SYNERR_IDENT, /* identifier expected */ - STIX_SYNERR_INTEGER, /* integer expected */ - STIX_SYNERR_PRIMITIVE, /* primitive: expected */ - STIX_SYNERR_DIRECTIVE, /* wrong directive */ - STIX_SYNERR_CLASSMOD, /* wrong class modifier */ - STIX_SYNERR_CLASSMODDUP, /* duplicate class modifier */ - STIX_SYNERR_CLASSUNDEF, /* undefined class */ - STIX_SYNERR_CLASSDUP, /* duplicate class */ - STIX_SYNERR_DCLBANNED, /* #dcl not allowed */ - STIX_SYNERR_FUNNAME, /* wrong function name */ - STIX_SYNERR_ARGNAMEDUP, /* duplicate argument name */ - STIX_SYNERR_TMPRNAMEDUP, /* duplicate temporary variable name */ - STIX_SYNERR_VARNAMEDUP /* duplicate variable name */ + STIX_SYNERR_ILCHR, /* illegal character */ + STIX_SYNERR_CMTNC, /* comment not closed */ + STIX_SYNERR_STRNC, /* string not closed */ + STIX_SYNERR_CLTNT, /* character literal not terminated */ + STIX_SYNERR_HLTNT, /* hased literal not terminated */ + STIX_SYNERR_CLNMS, /* colon missing */ + STIX_SYNERR_STRING, /* string expected */ + STIX_SYNERR_LBRACE, /* { expected */ + STIX_SYNERR_RBRACE, /* } expected */ + STIX_SYNERR_LPAREN, /* ( expected */ + STIX_SYNERR_RPAREN, /* ) expected */ + STIX_SYNERR_PERIOD, /* . expected */ + STIX_SYNERR_VBAR, /* | expected */ + STIX_SYNERR_GT, /* > expected */ + STIX_SYNERR_IDENT, /* identifier expected */ + STIX_SYNERR_INTEGER, /* integer expected */ + STIX_SYNERR_PRIMITIVE, /* primitive: expected */ + STIX_SYNERR_DIRECTIVE, /* wrong directive */ + STIX_SYNERR_CLASSUNDEF, /* undefined class */ + STIX_SYNERR_CLASSDUP, /* duplicate class */ + STIX_SYNERR_DCLBANNED, /* #dcl not allowed */ + STIX_SYNERR_MTHNAME, /* wrong function name */ + STIX_SYNERR_ARGNAMEDUP, /* duplicate argument name */ + STIX_SYNERR_TMPRNAMEDUP, /* duplicate temporary variable name */ + STIX_SYNERR_VARNAMEDUP /* duplicate variable name */ }; typedef enum stix_synerrnum_t stix_synerrnum_t; @@ -526,9 +524,12 @@ struct stix_compiler_t stix_ucs_t vars[3]; stix_size_t vars_capa[3]; - /* var_count, unlike vars above, includes superclass counts as well.*/ + /* var_count, unlike vars above, includes superclass counts as well. + * var_count[0] - number of named instance variables + * var_count[1] - number of class variables + * var_count[2] - number of class instance variables */ stix_size_t var_count[3]; - } _class; + } cls; /* information about a function being comipled */ struct @@ -552,7 +553,7 @@ struct stix_compiler_t stix_code_t code; stix_size_t code_capa; - } fun; + } mth; }; #endif diff --git a/stix/lib/stix.h b/stix/lib/stix.h index 8fccfd2..f6a59e7 100644 --- a/stix/lib/stix.h +++ b/stix/lib/stix.h @@ -503,9 +503,12 @@ struct stix_class_t stix_oop_t subclasses; /* Array of subclasses */ stix_oop_char_t name; /* Symbol */ + + /* == NEVER CHANGE THIS ORDER OF 3 ITEMS BELOW == */ stix_oop_char_t instvars; /* String */ stix_oop_char_t classvars; /* String */ stix_oop_char_t classinstvars; /* String */ + /* == NEVER CHANGE THE ORDER OF 3 ITEMS ABOVE == */ stix_oop_oop_t instfuns; /* instance methods, MethodDictionary */ stix_oop_oop_t classfuns; /* class methods, MethodDictionary */