js: simple member function ok

diff --git a/examples/js.html b/examples/js.html
index 01bf1c534dfa0a27cb4bb6da71ca44cfdc8bf819..8716472fddf6f6674495ade368f22ab67a94377b 100644 (file)
--- a/examples/js.html
+++ b/examples/js.html
@@ -9,13 +9,12 @@
 <script>
 var a = {
        x: 1.1,
-       p: [
-               {y: 2.2, z: 3.3},
-               {y: 4.4, z: 5.5}
-       ],
+       f: function () {
+               document.write(a.x);
+       }
 };
 
-document.write(a.x + a.p[1].z);
+a.f();
 </script>
 
 </body>

diff --git a/js/core/scf_ast.c b/js/core/scf_ast.c
index 2e815bb4d7c20e2743038fbc07caa39a9ea31db8..e3fd536811067bc618cb717e3a624320dec3c8ca 100644 (file)
--- a/js/core/scf_ast.c
+++ b/js/core/scf_ast.c
@@ -482,3 +482,98 @@ int scf_ast_add_const_var(scf_ast_t* ast, scf_node_t* parent, int type, const ui
 
        return 0;
 }
+
+int scf_function_signature(scf_ast_t* ast, scf_function_t* f)
+{
+       scf_string_t* s;
+       scf_type_t*   t = (scf_type_t*)f->node.parent;
+
+       int ret;
+       int i;
+
+       s = scf_string_alloc();
+       if (!s)
+               return -ENOMEM;
+
+       if (t->node.type >= SCF_STRUCT) {
+               assert(t->node.class_flag);
+
+               ret = scf_string_cat(s, t->name);
+               if (ret < 0)
+                       goto error;
+
+               ret = scf_string_cat_cstr(s, "_");
+               if (ret < 0)
+                       goto error;
+       }
+
+       if (f->op_type >= 0) {
+               scf_operator_t* op = scf_find_base_operator_by_type(f->op_type);
+
+               if (!op->signature)
+                       goto error;
+
+               ret = scf_string_cat_cstr(s, op->signature);
+       } else
+               ret = scf_string_cat(s, f->node.w->text);
+
+       if (ret < 0)
+               goto error;
+       scf_logd("f signature: %s\n", s->data);
+
+       if (t->node.type < SCF_STRUCT) {
+               if (f->signature)
+                       scf_string_free(f->signature);
+
+               f->signature = s;
+               return 0;
+       }
+
+       if (f->argv) {
+               for (i = 0; i < f->argv->size; i++) {
+                       scf_variable_t* v   = f->argv->data[i];
+                       scf_type_t*     t_v = NULL;
+
+                       t_v = scf_block_find_type_type((scf_block_t*)t, v->type);
+                       if (!t_v) {
+                               ret = scf_ast_find_global_type_type(&t_v, ast, v->type);
+                               if (ret < 0)
+                                       goto error;
+                       }
+
+                       ret = scf_string_cat_cstr(s, "_");
+                       if (ret < 0)
+                               goto error;
+
+                       scf_logd("t_v: %p, v->type: %d, v->w->text->data: %s\n", t_v, v->type, v->w->text->data);
+
+                       const char* abbrev = scf_type_find_abbrev(t_v->name->data);
+                       if (abbrev)
+                               ret = scf_string_cat_cstr(s, abbrev);
+                       else
+                               ret = scf_string_cat(s, t_v->name);
+                       if (ret < 0)
+                               goto error;
+
+                       if (v->nb_pointers > 0) {
+                               char buf[64];
+                               snprintf(buf, sizeof(buf) - 1, "%d", v->nb_pointers);
+
+                               ret = scf_string_cat_cstr(s, buf);
+                               if (ret < 0)
+                                       goto error;
+                       }
+               }
+       }
+
+       scf_logd("f signature: %s\n", s->data);
+
+       if (f->signature)
+               scf_string_free(f->signature);
+       f->signature = s;
+       return 0;
+
+error:
+       scf_string_free(s);
+       return -1;
+}

diff --git a/js/core/scf_ast.h b/js/core/scf_ast.h
index f05e72e16b7f70fe097a529b6d98326d22719db1..dbd9169bb77ea0ed2fd1dc941c39d7b7d1275472 100644 (file)
--- a/js/core/scf_ast.h
+++ b/js/core/scf_ast.h
@@ -101,6 +101,8 @@ int scf_ast_add_base_type(scf_ast_t* ast, scf_base_type_t* base_type);
 
 int scf_ast_add_file_block(scf_ast_t* ast, const char* path);
 
+int scf_function_signature(scf_ast_t* ast, scf_function_t* f);
+
 int scf_ast_add_const_str(scf_ast_t* ast, scf_node_t* parent, scf_lex_word_t* w);
 int scf_ast_add_const_var(scf_ast_t* ast, scf_node_t* parent, int type, const uint64_t u64);
 

diff --git a/js/core/scf_function.c b/js/core/scf_function.c
index 1b537a45a15a1df6a000766420fb14dff6f64148..4fe5befe569a735b3fa13d8d9407617ca1cf2257 100644 (file)
--- a/js/core/scf_function.c
+++ b/js/core/scf_function.c
@@ -215,89 +215,3 @@ int scf_function_same_type(scf_function_t* f0, scf_function_t* f1)
 
        return scf_function_same_argv(f0->argv, f1->argv);
 }
-
-int scf_function_signature(scf_function_t* f)
-{
-       scf_string_t* s;
-       scf_type_t*   t = (scf_type_t*)f->node.parent;
-
-       int ret;
-       int i;
-
-       s = scf_string_alloc();
-       if (!s)
-               return -ENOMEM;
-
-       if (t->node.type >= SCF_STRUCT) {
-               assert(t->node.class_flag);
-
-               ret = scf_string_cat(s, t->name);
-               if (ret < 0)
-                       goto error;
-
-               ret = scf_string_cat_cstr(s, "_");
-               if (ret < 0)
-                       goto error;
-       }
-
-       if (f->op_type >= 0) {
-               scf_operator_t* op = scf_find_base_operator_by_type(f->op_type);
-
-               if (!op->signature)
-                       goto error;
-
-               ret = scf_string_cat_cstr(s, op->signature);
-       } else
-               ret = scf_string_cat(s, f->node.w->text);
-
-       if (ret < 0)
-               goto error;
-       scf_logd("f signature: %s\n", s->data);
-
-       if (t->node.type < SCF_STRUCT) {
-               if (f->signature)
-                       scf_string_free(f->signature);
-
-               f->signature = s;
-               return 0;
-       }
-
-       if (f->argv) {
-               for (i = 0; i < f->argv->size; i++) {
-                       scf_variable_t* v   = f->argv->data[i];
-                       scf_type_t*     t_v = scf_block_find_type_type((scf_block_t*)t, v->type);
-
-                       ret = scf_string_cat_cstr(s, "_");
-                       if (ret < 0)
-                               goto error;
-
-                       const char* abbrev = scf_type_find_abbrev(t_v->name->data);
-                       if (abbrev)
-                               ret = scf_string_cat_cstr(s, abbrev);
-                       else
-                               ret = scf_string_cat(s, t_v->name);
-                       if (ret < 0)
-                               goto error;
-
-                       if (v->nb_pointers > 0) {
-                               char buf[64];
-                               snprintf(buf, sizeof(buf) - 1, "%d", v->nb_pointers);
-
-                               ret = scf_string_cat_cstr(s, buf);
-                               if (ret < 0)
-                                       goto error;
-                       }
-               }
-       }
-
-       scf_logd("f signature: %s\n", s->data);
-
-       if (f->signature)
-               scf_string_free(f->signature);
-       f->signature = s;
-       return 0;
-
-error:
-       scf_string_free(s);
-       return -1;
-}

diff --git a/js/core/scf_function.h b/js/core/scf_function.h
index 9765f2a410285fa13bcbdbc5145222bc3a8d47c8..26e074a772b10593599d288ed8b4bb4a78733f7c 100644 (file)
--- a/js/core/scf_function.h
+++ b/js/core/scf_function.h
@@ -61,6 +61,7 @@ struct scf_function_s {
        uint32_t          void_flag :1;
        uint32_t          call_flag :1;
        uint32_t          vla_flag  :1;
+       uint32_t          js_flag   :1;
 
        uint32_t          compile_flag:1;
        uint32_t          native_flag :1;
@@ -74,6 +75,4 @@ int             scf_function_same_type(scf_function_t* f0, scf_function_t* f1);
 int             scf_function_same_argv(scf_vector_t* argv0, scf_vector_t* argv1);
 int             scf_function_like_argv(scf_vector_t* argv0, scf_vector_t* argv1);
 
-int             scf_function_signature(scf_function_t* f);
-
 #endif

diff --git a/js/parse/scf_dfa_call.c b/js/parse/scf_dfa_call.c
index ad27a5df2cc3648e5b71db31f26ef9f7bb7f4dd8..2b06842c7acedaa86bc28cd6725d1e53a07692ce 100644 (file)
--- a/js/parse/scf_dfa_call.c
+++ b/js/parse/scf_dfa_call.c
@@ -62,6 +62,7 @@ static int _call_action_lp(scf_dfa_t* dfa, scf_vector_t* words, void* data)
        dfa_identity_t* id = scf_stack_top(d->current_identities);
        if (id && id->identity) {
 
+               scf_logi("parse->ast->current_block: %p, js_type: %d\n", parse->ast->current_block, parse->ast->current_block->node.type);
                int ret = scf_ast_find_function(&f, parse->ast, id->identity->text->data);
                if (ret < 0)
                        return SCF_DFA_ERROR;

diff --git a/js/parse/scf_dfa_expr.c b/js/parse/scf_dfa_expr.c
index 580f6655c3e575a3ae6baa7b2ab7a3f27a9d2d0e..419a28ba442f3c83598d1474aa8cee0b7d69cffc 100644 (file)
--- a/js/parse/scf_dfa_expr.c
+++ b/js/parse/scf_dfa_expr.c
@@ -91,6 +91,12 @@ int _expr_add_var(scf_parse_t* parse, dfa_data_t* d)
        assert(id && id->identity);
        w = id->identity;
 
+       if (!d->expr) {
+               d->expr = scf_expr_alloc();
+               if (!d->expr)
+                       return -ENOMEM;
+       }
+
        if (scf_ast_find_variable(&var, parse->ast, w->text->data) < 0)
                return SCF_DFA_ERROR;
 
@@ -124,6 +130,34 @@ int _expr_add_var(scf_parse_t* parse, dfa_data_t* d)
                scf_logi("md->current_var: %s, var: %s, member_flag: %d, line: %d, pos: %d\n",
                                md->current_var->w->text->data, var->w->text->data, var->member_flag, var->w->line, var->w->pos);
 
+               t = NULL;
+               if (scf_ast_find_type(&t, parse->ast, "Object") < 0)
+                       return SCF_DFA_ERROR;
+
+               v = scf_scope_find_variable(t->scope, "members");
+               if (!v) {
+                       scf_logw("var 'members' not found in struct '%s'\n", t->name->data);
+                       return SCF_DFA_ERROR;
+               }
+
+               node = scf_node_alloc(NULL, v->type, v);
+               if (!node)
+                       return SCF_DFA_ERROR;
+
+               if (scf_expr_add_node(d->expr, node) < 0) {
+                       scf_node_free(node);
+                       return SCF_DFA_ERROR;
+               }
+
+               node = scf_node_alloc(NULL, SCF_OP_ARRAY_INDEX, NULL);
+               if (!node)
+                       return SCF_DFA_ERROR;
+
+               if (scf_expr_add_node(d->expr, node) < 0) {
+                       scf_node_free(node);
+                       return SCF_DFA_ERROR;
+               }
+
                t = scf_block_find_type_type(parse->ast->current_block, SCF_VAR_INTPTR);
                v = SCF_VAR_ALLOC_BY_TYPE(NULL, t, 1, 0, NULL);
                if (!v)
@@ -139,12 +173,6 @@ int _expr_add_var(scf_parse_t* parse, dfa_data_t* d)
        if (!node)
                return -ENOMEM;
 
-       if (!d->expr) {
-               d->expr = scf_expr_alloc();
-               if (!d->expr)
-                       return -ENOMEM;
-       }
-
        scf_logd("d->expr: %p, node: %p\n", d->expr, node);
 
        if (scf_expr_add_node(d->expr, node) < 0) {
@@ -216,7 +244,7 @@ static int _expr_action_number(scf_dfa_t* dfa, scf_vector_t* words, void* data)
                                        return SCF_DFA_ERROR;
                                }
 
-                               if (scf_function_signature(f) < 0)
+                               if (scf_function_signature(parse->ast, f) < 0)
                                        return SCF_DFA_ERROR;
 
                                w->text->data[2] = '\0';
@@ -320,38 +348,11 @@ static int _expr_action_op(scf_dfa_t* dfa, scf_vector_t* words, void* data, int
 
        if (SCF_LEX_WORD_ARROW == w->type || SCF_LEX_WORD_DOT == w->type) {
                if (md->current_var->js_type >= 0) {
-                       t = NULL;
-                       if (scf_ast_find_type(&t, parse->ast, "Object") < 0)
-                               return SCF_DFA_ERROR;
-
-                       v = scf_scope_find_variable(t->scope, "members");
-                       if (!v) {
-                               scf_logw("var 'members' not found in struct '%s'\n", t->name->data);
-                               return SCF_DFA_ERROR;
-                       }
-
-                       node = scf_node_alloc(NULL, v->type, v);
-                       if (!node)
-                               return SCF_DFA_ERROR;
-
-                       if (scf_expr_add_node(d->expr, node) < 0) {
-                               scf_node_free(node);
-                               return SCF_DFA_ERROR;
-                       }
-
-                       node = scf_node_alloc(NULL, SCF_OP_ARRAY_INDEX, NULL);
-                       if (!node)
-                               return SCF_DFA_ERROR;
-
-                       if (scf_expr_add_node(d->expr, node) < 0) {
-                               scf_node_free(node);
-                               return SCF_DFA_ERROR;
-                       }
-
                        t = NULL;
                        if (scf_ast_find_type_type(&t, parse->ast, md->current_var->js_type) < 0)
                                return SCF_DFA_ERROR;
 
+                       scf_loge("t: %p, js_type: %d\n", t, t->type);
                        parse->ast->current_block = (scf_block_t*)t;
                }
        }

diff --git a/js/parse/scf_dfa_function_js.c b/js/parse/scf_dfa_function_js.c
index a32423ddda3cd559e1a0c6376c1b2cea2ca9b69e..ed8c05763cd80b54752654d85308fdb334d231b4 100644 (file)
--- a/js/parse/scf_dfa_function_js.c
+++ b/js/parse/scf_dfa_function_js.c
@@ -36,6 +36,7 @@ int _function_js_add_function(scf_dfa_t* dfa, scf_lex_word_t* w, dfa_data_t* d)
        if (!f)
                return SCF_DFA_ERROR;
        f->member_flag = !!b;
+       f->js_flag     = 1;
 
        scf_logi("function: %s,line:%d, member_flag: %d\n", f->node.w->text->data, f->node.w->line, f->member_flag);
 
@@ -51,6 +52,8 @@ int _function_js_add_function(scf_dfa_t* dfa, scf_lex_word_t* w, dfa_data_t* d)
                return SCF_DFA_ERROR;
        }
 
+       scf_logi("ast->current_block: %p, js_type: %d\n", ast->current_block, ast->current_block->node.type);
+
        scf_scope_push_function(ast->current_block->scope, f);
 
        scf_node_add_child((scf_node_t*)ast->current_block, (scf_node_t*)f);
@@ -130,6 +133,7 @@ static int _function_js_action_lp(scf_dfa_t* dfa, scf_vector_t* words, void* dat
        dfa_data_t*      d     = data;
        dfa_fun_data_t*  fd    = d->module_datas[dfa_module_function_js.index];
        scf_lex_word_t*  w;
+       scf_lex_word_t*  this;
 
        if (words->size < 2)
                return SCF_DFA_ERROR;
@@ -148,6 +152,25 @@ static int _function_js_action_lp(scf_dfa_t* dfa, scf_vector_t* words, void* dat
        d->argc = 0;
        d->nb_lps++;
 
+       if (d->current_function->member_flag) {
+               this = scf_lex_word_alloc(w->file, 0, 0, SCF_LEX_WORD_ID);
+               if (!this)
+                       return SCF_DFA_ERROR;
+
+               this->text = scf_string_cstr("this");
+               if (!this->text) {
+                       scf_lex_word_free(this);
+                       return SCF_DFA_ERROR;
+               }
+
+               int ret = _function_js_add_arg(parse->ast, this, d);
+
+               scf_lex_word_free(this);
+               this = NULL;
+               if (ret < 0)
+                       return SCF_DFA_ERROR;
+       }
+
        return SCF_DFA_NEXT_WORD;
 }
 
@@ -183,15 +206,10 @@ static int _function_js_action_rp(scf_dfa_t* dfa, scf_vector_t* words, void* dat
 
        scf_block_t* b = fd->parent_block;
 
-       if (!b->node.root_flag && !b->node.file_flag) {
-               scf_loge("function_js should be defined in file, global\n");
-               return SCF_DFA_ERROR;
-       }
-
        assert(b->scope);
 
        if (SCF_LEX_WORD_KEY_FUNC != f->node.w->type) {
-               if (f->static_flag)
+               if (f->static_flag || f->member_flag)
                        fprev = scf_scope_find_function(b->scope, f->node.w->text->data);
                else {
                        int ret = scf_ast_find_global_function(&fprev, parse->ast, f->node.w->text->data);
@@ -231,7 +249,11 @@ static int _function_js_action_end(scf_dfa_t* dfa, scf_vector_t* words, void* da
 
        fd->parent_block = NULL;
 
-       d->current_function = NULL;
+       if (d->current_function->member_flag) {
+
+       } else
+               d->current_function = NULL;
+
        d->argc   = 0;
        d->nb_lps = 0;
        d->nb_rps = 0;

diff --git a/js/parse/scf_dfa_init_data.c b/js/parse/scf_dfa_init_data.c
index b0410f35d709a60e8c0359502d055b23f6d3a3c1..88d7ff10af5f64243cd030f98078877e35c48844 100644 (file)
--- a/js/parse/scf_dfa_init_data.c
+++ b/js/parse/scf_dfa_init_data.c
@@ -15,6 +15,9 @@ typedef struct {
        scf_vector_t*    init_exprs;
        scf_stack_t*     init_objs;
 
+       scf_block_t*     parent_block;
+
+       scf_variable_t*  current_var;
        dfa_index_t*     current_index;
        int              current_n;
        int              current_dim;
@@ -61,7 +64,8 @@ static int _do_data_init(scf_ast_t* ast, dfa_data_t* d, scf_variable_t* obj)
        md->nb_lbs      = 0;
        md->nb_rbs      = 0;
 
-       d->current_var = NULL;
+       md->current_var = NULL;
+       d ->current_var = NULL;
        return ret;
 }
 
@@ -268,11 +272,60 @@ static int _data_action_comma(scf_dfa_t* dfa, scf_vector_t* words, void* data)
        return SCF_DFA_SWITCH_TO;
 }
 
+static int _data_action_func(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+{
+       scf_parse_t*        parse = dfa->priv;
+       dfa_data_t*         d     = data;
+       init_module_data_t* md    = d->module_datas[dfa_module_init_data.index];
+
+       d->expr_local_flag = 0;
+
+       SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "init_data_func_end"), SCF_DFA_HOOK_END);
+
+       return SCF_DFA_CONTINUE;
+}
+
+static int _data_action_func_end(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+{
+       scf_parse_t*         parse = dfa->priv;
+       scf_ast_t*           ast   = parse->ast;
+       dfa_data_t*          d     = data;
+       init_module_data_t*  md    = d->module_datas[dfa_module_init_data.index];
+       scf_lex_word_t*      w;
+       scf_variable_t*      obj   = scf_stack_top(md->init_objs);
+       scf_type_t*          t;
+
+       d->expr_local_flag = 1;
+       d->current_var     = md->current_var;
+
+       assert(SCF_VAR_VAR != obj->type);
+
+       int ret = scf_ast_find_type_type(&t, ast, obj->type);
+       if (ret < 0)
+               return ret;
+
+       w = md->current_index[md->current_dim].w;
+       assert(w);
+       md->current_index[md->current_dim].w = NULL;
+
+       scf_logi("add member '%s()' to '%s_%d_%d'\n", w->text->data, obj->w->text->data, obj->w->line, obj->w->pos);
+
+       assert(d->current_function);
+
+       ret = scf_string_copy(d->current_function->node.w->text, w->text);
+       if (ret < 0)
+               return ret;
+
+       d->current_function = NULL;
+       return SCF_DFA_SWITCH_TO;
+}
+
 static int _data_action_entry(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 {
        assert(words->size >= 2);
 
        scf_parse_t*        parse = dfa->priv;
+       scf_ast_t*          ast   = parse->ast;
        dfa_data_t*         d     = data;
        scf_lex_word_t*     w     = words->data[words->size - 2];
        init_module_data_t* md    = d->module_datas[dfa_module_init_data.index];
@@ -300,6 +353,10 @@ static int _data_action_entry(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 
        d->expr_local_flag = 1;
 
+       md->current_var  = d->current_var;
+       md->parent_block = ast->current_block;
+
+       scf_dfa_del_hook_by_name(&(dfa->hooks[SCF_DFA_HOOK_POST]), "var_semicolon");
        return SCF_DFA_CONTINUE;
 }
 
@@ -337,9 +394,11 @@ static int __data_add_obj(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 static int _data_action_lb(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 {
        scf_parse_t*        parse = dfa->priv;
+       scf_ast_t*          ast   = parse->ast;
        dfa_data_t*         d     = data;
        init_module_data_t* md    = d->module_datas[dfa_module_init_data.index];
        scf_variable_t*     obj;
+       scf_type_t*         s;
 
        md->nb_lbs++;
 
@@ -349,7 +408,30 @@ static int _data_action_lb(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 
        obj = scf_stack_top(md->init_objs);
 
-       scf_logi("obj: %p, md->nb_lbs: %d\n", obj, md->nb_lbs);
+       assert(SCF_VAR_VAR == obj->type);
+
+       s = scf_type_alloc(obj->w, obj->w->text->data, SCF_STRUCT + ast->nb_structs, 0);
+       if (!s) {
+               scf_loge("\n");
+               return SCF_DFA_ERROR;
+       }
+
+       s->scope = scf_scope_alloc(obj->w, "class");
+
+       ast->nb_structs++;
+       s->node.class_flag = 1;
+       scf_scope_push_type(md->parent_block->scope, s);
+       scf_node_add_child((scf_node_t*)md->parent_block, (scf_node_t*)s);
+
+       if (ast->current_block == md->parent_block)
+               d->current_var->js_type = s->type;
+
+       ast->current_block = (scf_block_t*)s;
+
+       obj->type    = s->type;
+       obj->js_type = s->type;
+
+       scf_loge("s: %p, js_type: %d, obj: %p, obj->w: %s, md->nb_lbs: %d\n", s, s->type, obj, obj->w->text->data, md->nb_lbs);
 
        SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "init_data_comma"), SCF_DFA_HOOK_POST);
 
@@ -400,6 +482,7 @@ static int _data_action_member(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 static int _data_action_rb(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 {
        scf_parse_t*        parse = dfa->priv;
+       scf_ast_t*          ast   = parse->ast;
        dfa_data_t*         d     = data;
        scf_type_t*         t     = NULL;
        init_module_data_t* md    = d->module_datas[dfa_module_init_data.index];
@@ -421,7 +504,7 @@ static int _data_action_rb(scf_dfa_t* dfa, scf_vector_t* words, void* data)
        md->nb_rbs++;
        md->current_dim--;
 
-       scf_logd("md->current_dim: %d, md->current_n: %d\n", md->current_dim, md->current_n);
+       scf_logi("md->current_dim: %d, md->current_n: %d\n", md->current_dim, md->current_n);
 
        int i;
        for (i = md->current_dim + 1; i < md->current_n; i++) {
@@ -432,48 +515,56 @@ static int _data_action_rb(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 
        obj = scf_stack_pop(md->init_objs);
 
-       int ret = scf_ast_find_type_type(&t, parse->ast, obj->type);
+       int ret = scf_ast_find_type_type(&t, ast, obj->type);
        if (ret < 0)
-               return ret;
+               goto error;
 
-       if (_class_calculate_size(dfa, t) < 0)
-               return SCF_DFA_ERROR;
+       ret = _class_calculate_size(dfa, t);
+       if (ret < 0)
+               goto error;
 
        if (md->nb_rbs == md->nb_lbs) {
                d->expr_local_flag = 0;
 
                scf_logi("----------- type: %d, nb_pointers: %d\n\n", d->current_var->type, d->current_var->nb_pointers);
-#if 0
-               d->current_var->type        = obj->type;
-               d->current_var->size        = obj->size;
-               d->current_var->data_size   = obj->data_size;
-               d->current_var->nb_pointers = obj->nb_pointers;
 
-               if (_do_data_init(dfa, words, d) < 0)
-                       return SCF_DFA_ERROR;
-#else
                d->current_var->js_type = obj->type;
 
-               ret = _do_data_init(parse->ast, d, obj);
+               ast->current_block = md->parent_block;
+               md->parent_block   = NULL;
+
+               ret = _do_data_init(ast, d, obj);
                if (ret < 0)
-                       return ret;
-#endif
+                       goto error;
+
                scf_dfa_del_hook_by_name(&(dfa->hooks[SCF_DFA_HOOK_POST]), "init_data_comma");
        } else {
                w = md->current_index[md->current_dim].w;
                if (w)
-                       ret = _add_struct_member(parse->ast, d, obj);
+                       ret = _add_struct_member(ast, d, obj);
                else
-                       ret = _add_array_member(parse->ast, d, obj);
-               if (ret < 0) {
-                       scf_variable_free(obj);
-                       return ret;
-               }
+                       ret = _add_array_member(ast, d, obj);
+               if (ret < 0)
+                       goto error;
        }
 
        scf_variable_free(obj);
        obj = NULL;
+
+       obj = scf_stack_top(md->init_objs);
+       if (obj) {
+               ret = scf_ast_find_type_type(&t, ast, obj->type);
+               if (ret < 0)
+                       return ret;
+
+               ast->current_block = (scf_block_t*)t;
+       }
+
        return SCF_DFA_NEXT_WORD;
+
+error:
+       scf_variable_free(obj);
+       return ret;
 }
 
 static int _data_action_rs(scf_dfa_t* dfa, scf_vector_t* words, void* data)
@@ -553,17 +644,19 @@ static int _data_action_rs(scf_dfa_t* dfa, scf_vector_t* words, void* data)
 
 static int _dfa_init_module_init_data(scf_dfa_t* dfa)
 {
-       SCF_DFA_MODULE_NODE(dfa, init_data, entry,  _data_is_entry,            _data_action_entry);
-       SCF_DFA_MODULE_NODE(dfa, init_data, member, scf_dfa_is_identity,       _data_action_member);
+       SCF_DFA_MODULE_NODE(dfa, init_data, entry,    _data_is_entry,       _data_action_entry);
+       SCF_DFA_MODULE_NODE(dfa, init_data, member,   scf_dfa_is_identity,  _data_action_member);
 
-       SCF_DFA_MODULE_NODE(dfa, init_data, colon,  scf_dfa_is_colon,          scf_dfa_action_next);
-       SCF_DFA_MODULE_NODE(dfa, init_data, comma,  scf_dfa_is_comma,          _data_action_comma);
+       SCF_DFA_MODULE_NODE(dfa, init_data, colon,    scf_dfa_is_colon,     scf_dfa_action_next);
+       SCF_DFA_MODULE_NODE(dfa, init_data, comma,    scf_dfa_is_comma,     _data_action_comma);
+       SCF_DFA_MODULE_NODE(dfa, init_data, func,     scf_dfa_is_func,      _data_action_func);
+       SCF_DFA_MODULE_NODE(dfa, init_data, func_end, scf_dfa_is_entry,     _data_action_func_end);
 
-       SCF_DFA_MODULE_NODE(dfa, init_data, lb,     scf_dfa_is_lb,             _data_action_lb);
-       SCF_DFA_MODULE_NODE(dfa, init_data, rb,     scf_dfa_is_rb,             _data_action_rb);
+       SCF_DFA_MODULE_NODE(dfa, init_data, lb,       scf_dfa_is_lb,        _data_action_lb);
+       SCF_DFA_MODULE_NODE(dfa, init_data, rb,       scf_dfa_is_rb,        _data_action_rb);
 
-       SCF_DFA_MODULE_NODE(dfa, init_data, ls,     scf_dfa_is_ls,             _data_action_ls);
-       SCF_DFA_MODULE_NODE(dfa, init_data, rs,     scf_dfa_is_rs,             _data_action_rs);
+       SCF_DFA_MODULE_NODE(dfa, init_data, ls,       scf_dfa_is_ls,        _data_action_ls);
+       SCF_DFA_MODULE_NODE(dfa, init_data, rs,       scf_dfa_is_rs,        _data_action_rs);
 
        scf_parse_t*        parse = dfa->priv;
        dfa_data_t*         d     = parse->dfa_data;
@@ -582,18 +675,21 @@ static int _dfa_init_module_init_data(scf_dfa_t* dfa)
 
 static int _dfa_init_syntax_init_data(scf_dfa_t* dfa)
 {
-       SCF_DFA_GET_MODULE_NODE(dfa, init_data, entry,  entry);
-       SCF_DFA_GET_MODULE_NODE(dfa, init_data, comma,  comma);
-       SCF_DFA_GET_MODULE_NODE(dfa, init_data, colon,  colon);
-       SCF_DFA_GET_MODULE_NODE(dfa, init_data, member, member);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   entry,     entry);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   comma,     comma);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   colon,     colon);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   member,    member);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   func,      func);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   func_end,  func_end);
 
-       SCF_DFA_GET_MODULE_NODE(dfa, init_data, lb,     lb);
-       SCF_DFA_GET_MODULE_NODE(dfa, init_data, rb,     rb);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   lb,        lb);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   rb,        rb);
 
-       SCF_DFA_GET_MODULE_NODE(dfa, init_data, ls,     ls);
-       SCF_DFA_GET_MODULE_NODE(dfa, init_data, rs,     rs);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   ls,        ls);
+       SCF_DFA_GET_MODULE_NODE(dfa, init_data,   rs,        rs);
 
-       SCF_DFA_GET_MODULE_NODE(dfa, expr,      entry,  expr);
+       SCF_DFA_GET_MODULE_NODE(dfa, function_js, func,      func_js);
+       SCF_DFA_GET_MODULE_NODE(dfa, expr,        entry,     expr);
 
        // empty init, use 0 to fill the data
        scf_dfa_node_add_child(entry,     lb);
@@ -617,9 +713,15 @@ static int _dfa_init_syntax_init_data(scf_dfa_t* dfa)
        // init member of object
        scf_dfa_node_add_child(lb,        member);
        scf_dfa_node_add_child(member,    colon);
+
+       // init member function()
+       scf_dfa_node_add_child(colon,     func);
+       scf_dfa_node_add_child(func,      func_js);
+       scf_dfa_node_add_child(func_end,  member);
+       scf_dfa_node_add_child(func_end,  rb);
+
        scf_dfa_node_add_child(colon,     expr);
        scf_dfa_node_add_child(expr,      comma);
-
        scf_dfa_node_add_child(comma,     member);
        scf_dfa_node_add_child(colon,     lb);
        scf_dfa_node_add_child(expr,      rb);

diff --git a/js/parse/scf_parse.c b/js/parse/scf_parse.c
index 01f76ecbbd7a024a191193ae353def874d83f21e..a56cef79030a4802b6d3a5c15d72073d66756155 100644 (file)
--- a/js/parse/scf_parse.c
+++ b/js/parse/scf_parse.c
@@ -1936,7 +1936,7 @@ static int _scf_parse_add_text_relas(scf_parse_t* parse, scf_elf_context_t* elf,
                for (j = 0; j < f->text_relas->size; j++) {
                        r  =        f->text_relas->data[j];
 
-                       if (scf_function_signature(r->func) < 0) {
+                       if (scf_function_signature(parse->ast, r->func) < 0) {
                                scf_loge("\n");
                                goto error;
                        }
@@ -2180,7 +2180,7 @@ int64_t scf_parse_fill_code2(scf_parse_t* parse, scf_vector_t* functions, scf_ve
                                return ret;
                }
 
-               if (scf_function_signature(f) < 0)
+               if (scf_function_signature(parse->ast, f) < 0)
                        return -ENOMEM;
 
                int ret = _fill_function_inst(code, f, offset, parse);