å«æjsç页é¢
diff --git a/js/abc_libjs.c b/js/abc_libjs.c index a606910..a063ccd 100644 --- a/js/abc_libjs.c +++ b/js/abc_libjs.c @@ -1,5 +1,46 @@ #include"abc_html.h" +static char* js_days[] = { + "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" +}; + +static char* js_mons[] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; + +int64_t abc_js_date() +{ + struct timespec ts; + + clock_gettime(CLOCK_REALTIME, &ts); + + return ts.tv_sec * 1000 + ts.tv_nsec / 1000000; +} + +void abc_js_date_toString(char* s, int max, int64_t msec) +{ + struct tm tm; + + msec /= 1000; + + localtime_r(&msec, &tm); + + int t0 = msec % (24 * 3600); + int t1 = tm.tm_hour * 3600 + tm.tm_min * 60 + tm.tm_sec; + + snprintf(s, max, "%s, %s %02d %d %02d:%02d:%02d GMT+%02d00", + js_days[tm.tm_wday], + js_mons[tm.tm_mon], + tm.tm_mday, + tm.tm_year + 1900, + tm.tm_hour, + tm.tm_min, + tm.tm_sec, + (t1 - t0) / 3600); +// strftime(s, max, "%A, %Y-%m-%d %T GMT%z", &tm); +} + int abc_html_write(abc_html_t* html, const char* s) { abc_char_t* c; diff --git a/js/abc_libjs.so b/js/abc_libjs.so index 60fb561..f025fb3 100755 Binary files a/js/abc_libjs.so and b/js/abc_libjs.so differ diff --git a/js/core/scf_function.h b/js/core/scf_function.h index c69b4a3..880e2ee 100644 --- a/js/core/scf_function.h +++ b/js/core/scf_function.h @@ -61,6 +61,7 @@ struct scf_function_s { uint32_t vargs_flag:1; uint32_t void_flag :1; uint32_t call_flag :1; + uint32_t init_flag :1; uint32_t vla_flag :1; uint32_t js_flag :1; diff --git a/js/core/scf_node.h b/js/core/scf_node.h index 375badd..ba1d833 100644 --- a/js/core/scf_node.h +++ b/js/core/scf_node.h @@ -48,6 +48,7 @@ struct scf_node_s { uint32_t this_done :1; // set when node is a function call() & its 'this' pointer is set + uint32_t js_flag :1; // set when for js obj type uint32_t semi_flag :1; // set when followed by a ';' }; diff --git a/js/core/scf_optimizer.c b/js/core/scf_optimizer.c index 38214e9..b6b4ed6 100644 --- a/js/core/scf_optimizer.c +++ b/js/core/scf_optimizer.c @@ -115,6 +115,9 @@ int scf_optimize(scf_ast_t* ast, scf_vector_t* functions) if (!f->node.define_flag) continue; + if (strcmp(f->node.w->text->data, "P")) + continue; + printf("\n"); scf_logi("------- %s() ------\n", f->node.w->text->data); diff --git a/js/core/scf_optimizer_js_array.c b/js/core/scf_optimizer_js_array.c index e5899cf..3940541 100644 --- a/js/core/scf_optimizer_js_array.c +++ b/js/core/scf_optimizer_js_array.c @@ -40,7 +40,46 @@ static int __js_array_realloc(scf_ast_t* ast, scf_3ac_code_t** pc, scf_node_t* a return 0; } -static int _optimize_js_array_bb(scf_ast_t* ast, scf_basic_block_t* bb, scf_list_t* bb_list_head) +static int __js_ref_obj(scf_ast_t* ast, scf_3ac_code_t** pc, scf_node_t* obj) +{ + scf_3ac_code_t* c; + scf_variable_t* v; + scf_function_t* f = NULL; + scf_type_t* t = NULL; + scf_node_t* pf; + + int ret = scf_ast_find_global_function(&f, ast, "scf__auto_ref"); + if (ret < 0) + return ret; + + ret = scf_ast_find_type_type(&t, ast, SCF_FUNCTION_PTR); + if (ret < 0) + return ret; + + v = SCF_VAR_ALLOC_BY_TYPE(f->node.w, t, 1, 1, f); + if (!v) + return -ENOMEM; + v->const_literal_flag = 1; + + pf = scf_node_alloc(NULL, v->type, v); + scf_variable_free(v); + v = NULL; + if (!pf) + return -ENOMEM; + + scf_node_t* srcs[2] = {pf, obj}; + + c = scf_3ac_code_NN(SCF_OP_CALL, NULL, 0, srcs, 2); + if (!c) { + scf_node_free(pf); + return -ENOMEM; + } + + *pc = c; + return 0; +} + +static int _optimize_js_array_bb(scf_ast_t* ast, scf_function_t* f, scf_basic_block_t* bb, scf_list_t* bb_list_head) { scf_3ac_operand_t* base; scf_3ac_operand_t* index; @@ -48,6 +87,7 @@ static int _optimize_js_array_bb(scf_ast_t* ast, scf_basic_block_t* bb, scf_list scf_3ac_code_t* c2; scf_variable_t* v; scf_node_t* array; + scf_node_t* node; scf_type_t* Object = NULL; scf_list_t* l; @@ -76,11 +116,34 @@ static int _optimize_js_array_bb(scf_ast_t* ast, scf_basic_block_t* bb, scf_list if (ret < 0) return ret; - c2->basic_block = c->basic_block; + c2->basic_block = c->basic_block; + c2->basic_block->call_flag = 1; assert(scf_list_prev(&c->list) != scf_list_sentinel(&bb->code_list_head)); scf_list_add_tail(scf_list_prev(&c->list), &c2->list); + + if (f->js_flag && scf_type_is_assign_array_index(c->op->type)) { + base = c->srcs->data[3]; + node = base->node; + + while (SCF_OP_EXPR == node->type) + node = node->nodes[0]; + + v = _scf_operand_get(node); + + if (v->arg_flag) { + c2 = NULL; + ret = __js_ref_obj(ast, &c2, node); + if (ret < 0) + return ret; + + c2->basic_block = c->basic_block; + c2->basic_block->call_flag = 1; + + scf_list_add_tail(scf_list_prev(&c->list), &c2->list); + } + } } } } @@ -108,7 +171,7 @@ static int _optimize_js_array(scf_ast_t* ast, scf_function_t* f, scf_vector_t* f if (bb->jmp_flag || bb->end_flag || bb->cmp_flag) continue; - int ret = _optimize_js_array_bb(ast, bb, bb_list_head); + int ret = _optimize_js_array_bb(ast, f, bb, bb_list_head); if (ret < 0) return ret; } diff --git a/js/doc.c b/js/doc.c index c1aa9c2..79361bc 100644 --- a/js/doc.c +++ b/js/doc.c @@ -6,11 +6,16 @@ int abc_html_write (Object* html, const char* s); int abc_html_write_i(Object* html, int64_t i); int abc_html_write_d(Object* html, double d); +int64_t abc_js_date(); +void abc_js_date_toString(char* s, int max, int64_t msec); + enum { JS_Undef, JS_Number, JS_String, JS_Object, + JS_Date, + JS_Boolean, }; struct Object @@ -22,6 +27,13 @@ struct Object // p.x --> p.members[x] char* str; double d; + int64_t i64; + + int __init(Object* this) + { + this->type = JS_Object; + return 0; + } int __init(Object* this, double d) { @@ -104,6 +116,79 @@ struct Object return 0; } + Object* Boolean(Object* this) + { + Object* res = create Object(); + if (!res) + return NULL; + + res->i64 = 0; + res->type = JS_Boolean; + return res; + } + + Object* Boolean(Object* this, int64_t i) + { + Object* res = create Object(); + if (!res) + return NULL; + + res->i64 = i; + res->type = JS_Boolean; + return res; + } + + Object* Boolean(Object* this, Object* that) + { + Object* res = create Object(); + if (!res) + return NULL; + + switch (that->type) { + case JS_Number: + if (0.0 == that->d) + res->i64 = 0; + else + res->i64 = 1; + break; + + case JS_String: + if ('\0' == that->str[0]) + res->i64 = 0; + else + res->i64 = 1; + break; + + case JS_Boolean: + res->i64 = that->i64; + break; + + case JS_Object: + if (that) + res->i64 = 0; + else + res->i64 = 1; + break; + default: + res->i64 = 0; + break; + }; + + res->type = JS_Boolean; + return res; + } + + Object* Date(Object* this) + { + Object* res = create Object(0); + if (!res) + return NULL; + + res->i64 = abc_js_date(); + res->type = JS_Date; + return res; + } + const char* toString(Object* this) { char* p; @@ -115,6 +200,17 @@ struct Object type = this->type; switch (type) { + case JS_Boolean: + s = scf__auto_malloc(8); + if (!s) + return NULL; + + if (this->i64) + sprintf(s, "true"); + else + sprintf(s, "false"); + break; + case JS_Number: s = scf__auto_malloc(128); if (!s) @@ -144,6 +240,13 @@ struct Object memcpy(s, p, len + 1); break; + case JS_Date: + s = scf__auto_malloc(128); + if (!s) + return NULL; + + abc_js_date_toString(s, 127, this->i64); + break; default: p = "undefined"; len = strlen(p); diff --git a/js/lib/scf_capi.c b/js/lib/scf_capi.c index 759b34d..101a0c7 100644 --- a/js/lib/scf_capi.c +++ b/js/lib/scf_capi.c @@ -1,6 +1,7 @@ int printf(const char* fmt, ...); int snprintf(char* buf, uintptr_t size, const char* fmt, ...); +int sprintf (char* buf, const char* fmt, ...); int rand(); void srand(uint32_t seed); diff --git a/js/native/x64/scf_x64_reg.c b/js/native/x64/scf_x64_reg.c index b21cb3a..ae6033b 100644 --- a/js/native/x64/scf_x64_reg.c +++ b/js/native/x64/scf_x64_reg.c @@ -251,9 +251,9 @@ int x64_caller_save_regs(scf_3ac_code_t* c, const char* regs[], int nb_regs, int scf_variable_t* v = dn->var; if (v && v->w) - scf_logw("dn: %#lx, v_%d/%s/%#lx\n", 0xffff & (uintptr_t)dn, v->w->line, v->w->text->data, 0xffff & (uintptr_t)v); + scf_logd("dn: %#lx, v_%d/%s/%#lx\n", 0xffff & (uintptr_t)dn, v->w->line, v->w->text->data, 0xffff & (uintptr_t)v); else - scf_logw("dn: %#lx, v_%#lx\n", 0xffff & (uintptr_t)dn, 0xffff & (uintptr_t)v); + scf_logd("dn: %#lx, v_%#lx\n", 0xffff & (uintptr_t)dn, 0xffff & (uintptr_t)v); break; } } @@ -742,7 +742,7 @@ scf_register_t* x64_select_overflowed_reg(scf_dag_node_t* dn, scf_3ac_code_t* c) int i; int j; - scf_logi("bytes: %d\n", bytes); + scf_logd("bytes: %d\n", bytes); assert(c->rcg); diff --git a/js/parse/scf_dfa_call.c b/js/parse/scf_dfa_call.c index d90ac76..15e433a 100644 --- a/js/parse/scf_dfa_call.c +++ b/js/parse/scf_dfa_call.c @@ -58,17 +58,24 @@ static int _call_action_lp(scf_dfa_t* dfa, scf_vector_t* words, void* data) if (scf_ast_find_type_type(&pt, ast, SCF_FUNCTION_PTR) < 0) return SCF_DFA_ERROR; + int ret = scf_ast_find_type(&Object, ast, "Object"); + if (ret < 0) + return SCF_DFA_ERROR; + assert(pt); assert(op); dfa_identity_t* id = scf_stack_top(d->current_identities); if (id && id->identity) { - scf_logi("ast->current_block: %p, js_type: %d\n", ast->current_block, ast->current_block->node.type); - int ret = scf_ast_find_function(&f, ast, id->identity->text->data); + scf_logd("ast->current_block: %p, js_type: %d\n", ast->current_block, ast->current_block->node.type); + ret = scf_ast_find_function(&f, ast, id->identity->text->data); if (ret < 0) return SCF_DFA_ERROR; + if (!f) + f = scf_scope_find_function(Object->scope, id->identity->text->data); + if (f) { scf_logd("f: %p, %s\n", f, f->node.w->text->data); @@ -101,10 +108,6 @@ static int _call_action_lp(scf_dfa_t* dfa, scf_vector_t* words, void* data) return SCF_DFA_ERROR; } } else { - ret = scf_ast_find_type(&Object, ast, "Object"); - if (ret < 0) - return SCF_DFA_ERROR; - if (Object->type != var_pf->type) { scf_loge("invalid function ptr\n"); return SCF_DFA_ERROR; @@ -294,7 +297,7 @@ static int _call_add_arguments(scf_ast_t* ast, scf_lex_word_t* w, int n_members, return 0; } -static int _call_add_obj(scf_ast_t* ast, scf_lex_word_t* w, scf_node_t* call, scf_expr_t* e, scf_type_t* Object) +int _call_add_obj(scf_ast_t* ast, scf_lex_word_t* w, scf_node_t* call, scf_expr_t* e, scf_type_t* Object) { scf_variable_t* v = NULL; scf_expr_t* e2; diff --git a/js/parse/scf_dfa_create.c b/js/parse/scf_dfa_create.c index 6496de4..1e689c1 100644 --- a/js/parse/scf_dfa_create.c +++ b/js/parse/scf_dfa_create.c @@ -16,6 +16,8 @@ typedef struct { } create_module_data_t; +int _call_add_obj(scf_ast_t* ast, scf_lex_word_t* w, scf_node_t* call, scf_expr_t* e, scf_type_t* Object); + static int _create_is_create(scf_dfa_t* dfa, void* word) { scf_lex_word_t* w = word; @@ -23,6 +25,170 @@ static int _create_is_create(scf_dfa_t* dfa, void* word) return SCF_LEX_WORD_KEY_CREATE == w->type; } +static int __js_init_func(scf_ast_t* ast, scf_function_t* f) +{ + scf_variable_t* this = scf_scope_find_variable(f->scope, "this"); + scf_variable_t* that = NULL; + scf_variable_t* pf = NULL; + scf_type_t* Object = NULL; + scf_type_t* pt = NULL; + scf_node_t* node; + scf_node_t* assign; + scf_node_t* create; + scf_node_t* _return; + scf_expr_t* e; + scf_block_t* b; + + if (scf_ast_find_type_type(&pt, ast, SCF_FUNCTION_PTR) < 0) + return SCF_DFA_ERROR; + + if (scf_ast_find_type(&Object, ast, "Object") < 0) + return SCF_DFA_ERROR; + + that = SCF_VAR_ALLOC_BY_TYPE(this->w, Object, 1, 1, NULL); + if (!that) + return -ENOMEM; + that->member_flag = 1; + that->arg_flag = 1; + this->arg_flag = 0; + + memcpy(that->w->text->data, "that", 4); + f->argv->data[0] = that; + scf_scope_push_var(f->scope, that); + + // this = create Object() + // add 'this' + node = scf_node_alloc(NULL, this->type, this); + if (!node) + return -ENOMEM; + + b = scf_block_alloc_cstr("multi_rets"); + if (!b) { + scf_node_free(node); + return -ENOMEM; + } + + int ret = scf_node_add_child((scf_node_t*)b, node); + if (ret < 0) { + scf_node_free(node); + scf_block_free(b); + return ret; + } + + // add '=' + assign = scf_node_alloc(this->w, SCF_OP_ASSIGN, NULL); + if (!assign) { + scf_block_free(b); + return -ENOMEM; + } + + ret = scf_node_add_child(assign, (scf_node_t*)b); + if (ret < 0) { + scf_node_free(assign); + scf_block_free(b); + return ret; + } + + // add 'create' + create = scf_node_alloc(this->w, SCF_OP_CREATE, NULL); + if (!create) { + scf_node_free(assign); + return -ENOMEM; + } + + ret = scf_node_add_child(assign, create); + if (ret < 0) { + scf_node_free(create); + scf_node_free(assign); + return ret; + } + + // add 'Object()' + pf = SCF_VAR_ALLOC_BY_TYPE(Object->w, pt, 1, 1, NULL); + if (!pf) { + scf_node_free(assign); + return -ENOMEM; + } + pf->const_literal_flag = 1; + + node = scf_node_alloc(NULL, pf->type, pf); + scf_variable_free(pf); + pf = NULL; + if (!node) { + scf_node_free(assign); + return -ENOMEM; + } + + ret = scf_node_add_child(create, node); + if (ret < 0) { + scf_node_free(node); + scf_node_free(assign); + return ret; + } + + e = scf_expr_alloc(); + if (!e) + return -ENOMEM; + + ret = scf_node_add_child(e, assign); + if (ret < 0) { + scf_node_free(assign); + scf_expr_free(e); + return ret; + } + + ret = scf_node_add_child((scf_node_t*)f, e); + if (ret < 0) { + scf_expr_free(e); + return ret; + } + + int i; + for (i = f->node.nb_nodes - 2; i >= 0; i--) + f->node.nodes[i + 1] = f->node.nodes[i]; + f->node.nodes[0] = e; + e = NULL; + + // return this + e = scf_expr_alloc(); + if (!e) + return -ENOMEM; + + node = scf_node_alloc(NULL, this->type, this); + if (!node) { + scf_expr_free(e); + return -ENOMEM; + } + + ret = scf_node_add_child(e, node); + if (ret < 0) { + scf_node_free(node); + scf_expr_free(e); + return ret; + } + + _return = scf_node_alloc(this->w, SCF_OP_RETURN, NULL); + if (!_return) { + scf_expr_free(e); + return -ENOMEM; + } + + ret = scf_node_add_child(_return, e); + if (ret < 0) { + scf_expr_free(e); + scf_node_free(_return); + return ret; + } + + ret = scf_node_add_child((scf_node_t*)f, _return); + if (ret < 0) { + scf_node_free(_return); + return ret; + } + + return 0; +} + static int _create_action_lp_stat(scf_dfa_t* dfa, scf_vector_t* words, void* data) { dfa_data_t* d = data; @@ -61,6 +227,7 @@ static int _create_action_identity(scf_dfa_t* dfa, scf_vector_t* words, void* da scf_parse_t* parse = dfa->priv; dfa_data_t* d = data; scf_lex_word_t* w = words->data[words->size - 1]; + scf_function_t* f = NULL; create_module_data_t* md = d->module_datas[dfa_module_create.index]; scf_type_t* t = NULL; @@ -74,6 +241,12 @@ static int _create_action_identity(scf_dfa_t* dfa, scf_vector_t* words, void* da return SCF_DFA_ERROR; } + if (d->current_var && strcmp(t->name->data, "Object")) { + d->current_var->js_type = t->type; + scf_logw("type '%s', t->type: %d, d->current_var: %s, type: %d, js_type: %d\n", + t->name->data, t->type, d->current_var->w->text->data, d->current_var->type, d->current_var->js_type); + } + if (scf_ast_find_type_type(&pt, parse->ast, SCF_FUNCTION_PTR) < 0) return SCF_DFA_ERROR; assert(pt); @@ -82,6 +255,23 @@ static int _create_action_identity(scf_dfa_t* dfa, scf_vector_t* words, void* da SCF_CHECK_ERROR(!var, SCF_DFA_ERROR, "var '%s' alloc failed\n", w->text->data); var->const_literal_flag = 1; + if (scf_ast_find_function(&f, parse->ast, w->text->data) < 0) + return SCF_DFA_ERROR; + + if (f && f->js_flag) { + t->node.js_flag = 1; + md->create->js_flag = 1; + + if (!f->init_flag) { + if (__js_init_func(parse->ast, f) < 0) + return SCF_DFA_ERROR; + + f->init_flag = 1; + } + + var->func_ptr = f; + } + scf_node_t* node = scf_node_alloc(NULL, var->type, var); SCF_CHECK_ERROR(!node, SCF_DFA_ERROR, "node alloc failed\n"); @@ -125,10 +315,11 @@ static int _create_action_lp(scf_dfa_t* dfa, scf_vector_t* words, void* data) static int _create_action_rp(scf_dfa_t* dfa, scf_vector_t* words, void* data) { - scf_parse_t* parse = dfa->priv; - dfa_data_t* d = data; - scf_lex_word_t* w = words->data[words->size - 1]; - create_module_data_t* md = d->module_datas[dfa_module_create.index]; + scf_parse_t* parse = dfa->priv; + dfa_data_t* d = data; + scf_lex_word_t* w = words->data[words->size - 1]; + create_module_data_t* md = d->module_datas[dfa_module_create.index]; + scf_type_t* Object = NULL; md->nb_rps++; @@ -145,6 +336,16 @@ static int _create_action_rp(scf_dfa_t* dfa, scf_vector_t* words, void* data) assert(md->nb_rps == md->nb_lps); if (d->expr) { + if (md->create->js_flag) { + int ret = scf_ast_find_type(&Object, parse->ast, "Object"); + if (ret < 0) + return ret; + + ret = _call_add_obj(parse->ast, w, md->create, d->expr, Object); + if (ret < 0) + return ret; + } + int ret = scf_node_add_child(md->create, d->expr); d->expr = NULL; SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "node add child failed\n"); @@ -153,6 +354,9 @@ static int _create_action_rp(scf_dfa_t* dfa, scf_vector_t* words, void* data) d->expr = md->parent_expr; d->expr_local_flag--; + if (md->create->js_flag) + md->create->type = SCF_OP_CALL; + if (d->expr) { int ret = scf_expr_add_node(d->expr, md->create); SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "expr add child failed\n"); @@ -168,13 +372,24 @@ static int _create_action_rp(scf_dfa_t* dfa, scf_vector_t* words, void* data) static int _create_action_comma(scf_dfa_t* dfa, scf_vector_t* words, void* data) { - scf_parse_t* parse = dfa->priv; - dfa_data_t* d = data; - scf_lex_word_t* w = words->data[words->size - 1]; - create_module_data_t* md = d->module_datas[dfa_module_create.index]; + scf_parse_t* parse = dfa->priv; + dfa_data_t* d = data; + scf_lex_word_t* w = words->data[words->size - 1]; + create_module_data_t* md = d->module_datas[dfa_module_create.index]; + scf_type_t* Object = NULL; SCF_CHECK_ERROR(!d->expr, SCF_DFA_ERROR, "\n"); + if (md->create->js_flag) { + int ret = scf_ast_find_type(&Object, parse->ast, "Object"); + if (ret < 0) + return ret; + + ret = _call_add_obj(parse->ast, w, md->create, d->expr, Object); + if (ret < 0) + return ret; + } + int ret = scf_node_add_child(md->create, d->expr); d->expr = NULL; SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "node add child failed\n"); diff --git a/js/parse/scf_dfa_expr.c b/js/parse/scf_dfa_expr.c index 42bb81e..6ff8d56 100644 --- a/js/parse/scf_dfa_expr.c +++ b/js/parse/scf_dfa_expr.c @@ -89,6 +89,7 @@ int _expr_add_var(scf_parse_t* parse, dfa_data_t* d) scf_type_t* t = NULL; scf_type_t* t2 = NULL; scf_function_t* f = NULL; + scf_block_t* b = NULL; dfa_identity_t* id = scf_stack_pop(d->current_identities); scf_lex_word_t* w; @@ -126,6 +127,33 @@ int _expr_add_var(scf_parse_t* parse, dfa_data_t* d) if (scf_ast_find_type_type(&t, parse->ast, md->current_var->js_type) < 0) return SCF_DFA_ERROR; + if (!strcmp(t->name->data, "Object")) { + if (strcmp(md->current_var->w->text->data, "this") || !d->current_function) + return SCF_DFA_ERROR; + + f = d->current_function; + + b = (scf_block_t*)f->node.parent; + assert(b->node.file_flag); + + t = scf_type_alloc(f->node.w, f->node.w->text->data, SCF_STRUCT + parse->ast->nb_structs, 0); + if (!t) { + scf_loge("\n"); + return SCF_DFA_ERROR; + } + + t->scope = scf_scope_alloc(f->node.w, "class"); + + parse->ast->nb_structs++; + t->node.class_flag = 1; + scf_scope_push_type(b->scope, t); + scf_node_add_child((scf_node_t*)b, (scf_node_t*)t); + + md->current_var->js_type = t->type; + + scf_logi("md->current_var->js_type: %d, %s\n", t->type, t->name->data); + } + t2 = NULL; if (scf_ast_find_type_type(&t2, parse->ast, SCF_VAR_VAR) < 0) return SCF_DFA_ERROR; @@ -561,25 +589,6 @@ static int _expr_action_rp(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_variable_t* v = NULL; - scf_function_t* f = NULL; - - if (scf_ast_find_variable(&v, parse->ast, id->identity->text->data) < 0) - return SCF_DFA_ERROR; - - if (!v) { - scf_logw("'%s' not var\n", id->identity->text->data); - - if (scf_ast_find_function(&f, parse->ast, id->identity->text->data) < 0) - return SCF_DFA_ERROR; - - if (!f) { - scf_logw("'%s' not function\n", id->identity->text->data); - return SCF_DFA_NEXT_SYNTAX; - } - } - if (_expr_add_var(parse, d) < 0) { scf_loge("expr add var error\n"); return SCF_DFA_ERROR; @@ -810,7 +819,7 @@ int _expr_multi_rets(scf_expr_t* e) for (i = parent->nb_nodes - 2; i >= 0; i--) { ret = parent->nodes[i]; - if (ret->semi_flag) + if (ret->semi_flag || SCF_OP_EXPR != ret->type) break; if (b->node.nb_nodes >= nb_rets - 1) diff --git a/js/parse/scf_operator_handler_semantic.c b/js/parse/scf_operator_handler_semantic.c index 91aecdf..66deb83 100644 --- a/js/parse/scf_operator_handler_semantic.c +++ b/js/parse/scf_operator_handler_semantic.c @@ -3276,11 +3276,11 @@ static int _scf_op_semantic_eq(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, scf_variable_t* v0 = _scf_operand_get(nodes[0]); \ scf_variable_t* v1 = _scf_operand_get(nodes[1]); \ \ - if (scf_variable_float(v0) || scf_variable_float(v1)) { \ + } while (0) +// if (scf_variable_float(v0) || scf_variable_float(v1)) { \ scf_loge("float type can't cmp equal\n"); \ return -EINVAL; \ } \ - } while (0) CMPEQ_CHECK_FLOAT(); diff --git a/js/parse/scf_parse.c b/js/parse/scf_parse.c index 436312d..948e649 100644 --- a/js/parse/scf_parse.c +++ b/js/parse/scf_parse.c @@ -1121,7 +1121,7 @@ static int _debug_add_subprogram(scf_dwarf_info_entry_t** pie, scf_parse_t* pars scf_variable_t* v = f->rets->data[0]; scf_type_t* t = NULL; - scf_logi("v: %p, f->rets->size: %d\n", v, f->rets->size); + scf_logd("v: %p, f->rets->size: %d\n", v, f->rets->size); ret = scf_ast_find_type_type(&t, parse->ast, v->type); if (ret < 0) @@ -1902,7 +1902,7 @@ int scf_parse_compile_functions(scf_parse_t* parse, scf_vector_t* functions) } assert(scf_list_empty(&h)); - scf_basic_block_print_list(&f->basic_block_list_head); +// scf_basic_block_print_list(&f->basic_block_list_head); } int ret = scf_optimize(parse->ast, functions);