js: object with array init ok

diff --git a/examples/js.html b/examples/js.html
index 1c701f0c8c91f05255603ed83e578c833874f5b5..01bf1c534dfa0a27cb4bb6da71ca44cfdc8bf819 100644 (file)
--- a/examples/js.html
+++ b/examples/js.html
@@ -7,16 +7,15 @@
 <p>含有js的页面</p>
 
 <script>
-var a = [3.14, 2.71];
-
-var b = {
-       p: {
-               x:1.1,
-               y:2.1
-       },
-       z: 3.1,
+var a = {
+       x: 1.1,
+       p: [
+               {y: 2.2, z: 3.3},
+               {y: 4.4, z: 5.5}
+       ],
 };
-document.write(a[1] + b.p.x + b.z);
+
+document.write(a.x + a.p[1].z);
 </script>
 
 </body>

diff --git a/js/parse/scf_dfa_expr.c b/js/parse/scf_dfa_expr.c
index 949880bee86da8e2c911765f86256b2b1c0bee4a..580f6655c3e575a3ae6baa7b2ab7a3f27a9d2d0e 100644 (file)
--- a/js/parse/scf_dfa_expr.c
+++ b/js/parse/scf_dfa_expr.c
@@ -121,7 +121,8 @@ int _expr_add_var(scf_parse_t* parse, dfa_data_t* d)
        if (md->current_var
                        && md->current_var->js_type >= 0
                        && var->member_flag) {
-               scf_loge("var: %s, member_flag: %d, line: %d, pos: %d\n", var->w->text->data, var->member_flag, var->w->line, var->w->pos);
+               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 = scf_block_find_type_type(parse->ast->current_block, SCF_VAR_INTPTR);
                v = SCF_VAR_ALLOC_BY_TYPE(NULL, t, 1, 0, NULL);

diff --git a/js/parse/scf_dfa_init_data.c b/js/parse/scf_dfa_init_data.c
index b3b647f4920752de29b1bc36fe0190bf9a8ef54a..b0410f35d709a60e8c0359502d055b23f6d3a3c1 100644 (file)
--- a/js/parse/scf_dfa_init_data.c
+++ b/js/parse/scf_dfa_init_data.c
@@ -4,8 +4,6 @@
 
 extern scf_dfa_module_t  dfa_module_init_data;
 
-int scf_array_init (scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* var, scf_vector_t* init_exprs);
-int scf_struct_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* var, scf_vector_t* init_exprs);
 int scf_object_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* var, scf_variable_t* obj, scf_vector_t* init_exprs);
 
 int _class_calculate_size(scf_dfa_t* dfa, scf_type_t* s);
@@ -139,6 +137,7 @@ static int _add_struct_member(scf_ast_t* ast, dfa_data_t* d, scf_variable_t* r)
                        v->dimentions[i].num = r->dimentions[i].num;
 
                v->const_literal_flag = 1;
+               v->js_type = v->type;
        }
 
        scf_variable_free(r);

diff --git a/js/parse/scf_struct_array.c b/js/parse/scf_struct_array.c
index 4c16cdfecbbceffb3591aeb262f2ec6ec0ea0a9b..60bf823cb9f5158c81bf54c0de938d8c662262d6 100644 (file)
--- a/js/parse/scf_struct_array.c
+++ b/js/parse/scf_struct_array.c
@@ -1,375 +1,6 @@
 #include"scf_dfa.h"
 #include"scf_parse.h"
 
-static int __reshape_index(dfa_index_t** out, scf_variable_t* array, dfa_index_t* index, int n)
-{
-       assert(array->nb_dimentions > 0);
-       assert(n > 0);
-
-       dfa_index_t* p = calloc(array->nb_dimentions, sizeof(dfa_index_t));
-       if (!p)
-               return -ENOMEM;
-
-       intptr_t i = index[n - 1].i;
-
-       scf_logw("reshape 'init exprs' from %d-dimention to %d-dimention, origin last index: %ld\n",
-                       n, array->nb_dimentions, i);
-
-       int j;
-       for (j = array->nb_dimentions - 1; j >= 0; j--) {
-
-               if (array->dimentions[j].num <= 0) {
-                       scf_logw("array's %d-dimention size not set, file: %s, line: %d\n", j, array->w->file->data, array->w->line);
-
-                       free(p);
-                       return -1;
-               }
-
-               p[j].i = i % array->dimentions[j].num;
-               i      = i / array->dimentions[j].num;
-       }
-
-       for (j = 0; j < array->nb_dimentions; j++)
-               scf_logi("\033[32m dim: %d, size: %d, index: %ld\033[0m\n", j, array->dimentions[j].num, p[j].i);
-
-       *out = p;
-       return 0;
-}
-
-static int __array_member_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* array, dfa_index_t* index, int n, scf_node_t** pnode)
-{
-       if (!pnode)
-               return -1;
-
-       scf_type_t* t    = scf_block_find_type_type(ast->current_block, SCF_VAR_INT);
-       scf_node_t* root = *pnode;
-
-       if (!root)
-               root = scf_node_alloc(NULL, array->type, array);
-
-       if (n < array->nb_dimentions) {
-               if (n <= 0) {
-                       scf_loge("number of indexes less than needed, array '%s', file: %s, line: %d\n",
-                                       array->w->text->data, w->file->data, w->line);
-                       return -1;
-               }
-
-               int ret = __reshape_index(&index, array, index, n);
-               if (ret < 0)
-                       return ret;
-       }
-
-       int i;
-       for (i = 0; i < array->nb_dimentions; i++) {
-
-               intptr_t k = index[i].i;
-
-               if (k >= array->dimentions[i].num) {
-                       scf_loge("index [%ld] out of size [%d], in dim: %d, file: %s, line: %d\n",
-                                       k, array->dimentions[i].num, i, w->file->data, w->line);
-
-                       if (n < array->nb_dimentions) {
-                               free(index);
-                               index = NULL;
-                       }
-                       return -1;
-               }
-
-               scf_variable_t* v_index     = scf_variable_alloc(NULL, t);
-               v_index->const_flag         = 1;
-               v_index->const_literal_flag = 1;
-               v_index->data.i64           = k;
-
-               scf_node_t* node_index = scf_node_alloc(NULL, v_index->type,  v_index);
-               scf_node_t* node_op    = scf_node_alloc(w,    SCF_OP_ARRAY_INDEX, NULL);
-
-               scf_node_add_child(node_op, root);
-               scf_node_add_child(node_op, node_index);
-               root = node_op;
-       }
-
-       if (n < array->nb_dimentions) {
-               free(index);
-               index = NULL;
-       }
-
-       *pnode = root;
-       return array->nb_dimentions;
-}
-
-int scf_struct_member_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* _struct, dfa_index_t* index, int n, scf_node_t** pnode)
-{
-       if (!pnode)
-               return -1;
-
-       scf_variable_t* v    = NULL;
-       scf_type_t*     t    = scf_block_find_type_type(ast->current_block, _struct->type);
-       scf_node_t*     root = *pnode;
-
-       if (!root)
-               root = scf_node_alloc(NULL, _struct->type,  _struct);
-
-       int j = 0;
-       while (j < n) {
-
-               if (!t->scope) {
-                       scf_loge("\n");
-                       return -1;
-               }
-
-               int k;
-
-               if (index[j].w) {
-                       for (k = 0; k < t->scope->vars->size; k++) {
-                               v  =        t->scope->vars->data[k];
-
-                               if (v->w && !strcmp(index[j].w->text->data, v->w->text->data))
-                                       break;
-                       }
-               } else
-                       k = index[j].i;
-
-               if (k >= t->scope->vars->size) {
-                       scf_loge("\n");
-                       return -1;
-               }
-
-               v = t->scope->vars->data[k];
-
-               scf_node_t* node_op = scf_node_alloc(w,    SCF_OP_POINTER, NULL);
-               scf_node_t* node_v  = scf_node_alloc(NULL, v->type,        v);
-
-               scf_node_add_child(node_op, root);
-               scf_node_add_child(node_op, node_v);
-               root = node_op;
-
-               scf_logi("j: %d, k: %d, v: '%s'\n", j, k, v->w->text->data);
-               j++;
-
-               if (v->nb_dimentions > 0) {
-
-                       int ret = __array_member_init(ast, w, v, index + j, n - j, &root);
-                       if (ret < 0)
-                               return -1;
-
-                       j += ret;
-                       scf_logi("struct var member: %s->%s[]\n", _struct->w->text->data, v->w->text->data);
-               }
-
-               if (v->type < SCF_STRUCT || v->nb_pointers > 0) {
-                       // if 'v' is a base type var or a pointer, and of course 'v' isn't an array,
-                       // we can't get the member of v !!
-                       // the index must be the last one, and its expr is to init v !
-                       if (j < n - 1) {
-                               scf_loge("number of indexes more than needed, struct member: %s->%s, file: %s, line: %d\n",
-                                               _struct->w->text->data, v->w->text->data, w->file->data, w->line);
-                               return -1;
-                       }
-
-                       scf_logi("struct var member: %s->%s\n", _struct->w->text->data, v->w->text->data);
-
-                       *pnode = root;
-                       return n;
-               }
-
-               // 'v' is not a base type var or a pointer, it's a struct
-               // first, find the type in this struct scope, then find in global
-               scf_type_t* type_v = NULL;
-
-               while (t) {
-                       type_v = scf_scope_find_type_type(t->scope, v->type);
-                       if (type_v)
-                               break;
-
-                       // only can use types in this scope, or parent scope
-                       // can't use types in children scope
-                       t = t->parent;
-               }
-
-               if (!type_v) {
-                       type_v = scf_block_find_type_type(ast->current_block, v->type);
-
-                       if (!type_v) {
-                               scf_loge("\n");
-                               return -1;
-                       }
-               }
-
-               t = type_v;
-       }
-
-       scf_loge("number of indexes less than needed, struct member: %s->%s, file: %s, line: %d\n",
-                       _struct->w->text->data, v->w->text->data, w->file->data, w->line);
-       return -1;
-}
-
-int scf_array_member_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* array, dfa_index_t* index, int n, scf_node_t** pnode)
-{
-       scf_node_t* root = NULL;
-
-       int ret = __array_member_init(ast, w, array, index, n, &root);
-       if (ret < 0)
-               return ret;
-
-       if (array->type < SCF_STRUCT || array->nb_pointers > 0) {
-
-               if (ret < n - 1) {
-                       scf_loge("\n");
-                       return -1;
-               }
-
-               *pnode = root;
-               return n;
-       }
-
-       ret = scf_struct_member_init(ast, w, array, index + ret, n - ret, &root);
-       if (ret < 0)
-               return ret;
-
-       *pnode = root;
-       return n;
-}
-
-int scf_array_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* v, scf_vector_t* init_exprs)
-{
-       dfa_init_expr_t* ie;
-
-       int unset     = 0;
-       int unset_dim = -1;
-       int capacity  = 1;
-       int i;
-       int j;
-
-       for (i = 0; i < v->nb_dimentions; i++) {
-               assert(v->dimentions);
-
-               scf_logi("dim[%d]: %d\n", i, v->dimentions[i].num);
-
-               if (v->dimentions[i].num < 0) {
-
-                       if (unset > 0) {
-                               scf_loge("array '%s' should only unset 1-dimention size, file: %s, line: %d\n",
-                                               v->w->text->data, w->file->data, w->line);
-                               return -1;
-                       }
-
-                       unset++;
-                       unset_dim = i;
-               } else
-                       capacity *= v->dimentions[i].num;
-       }
-
-       if (unset) {
-               int unset_max = -1;
-
-               for (i = 0; i < init_exprs->size; i++) {
-                       ie =        init_exprs->data[i];
-
-                       if (unset_dim < ie->n) {
-                               if (unset_max < ie->index[unset_dim].i)
-                                       unset_max = ie->index[unset_dim].i;
-                       }
-               }
-
-               if (-1 == unset_max) {
-                       unset_max = init_exprs->size / capacity;
-
-                       v->dimentions[unset_dim].num = unset_max;
-
-                       scf_logw("don't set %d-dimention size of array '%s', use '%d' as calculated, file: %s, line: %d\n",
-                                       unset_dim, v->w->text->data, unset_max, w->file->data, w->line);
-               } else
-                       v->dimentions[unset_dim].num = unset_max + 1;
-       }
-
-       for (i = 0; i < init_exprs->size; i++) {
-               ie =        init_exprs->data[i];
-
-               if (ie->n < v->nb_dimentions) {
-                       int n = ie->n;
-
-                       void* p = realloc(ie, sizeof(dfa_init_expr_t) + sizeof(dfa_index_t) * v->nb_dimentions);
-                       if (!p)
-                               return -ENOMEM;
-                       init_exprs->data[i] = p;
-
-                       ie    = p;
-                       ie->n = v->nb_dimentions;
-
-                       intptr_t index = ie->index[n - 1].i;
-
-                       scf_logw("reshape 'init exprs' from %d-dimention to %d-dimention, origin last index: %ld\n", n, v->nb_dimentions, index);
-
-                       for (j = v->nb_dimentions - 1; j >= 0; j--) {
-
-                               ie->index[j].i = index % v->dimentions[j].num;
-                               index          = index / v->dimentions[j].num;
-                       }
-               }
-
-               for (j = 0; j < v->nb_dimentions; j++)
-                       scf_logi("\033[32mi: %d, dim: %d, size: %d, index: %ld\033[0m\n", i, j, v->dimentions[j].num, ie->index[j].i);
-       }
-
-       for (i = 0; i < init_exprs->size; i++) {
-               ie =        init_exprs->data[i];
-
-               scf_logi("#### data init, i: %d, init expr: %p\n", i, ie->expr);
-
-               scf_expr_t* e;
-               scf_node_t* assign;
-               scf_node_t* node = NULL;
-
-               if (scf_array_member_init(ast, w, v, ie->index, ie->n, &node) < 0) {
-                       scf_loge("\n");
-                       return -1;
-               }
-
-               e      = scf_expr_alloc();
-               assign = scf_node_alloc(w, SCF_OP_ASSIGN, NULL);
-
-               scf_node_add_child(assign, node);
-               scf_node_add_child(assign, ie->expr);
-               scf_expr_add_node(e, assign);
-
-               ie->expr = e;
-               printf("\n");
-       }
-
-       return 0;
-}
-
-int scf_struct_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* var, scf_vector_t* init_exprs)
-{
-       dfa_init_expr_t* ie;
-
-       int i;
-       for (i = 0; i < init_exprs->size; i++) {
-               ie =        init_exprs->data[i];
-
-               scf_logi("#### struct init, i: %d, init_expr->expr: %p\n", i, ie->expr);
-
-               scf_expr_t* e;
-               scf_node_t* assign;
-               scf_node_t* node = NULL;
-
-               if (scf_struct_member_init(ast, w, var, ie->index, ie->n, &node) < 0)
-                       return -1;
-
-               e      = scf_expr_alloc();
-               assign = scf_node_alloc(w, SCF_OP_ASSIGN, NULL);
-
-               scf_node_add_child(assign, node);
-               scf_node_add_child(assign, ie->expr);
-               scf_expr_add_node(e, assign);
-
-               ie->expr = e;
-               printf("\n");
-       }
-
-       return 0;
-}
-
 static int __object_create(scf_expr_t* e, scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* var, int n_members, scf_type_t* Object,
                scf_vector_t* init_exprs,
                scf_vector_t* init_pos)
@@ -452,7 +83,7 @@ static int __object_create(scf_expr_t* e, scf_ast_t* ast, scf_lex_word_t* w, scf
                        ie =        init_exprs->data[i];
 
                        if (ie->n != init_pos->size) {
-                               scf_logw("var: %s, ie->n: %d, init_pos->size: %d\n", var->w->text->data, ie->n, init_pos->size);
+                               scf_logd("var: %s, ie->n: %d, init_pos->size: %d\n", var->w->text->data, ie->n, init_pos->size);
                                continue;
                        }
 
@@ -460,7 +91,7 @@ static int __object_create(scf_expr_t* e, scf_ast_t* ast, scf_lex_word_t* w, scf
                                di        = init_pos->data[j];
 
                                if (!dfa_index_same(&ie->index[j], di)) {
-                                       scf_logw("var: %s\n", var->w->text->data);
+                                       scf_logd("var: %s\n", var->w->text->data);
                                        break;
                                }
                        }
@@ -552,6 +183,8 @@ static int __object_init(scf_ast_t* ast, scf_expr_t* e, scf_lex_word_t* w, scf_v
        }
        e = NULL;
 
+       scf_logi("-----------------\n");
+
        if (t->type >= SCF_STRUCT || array_dim < obj->nb_dimentions) {
                // add ->
                node = scf_node_alloc(w, SCF_OP_POINTER, NULL);
@@ -627,6 +260,7 @@ static int __object_init(scf_ast_t* ast, scf_expr_t* e, scf_lex_word_t* w, scf_v
                                return ret;
                        }
 
+                       scf_logi(".............\n");
                        if (v) {
                                di->w = v->w;
                                di->i = -1;
@@ -644,6 +278,7 @@ static int __object_init(scf_ast_t* ast, scf_expr_t* e, scf_lex_word_t* w, scf_v
                                scf_expr_free(e2);
                                return ret;
                        }
+                       scf_logi(".............\n");
 
                        assert(0 == scf_vector_del(init_pos, di));
                        free(di);
@@ -653,6 +288,7 @@ static int __object_init(scf_ast_t* ast, scf_expr_t* e, scf_lex_word_t* w, scf_v
                }
        }
 
+       scf_logi("-----------------\n\n");
        scf_expr_free(e2);
        e2 = NULL;
        return 0;