From: yu.dongliang <18588496441@163.com> Date: Sat, 11 Oct 2025 08:08:29 +0000 (+0800) Subject: re-name key word 'create' to 'new' X-Git-Url: http://baseworks.info/?a=commitdiff_plain;ds=inline;p=scf.git re-name key word 'create' to 'new' --- diff --git a/core/scf_basic_block.c b/core/scf_basic_block.c index b38a2dd..55a6426 100644 --- a/core/scf_basic_block.c +++ b/core/scf_basic_block.c @@ -1132,8 +1132,9 @@ int scf_basic_block_active_vars(scf_basic_block_t* bb) } #endif - scf_vector_clear(bb->entry_dn_actives, NULL); - scf_vector_clear(bb->dn_updateds, NULL); + scf_vector_clear(bb->entry_dn_actives, NULL); + scf_vector_clear(bb->entry_dn_inactives, NULL); + scf_vector_clear(bb->dn_updateds, NULL); if (!scf_list_empty(&bb->code_list_head)) { @@ -1319,6 +1320,9 @@ int scf_basic_block_loads_saves(scf_basic_block_t* bb, scf_list_t* bb_list_head) int ret; int i; + scf_vector_clear(bb->dn_loads, NULL); + scf_vector_clear(bb->dn_saves, NULL); + for (i = 0; i < bb->entry_dn_actives->size; i++) { dn = bb->entry_dn_actives->data[i]; diff --git a/core/scf_core_types.h b/core/scf_core_types.h index 0f66624..960b494 100644 --- a/core/scf_core_types.h +++ b/core/scf_core_types.h @@ -87,7 +87,7 @@ enum scf_core_types SCF_OP_CALL, // () function call SCF_OP_TYPE_CAST, // (char*) type cast - SCF_OP_CREATE, // create + SCF_OP_NEW, // new class object SCF_OP_SIZEOF, // sizeof SCF_OP_CONTAINER, // container_of diff --git a/core/scf_dag.c b/core/scf_dag.c index eb0438a..67e483c 100644 --- a/core/scf_dag.c +++ b/core/scf_dag.c @@ -548,7 +548,7 @@ int scf_dag_node_same(scf_dag_node_t* dn, const scf_node_t* node) scf_logd("dag type: %d, node: %#lx, var: %#lx\n", dn->type, 0xffff & (uintptr_t)dn, 0xffff & (uintptr_t)dn->var); } - if (SCF_OP_CREATE == node->type) + if (SCF_OP_NEW == node->type) node = node->result_nodes->data[0]; if (dn->type != node->type) diff --git a/core/scf_lex_word.h b/core/scf_lex_word.h index d37a758..543aae6 100644 --- a/core/scf_lex_word.h +++ b/core/scf_lex_word.h @@ -60,7 +60,7 @@ enum scf_lex_words SCF_LEX_WORD_RA, // >> right angle brackets SCF_LEX_WORD_KEY_SIZEOF, // sizeof - SCF_LEX_WORD_KEY_CREATE, // create class object + SCF_LEX_WORD_KEY_NEW, // create class object SCF_LEX_WORD_KEY_CONTAINER, // container_of SCF_LEX_WORD_KEY_VA_ARG, // va_arg diff --git a/core/scf_operator.c b/core/scf_operator.c index 69351e8..270bde4 100644 --- a/core/scf_operator.c +++ b/core/scf_operator.c @@ -15,7 +15,7 @@ static scf_operator_t base_operators[] = {"va_end", NULL, SCF_OP_VA_END, 1, 1, SCF_OP_ASSOCIATIVITY_LEFT}, {"container", NULL, SCF_OP_CONTAINER, 1, 3, SCF_OP_ASSOCIATIVITY_LEFT}, - {"create", NULL, SCF_OP_CREATE, 2, -1, SCF_OP_ASSOCIATIVITY_RIGHT}, + {"new", NULL, SCF_OP_NEW, 2, -1, SCF_OP_ASSOCIATIVITY_RIGHT}, {"(", NULL, SCF_OP_TYPE_CAST, 2, 2, SCF_OP_ASSOCIATIVITY_RIGHT}, {"!", "not", SCF_OP_LOGIC_NOT, 2, 1, SCF_OP_ASSOCIATIVITY_RIGHT}, {"~", "bnot", SCF_OP_BIT_NOT, 2, 1, SCF_OP_ASSOCIATIVITY_RIGHT}, diff --git a/core/scf_operator_handler_3ac.c b/core/scf_operator_handler_3ac.c index c033049..7ed9cb1 100644 --- a/core/scf_operator_handler_3ac.c +++ b/core/scf_operator_handler_3ac.c @@ -96,7 +96,7 @@ static int _scf_expr_calculate_internal(scf_ast_t* ast, scf_node_t* node, void* return h(ast, node->nodes, node->nb_nodes, d); } else { - if (!scf_type_is_assign(node->op->type) && SCF_OP_ADDRESS_OF != node->op->type && SCF_OP_CREATE != node->op->type) { + if (!scf_type_is_assign(node->op->type) && SCF_OP_ADDRESS_OF != node->op->type && SCF_OP_NEW != node->op->type) { for (i = node->nb_nodes - 1; i >= 0; i--) { if (_scf_expr_calculate_internal(ast, node->nodes[i], d) < 0) { @@ -1425,7 +1425,7 @@ int scf_function_to_3ac(scf_ast_t* ast, scf_function_t* f, scf_list_t* _3ac_list return 0; } -static int _scf_op_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) +static int _scf_op_new(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) { assert(nb_nodes > 0); @@ -2391,7 +2391,7 @@ scf_operator_handler_pt __operator_handlers[SCF_N_3AC_OPS] = { [SCF_OP_EXPR ] = _scf_op_expr, [SCF_OP_CALL ] = _scf_op_call, - [SCF_OP_CREATE] = _scf_op_create, + [SCF_OP_NEW ] = _scf_op_new, [SCF_OP_ARRAY_INDEX] = _scf_op_array_index, [SCF_OP_POINTER ] = _scf_op_pointer, diff --git a/core/scf_optimizer.c b/core/scf_optimizer.c index 79fd61c..d8e5da4 100644 --- a/core/scf_optimizer.c +++ b/core/scf_optimizer.c @@ -54,6 +54,9 @@ static scf_optimizer_t* scf_optimizers[] = &scf_optimizer_basic_block, &scf_optimizer_const_teq, + &scf_optimizer_active_vars, + &scf_optimizer_loads_saves, + &scf_optimizer_dominators, &scf_optimizer_loop, &scf_optimizer_vla, diff --git a/core/scf_optimizer_auto_gc.c b/core/scf_optimizer_auto_gc.c index 2b1ab06..bdc2a93 100644 --- a/core/scf_optimizer_auto_gc.c +++ b/core/scf_optimizer_auto_gc.c @@ -743,7 +743,7 @@ static int _auto_gc_retval(scf_dn_status_t* ds_obj, scf_dag_node_t* dn, scf_vect if (dn->node->split_flag) { parent = dn->node->split_parent; - assert(SCF_OP_CALL == parent->type || SCF_OP_CREATE == parent->type); + assert(SCF_OP_CALL == parent->type || SCF_OP_NEW == parent->type); for (i = 0; i < parent->result_nodes->size; i++) { result = parent->result_nodes->data[i]; diff --git a/core/scf_optimizer_auto_gc_find.c b/core/scf_optimizer_auto_gc_find.c index f1c9ef8..5b0ea3d 100644 --- a/core/scf_optimizer_auto_gc_find.c +++ b/core/scf_optimizer_auto_gc_find.c @@ -479,7 +479,7 @@ static int _auto_gc_find_ref(scf_dn_status_t* ds_obj, scf_dag_node_t* dn, scf_3a if (dn->node->split_flag) { parent = dn->node->split_parent; - assert(SCF_OP_CALL == parent->type || SCF_OP_CREATE == parent->type); + assert(SCF_OP_CALL == parent->type || SCF_OP_NEW == parent->type); for (i = 0; i < parent->result_nodes->size; i++) { result = parent->result_nodes->data[i]; diff --git a/core/scf_pointer_alias.c b/core/scf_pointer_alias.c index 2232ac7..fde6de7 100644 --- a/core/scf_pointer_alias.c +++ b/core/scf_pointer_alias.c @@ -143,7 +143,7 @@ static int _bb_pointer_initeds(scf_vector_t* initeds, scf_list_t* bb_list_head, scf_logd("dn->node->split_parent: %d, %p\n", dn->node->split_parent->type, dn->node->split_parent); assert(dn->node->split_parent->type == SCF_OP_CALL - || dn->node->split_parent->type == SCF_OP_CREATE); + || dn->node->split_parent->type == SCF_OP_NEW); return 0; } @@ -242,7 +242,7 @@ static int _bb_pointer_initeds_leak(scf_vector_t* initeds, scf_list_t* bb_list_h if (dn->node->split_flag) { assert(dn->node->split_parent->type == SCF_OP_CALL - || dn->node->split_parent->type == SCF_OP_CREATE); + || dn->node->split_parent->type == SCF_OP_NEW); return 0; } diff --git a/examples/auto_gc_1.c b/examples/auto_gc_1.c index 9edd1a4..f7ad548 100644 --- a/examples/auto_gc_1.c +++ b/examples/auto_gc_1.c @@ -12,7 +12,7 @@ struct Object Object* operator+(Object* this, Object* that) { - Object* res = create Object(this->d + that->d); + Object* res = new Object(this->d + that->d); return res; } }; @@ -24,8 +24,8 @@ Object* add(Object* x, Object* y) int main() { - Object* a = create Object(1.1); - Object* b = create Object(2.2); + Object* a = new Object(1.1); + Object* b = new Object(2.2); Object* c = add(a, b); diff --git a/examples/complex.c b/examples/complex.c index 0eb8776..1f55158 100644 --- a/examples/complex.c +++ b/examples/complex.c @@ -7,9 +7,9 @@ int main() complex* c2; complex* c3; - complex* c0 = create complex(1.0, 2.0); + complex* c0 = new complex(1.0, 2.0); - c1 = create complex(3.0, 4.0); + c1 = new complex(3.0, 4.0); c2 = c0 + c1; c3 = c0 * c1; diff --git a/examples/mat.c b/examples/mat.c index aa4f5ef..2db49a0 100644 --- a/examples/mat.c +++ b/examples/mat.c @@ -70,7 +70,7 @@ struct mat { mat* res; - res = create mat(MAT_TYPE_DOUBLE, NULL, this->depth, this->width, this->height, this->count); + res = new mat(MAT_TYPE_DOUBLE, NULL, this->depth, this->width, this->height, this->count); if (!res) return NULL, -1; @@ -144,9 +144,9 @@ int main() mat* m3; mat* m4; - m0 = create mat(MAT_TYPE_DOUBLE, (uint8_t*)a, 1, 2, 2, 1); - m1 = create mat(MAT_TYPE_DOUBLE, (uint8_t*)b, 1, 2, 2, 1); - m2 = create mat(MAT_TYPE_DOUBLE, (uint8_t*)c, 1, 2, 2, 1); + m0 = new mat(MAT_TYPE_DOUBLE, (uint8_t*)a, 1, 2, 2, 1); + m1 = new mat(MAT_TYPE_DOUBLE, (uint8_t*)b, 1, 2, 2, 1); + m2 = new mat(MAT_TYPE_DOUBLE, (uint8_t*)c, 1, 2, 2, 1); m3 = m0 + m1 + m2; diff --git a/examples/ret2_err.c b/examples/ret2_err.c index cdc12ce..63a4512 100644 --- a/examples/ret2_err.c +++ b/examples/ret2_err.c @@ -33,7 +33,7 @@ int main() str* p0; int err; - p0, err = create str(); + p0, err = new str(); if (err < 0) return -1; diff --git a/examples/str.c b/examples/str.c index d9a0ff0..978f9d0 100644 --- a/examples/str.c +++ b/examples/str.c @@ -31,7 +31,7 @@ int main() str* p0; str* p1; - p0 = create str(); + p0 = new str(); p1 = p0; printf("%s\n", p1->data); diff --git a/examples/string.c b/examples/string.c index 081733e..9262554 100644 --- a/examples/string.c +++ b/examples/string.c @@ -78,7 +78,7 @@ struct string { string* s; - s = create string(); + s = new string(); if (!s) return NULL, -1; diff --git a/lex/scf_lex.c b/lex/scf_lex.c index abd4f23..923b543 100644 --- a/lex/scf_lex.c +++ b/lex/scf_lex.c @@ -23,7 +23,7 @@ static scf_key_word_t key_words[] = {"sizeof", SCF_LEX_WORD_KEY_SIZEOF}, - {"create", SCF_LEX_WORD_KEY_CREATE}, + {"new", SCF_LEX_WORD_KEY_NEW}, {"operator", SCF_LEX_WORD_KEY_OPERATOR}, diff --git a/lib/scf_complex.c b/lib/scf_complex.c index 86ac0e6..c07e5ef 100644 --- a/lib/scf_complex.c +++ b/lib/scf_complex.c @@ -69,7 +69,7 @@ struct complex complex* res; - res = create complex(0.0, 0.0); + res = new complex(0.0, 0.0); if (!res) return NULL, -1; @@ -85,7 +85,7 @@ struct complex complex* res; - res = create complex(0.0, 0.0); + res = new complex(0.0, 0.0); if (!res) return NULL, -1; @@ -101,7 +101,7 @@ struct complex complex* res; - res = create complex(0.0, 0.0); + res = new complex(0.0, 0.0); if (!res) return NULL, -1; @@ -122,7 +122,7 @@ struct complex complex* res; - res = create complex(0.0, 0.0); + res = new complex(0.0, 0.0); if (!res) return NULL, -1; @@ -136,5 +136,3 @@ struct complex return res, 0; } }; - - diff --git a/lib/scf_string.c b/lib/scf_string.c index c45c34f..a072f62 100644 --- a/lib/scf_string.c +++ b/lib/scf_string.c @@ -96,7 +96,7 @@ struct string { string* s; - s = create string(); + s = new string(); if (!s) return NULL, -1; @@ -133,4 +133,3 @@ struct string scf__auto_freep(&this->data, NULL); } }; - diff --git a/parse/Makefile b/parse/Makefile index 7cb3b8f..fdc5dcc 100644 --- a/parse/Makefile +++ b/parse/Makefile @@ -131,7 +131,7 @@ CFILES += scf_dfa_macro.c CFILES += scf_dfa_include.c CFILES += scf_dfa_call.c -CFILES += scf_dfa_create.c +CFILES += scf_dfa_new.c CFILES += scf_dfa_sizeof.c CFILES += scf_dfa_container.c CFILES += scf_dfa_va_arg.c diff --git a/parse/scf_dfa_call.c b/parse/scf_dfa_call.c index ad27a5d..0c9c5f8 100644 --- a/parse/scf_dfa_call.c +++ b/parse/scf_dfa_call.c @@ -295,22 +295,22 @@ static int _dfa_init_syntax_call(scf_dfa_t* dfa) SCF_DFA_GET_MODULE_NODE(dfa, expr, entry, expr); - SCF_DFA_GET_MODULE_NODE(dfa, create, create, create); - SCF_DFA_GET_MODULE_NODE(dfa, create, identity, create_id); - SCF_DFA_GET_MODULE_NODE(dfa, create, rp, create_rp); + SCF_DFA_GET_MODULE_NODE(dfa, new, new, new); + SCF_DFA_GET_MODULE_NODE(dfa, new, identity, new_id); + SCF_DFA_GET_MODULE_NODE(dfa, new, rp, new_rp); // no args scf_dfa_node_add_child(lp, rp); // have args - // arg: create class object, such as: list.push(new A); - scf_dfa_node_add_child(lp, create); - scf_dfa_node_add_child(create_id, comma); - scf_dfa_node_add_child(create_id, rp); - scf_dfa_node_add_child(create_rp, comma); - scf_dfa_node_add_child(create_rp, rp); - scf_dfa_node_add_child(comma, create); + // arg: new class object, such as: list.push(new A); + scf_dfa_node_add_child(lp, new); + scf_dfa_node_add_child(new_id, comma); + scf_dfa_node_add_child(new_id, rp); + scf_dfa_node_add_child(new_rp, comma); + scf_dfa_node_add_child(new_rp, rp); + scf_dfa_node_add_child(comma, new); scf_dfa_node_add_child(lp, expr); scf_dfa_node_add_child(expr, comma); diff --git a/parse/scf_dfa_create.c b/parse/scf_dfa_create.c deleted file mode 100644 index 6496de4..0000000 --- a/parse/scf_dfa_create.c +++ /dev/null @@ -1,263 +0,0 @@ -#include"scf_dfa.h" -#include"scf_dfa_util.h" -#include"scf_parse.h" -#include"scf_stack.h" - -extern scf_dfa_module_t dfa_module_create; - -typedef struct { - - int nb_lps; - int nb_rps; - - scf_node_t* create; - - scf_expr_t* parent_expr; - -} create_module_data_t; - -static int _create_is_create(scf_dfa_t* dfa, void* word) -{ - scf_lex_word_t* w = word; - - return SCF_LEX_WORD_KEY_CREATE == w->type; -} - -static int _create_action_lp_stat(scf_dfa_t* dfa, scf_vector_t* words, void* data) -{ - dfa_data_t* d = data; - scf_stack_t* s = d->module_datas[dfa_module_create.index]; - create_module_data_t* md = d->module_datas[dfa_module_create.index]; - - md->nb_lps++; - - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_lp_stat"), SCF_DFA_HOOK_POST); - - return SCF_DFA_NEXT_WORD; -} - -static int _create_action_create(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_CHECK_ERROR(md->create, SCF_DFA_ERROR, "\n"); - - md->create = scf_node_alloc(w, SCF_OP_CREATE, NULL); - if (!md->create) - return SCF_DFA_ERROR; - - md->nb_lps = 0; - md->nb_rps = 0; - md->parent_expr = d->expr; - - return SCF_DFA_NEXT_WORD; -} - -static int _create_action_identity(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_type_t* t = NULL; - scf_type_t* pt = NULL; - - if (scf_ast_find_type(&t, parse->ast, w->text->data) < 0) - return SCF_DFA_ERROR; - - if (!t) { - scf_loge("type '%s' not found\n", w->text->data); - return SCF_DFA_ERROR; - } - - if (scf_ast_find_type_type(&pt, parse->ast, SCF_FUNCTION_PTR) < 0) - return SCF_DFA_ERROR; - assert(pt); - - scf_variable_t* var = SCF_VAR_ALLOC_BY_TYPE(w, pt, 1, 1, NULL); - SCF_CHECK_ERROR(!var, SCF_DFA_ERROR, "var '%s' alloc failed\n", w->text->data); - var->const_literal_flag = 1; - - scf_node_t* node = scf_node_alloc(NULL, var->type, var); - SCF_CHECK_ERROR(!node, SCF_DFA_ERROR, "node alloc failed\n"); - - int ret = scf_node_add_child(md->create, node); - SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "node add child failed\n"); - - w = dfa->ops->pop_word(dfa); - if (SCF_LEX_WORD_LP != w->type) { - - if (d->expr) { - ret = scf_expr_add_node(d->expr, md->create); - SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "expr add child failed\n"); - } else - d->expr = md->create; - - md->create = NULL; - } - dfa->ops->push_word(dfa, w); - - return SCF_DFA_NEXT_WORD; -} - -static int _create_action_lp(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_logd("d->expr: %p\n", d->expr); - - d->expr = NULL; - d->expr_local_flag++; - - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_rp"), SCF_DFA_HOOK_POST); - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_comma"), SCF_DFA_HOOK_POST); - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_lp_stat"), SCF_DFA_HOOK_POST); - - return SCF_DFA_NEXT_WORD; -} - -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]; - - md->nb_rps++; - - scf_logd("md->nb_lps: %d, md->nb_rps: %d\n", md->nb_lps, md->nb_rps); - - if (md->nb_rps < md->nb_lps) { - - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_rp"), SCF_DFA_HOOK_POST); - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_comma"), SCF_DFA_HOOK_POST); - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_lp_stat"), SCF_DFA_HOOK_POST); - - return SCF_DFA_NEXT_WORD; - } - assert(md->nb_rps == md->nb_lps); - - if (d->expr) { - 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"); - } - - d->expr = md->parent_expr; - d->expr_local_flag--; - - 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"); - } else - d->expr = md->create; - - md->create = NULL; - - scf_logi("d->expr: %p\n", d->expr); - - return SCF_DFA_NEXT_WORD; -} - -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_CHECK_ERROR(!d->expr, SCF_DFA_ERROR, "\n"); - - 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"); - - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_comma"), SCF_DFA_HOOK_POST); - SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "create_lp_stat"), SCF_DFA_HOOK_POST); - - return SCF_DFA_SWITCH_TO; -} - -static int _dfa_init_module_create(scf_dfa_t* dfa) -{ - SCF_DFA_MODULE_NODE(dfa, create, create, _create_is_create, _create_action_create); - - SCF_DFA_MODULE_NODE(dfa, create, identity, scf_dfa_is_identity, _create_action_identity); - - SCF_DFA_MODULE_NODE(dfa, create, lp, scf_dfa_is_lp, _create_action_lp); - SCF_DFA_MODULE_NODE(dfa, create, rp, scf_dfa_is_rp, _create_action_rp); - - SCF_DFA_MODULE_NODE(dfa, create, lp_stat, scf_dfa_is_lp, _create_action_lp_stat); - - SCF_DFA_MODULE_NODE(dfa, create, comma, scf_dfa_is_comma, _create_action_comma); - - scf_parse_t* parse = dfa->priv; - dfa_data_t* d = parse->dfa_data; - create_module_data_t* md = d->module_datas[dfa_module_create.index]; - - assert(!md); - - md = calloc(1, sizeof(create_module_data_t)); - if (!md) { - scf_loge("\n"); - return SCF_DFA_ERROR; - } - - d->module_datas[dfa_module_create.index] = md; - - return SCF_DFA_OK; -} - -static int _dfa_fini_module_create(scf_dfa_t* dfa) -{ - scf_parse_t* parse = dfa->priv; - dfa_data_t* d = parse->dfa_data; - create_module_data_t* md = d->module_datas[dfa_module_create.index]; - - if (md) { - free(md); - md = NULL; - d->module_datas[dfa_module_create.index] = NULL; - } - - return SCF_DFA_OK; -} - -static int _dfa_init_syntax_create(scf_dfa_t* dfa) -{ - SCF_DFA_GET_MODULE_NODE(dfa, create, create, create); - SCF_DFA_GET_MODULE_NODE(dfa, create, identity, identity); - SCF_DFA_GET_MODULE_NODE(dfa, create, lp, lp); - SCF_DFA_GET_MODULE_NODE(dfa, create, rp, rp); - SCF_DFA_GET_MODULE_NODE(dfa, create, comma, comma); - - SCF_DFA_GET_MODULE_NODE(dfa, expr, entry, expr); - - scf_dfa_node_add_child(create, identity); - scf_dfa_node_add_child(identity, lp); - - scf_dfa_node_add_child(lp, rp); - - scf_dfa_node_add_child(lp, expr); - scf_dfa_node_add_child(expr, comma); - scf_dfa_node_add_child(comma, expr); - scf_dfa_node_add_child(expr, rp); - - return 0; -} - -scf_dfa_module_t dfa_module_create = -{ - .name = "create", - .init_module = _dfa_init_module_create, - .init_syntax = _dfa_init_syntax_create, - - .fini_module = _dfa_fini_module_create, -}; diff --git a/parse/scf_dfa_expr.c b/parse/scf_dfa_expr.c index e8e431e..240fbcc 100644 --- a/parse/scf_dfa_expr.c +++ b/parse/scf_dfa_expr.c @@ -662,7 +662,7 @@ int _expr_multi_rets(scf_expr_t* e) nb_rets = f->rets->size; - } else if (SCF_OP_CREATE == call->type) + } else if (SCF_OP_NEW == call->type) nb_rets = 2; else return 0; @@ -891,9 +891,9 @@ static int _dfa_init_syntax_expr(scf_dfa_t* dfa) SCF_DFA_GET_MODULE_NODE(dfa, sizeof, _sizeof, _sizeof); SCF_DFA_GET_MODULE_NODE(dfa, sizeof, rp, sizeof_rp); - SCF_DFA_GET_MODULE_NODE(dfa, create, create, create); - SCF_DFA_GET_MODULE_NODE(dfa, create, identity, create_id); - SCF_DFA_GET_MODULE_NODE(dfa, create, rp, create_rp); + SCF_DFA_GET_MODULE_NODE(dfa, new, new, new); + SCF_DFA_GET_MODULE_NODE(dfa, new, identity, new_id); + SCF_DFA_GET_MODULE_NODE(dfa, new, rp, new_rp); SCF_DFA_GET_MODULE_NODE(dfa, type, entry, type_entry); SCF_DFA_GET_MODULE_NODE(dfa, type, base_type, base_type); @@ -925,10 +925,10 @@ static int _dfa_init_syntax_expr(scf_dfa_t* dfa) scf_dfa_node_add_child(container_rp, comma); scf_dfa_node_add_child(container_rp, semicolon); - // create class object - scf_dfa_node_add_child(expr, create); - scf_dfa_node_add_child(create_id, semicolon); - scf_dfa_node_add_child(create_rp, semicolon); + // new class object + scf_dfa_node_add_child(expr, new); + scf_dfa_node_add_child(new_id, semicolon); + scf_dfa_node_add_child(new_rp, semicolon); // va_arg(ap, type) scf_dfa_node_add_child(expr, va_arg); @@ -1002,8 +1002,8 @@ static int _dfa_init_syntax_expr(scf_dfa_t* dfa) scf_dfa_node_add_child(binary_op, number); scf_dfa_node_add_child(binary_op, identity); - // create class object - scf_dfa_node_add_child(binary_op, create); + // new class object + scf_dfa_node_add_child(binary_op, new); scf_dfa_node_add_child(binary_op, expr); scf_dfa_node_add_child(unary_post, rp); diff --git a/parse/scf_dfa_new.c b/parse/scf_dfa_new.c new file mode 100644 index 0000000..5920c8b --- /dev/null +++ b/parse/scf_dfa_new.c @@ -0,0 +1,260 @@ +#include"scf_dfa.h" +#include"scf_dfa_util.h" +#include"scf_parse.h" +#include"scf_stack.h" + +extern scf_dfa_module_t dfa_module_new; + +typedef struct { + + int nb_lps; + int nb_rps; + + scf_node_t* new; + + scf_expr_t* parent_expr; + +} new_module_data_t; + +static int _new_is_new(scf_dfa_t* dfa, void* word) +{ + scf_lex_word_t* w = word; + + return SCF_LEX_WORD_KEY_NEW == w->type; +} + +static int _new_action_lp_stat(scf_dfa_t* dfa, scf_vector_t* words, void* data) +{ + dfa_data_t* d = data; + scf_stack_t* s = d->module_datas[dfa_module_new.index]; + new_module_data_t* md = d->module_datas[dfa_module_new.index]; + + md->nb_lps++; + + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_lp_stat"), SCF_DFA_HOOK_POST); + + return SCF_DFA_NEXT_WORD; +} + +static int _new_action_new(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]; + new_module_data_t* md = d->module_datas[dfa_module_new.index]; + + SCF_CHECK_ERROR(md->new, SCF_DFA_ERROR, "\n"); + + md->new = scf_node_alloc(w, SCF_OP_NEW, NULL); + if (!md->new) + return SCF_DFA_ERROR; + + md->nb_lps = 0; + md->nb_rps = 0; + md->parent_expr = d->expr; + + return SCF_DFA_NEXT_WORD; +} + +static int _new_action_identity(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]; + new_module_data_t* md = d->module_datas[dfa_module_new.index]; + + scf_type_t* t = NULL; + scf_type_t* pt = NULL; + + if (scf_ast_find_type(&t, parse->ast, w->text->data) < 0) + return SCF_DFA_ERROR; + + if (!t) { + scf_loge("type '%s' not found\n", w->text->data); + return SCF_DFA_ERROR; + } + + if (scf_ast_find_type_type(&pt, parse->ast, SCF_FUNCTION_PTR) < 0) + return SCF_DFA_ERROR; + assert(pt); + + scf_variable_t* var = SCF_VAR_ALLOC_BY_TYPE(w, pt, 1, 1, NULL); + SCF_CHECK_ERROR(!var, SCF_DFA_ERROR, "var '%s' alloc failed\n", w->text->data); + var->const_literal_flag = 1; + + scf_node_t* node = scf_node_alloc(NULL, var->type, var); + SCF_CHECK_ERROR(!node, SCF_DFA_ERROR, "node alloc failed\n"); + + int ret = scf_node_add_child(md->new, node); + SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "node add child failed\n"); + + w = dfa->ops->pop_word(dfa); + if (SCF_LEX_WORD_LP != w->type) { + + if (d->expr) { + ret = scf_expr_add_node(d->expr, md->new); + SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "expr add child failed\n"); + } else + d->expr = md->new; + + md->new = NULL; + } + dfa->ops->push_word(dfa, w); + + return SCF_DFA_NEXT_WORD; +} + +static int _new_action_lp(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]; + new_module_data_t* md = d->module_datas[dfa_module_new.index]; + + scf_logd("d->expr: %p\n", d->expr); + + d->expr = NULL; + d->expr_local_flag++; + + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_rp"), SCF_DFA_HOOK_POST); + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_comma"), SCF_DFA_HOOK_POST); + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_lp_stat"), SCF_DFA_HOOK_POST); + + return SCF_DFA_NEXT_WORD; +} + +static int _new_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]; + new_module_data_t* md = d->module_datas[dfa_module_new.index]; + + md->nb_rps++; + + scf_logd("md->nb_lps: %d, md->nb_rps: %d\n", md->nb_lps, md->nb_rps); + + if (md->nb_rps < md->nb_lps) { + + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_rp"), SCF_DFA_HOOK_POST); + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_comma"), SCF_DFA_HOOK_POST); + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_lp_stat"), SCF_DFA_HOOK_POST); + + return SCF_DFA_NEXT_WORD; + } + assert(md->nb_rps == md->nb_lps); + + if (d->expr) { + int ret = scf_node_add_child(md->new, d->expr); + d->expr = NULL; + SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "node add child failed\n"); + } + + d->expr = md->parent_expr; + d->expr_local_flag--; + + if (d->expr) { + int ret = scf_expr_add_node(d->expr, md->new); + SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "expr add child failed\n"); + } else + d->expr = md->new; + + md->new = NULL; + + scf_logi("d->expr: %p\n", d->expr); + + return SCF_DFA_NEXT_WORD; +} + +static int _new_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]; + new_module_data_t* md = d->module_datas[dfa_module_new.index]; + + SCF_CHECK_ERROR(!d->expr, SCF_DFA_ERROR, "\n"); + + int ret = scf_node_add_child(md->new, d->expr); + d->expr = NULL; + SCF_CHECK_ERROR(ret < 0, SCF_DFA_ERROR, "node add child failed\n"); + + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_comma"), SCF_DFA_HOOK_POST); + SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "new_lp_stat"), SCF_DFA_HOOK_POST); + + return SCF_DFA_SWITCH_TO; +} + +static int _dfa_init_module_new(scf_dfa_t* dfa) +{ + SCF_DFA_MODULE_NODE(dfa, new, new, _new_is_new, _new_action_new); + SCF_DFA_MODULE_NODE(dfa, new, identity, scf_dfa_is_identity, _new_action_identity); + + SCF_DFA_MODULE_NODE(dfa, new, lp, scf_dfa_is_lp, _new_action_lp); + SCF_DFA_MODULE_NODE(dfa, new, rp, scf_dfa_is_rp, _new_action_rp); + SCF_DFA_MODULE_NODE(dfa, new, lp_stat, scf_dfa_is_lp, _new_action_lp_stat); + SCF_DFA_MODULE_NODE(dfa, new, comma, scf_dfa_is_comma, _new_action_comma); + + scf_parse_t* parse = dfa->priv; + dfa_data_t* d = parse->dfa_data; + new_module_data_t* md = d->module_datas[dfa_module_new.index]; + + assert(!md); + + md = calloc(1, sizeof(new_module_data_t)); + if (!md) { + scf_loge("\n"); + return SCF_DFA_ERROR; + } + + d->module_datas[dfa_module_new.index] = md; + + return SCF_DFA_OK; +} + +static int _dfa_fini_module_new(scf_dfa_t* dfa) +{ + scf_parse_t* parse = dfa->priv; + dfa_data_t* d = parse->dfa_data; + new_module_data_t* md = d->module_datas[dfa_module_new.index]; + + if (md) { + free(md); + md = NULL; + d->module_datas[dfa_module_new.index] = NULL; + } + + return SCF_DFA_OK; +} + +static int _dfa_init_syntax_new(scf_dfa_t* dfa) +{ + SCF_DFA_GET_MODULE_NODE(dfa, new, new, new); + SCF_DFA_GET_MODULE_NODE(dfa, new, identity, identity); + SCF_DFA_GET_MODULE_NODE(dfa, new, lp, lp); + SCF_DFA_GET_MODULE_NODE(dfa, new, rp, rp); + SCF_DFA_GET_MODULE_NODE(dfa, new, comma, comma); + + SCF_DFA_GET_MODULE_NODE(dfa, expr, entry, expr); + + scf_dfa_node_add_child(new, identity); + scf_dfa_node_add_child(identity, lp); + + scf_dfa_node_add_child(lp, rp); + + scf_dfa_node_add_child(lp, expr); + scf_dfa_node_add_child(expr, comma); + scf_dfa_node_add_child(comma, expr); + scf_dfa_node_add_child(expr, rp); + + return 0; +} + +scf_dfa_module_t dfa_module_new = +{ + .name = "new", + .init_module = _dfa_init_module_new, + .init_syntax = _dfa_init_syntax_new, + + .fini_module = _dfa_fini_module_new, +}; diff --git a/parse/scf_dfa_parse.c b/parse/scf_dfa_parse.c index 495c411..21dfc9b 100644 --- a/parse/scf_dfa_parse.c +++ b/parse/scf_dfa_parse.c @@ -7,7 +7,7 @@ extern scf_dfa_module_t dfa_module_include; extern scf_dfa_module_t dfa_module_identity; extern scf_dfa_module_t dfa_module_expr; -extern scf_dfa_module_t dfa_module_create; +extern scf_dfa_module_t dfa_module_new; extern scf_dfa_module_t dfa_module_call; extern scf_dfa_module_t dfa_module_sizeof; extern scf_dfa_module_t dfa_module_container; @@ -49,7 +49,7 @@ scf_dfa_module_t* dfa_modules[] = &dfa_module_identity, &dfa_module_expr, - &dfa_module_create, + &dfa_module_new, &dfa_module_call, &dfa_module_sizeof, &dfa_module_container, diff --git a/parse/scf_operator_handler_const.c b/parse/scf_operator_handler_const.c index b3bb010..f1dfa57 100644 --- a/parse/scf_operator_handler_const.c +++ b/parse/scf_operator_handler_const.c @@ -109,7 +109,7 @@ static int _scf_expr_calculate_internal(scf_ast_t* ast, scf_node_t* node, void* return 0; } -static int _scf_op_const_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) +static int _scf_op_const_new(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) { assert(nb_nodes > 3); @@ -923,7 +923,7 @@ scf_operator_handler_pt const_operator_handlers[SCF_N_OPS] = [SCF_OP_ARRAY_INDEX] = _scf_op_const_array_index, [SCF_OP_POINTER ] = _scf_op_const_pointer, - [SCF_OP_CREATE ] = _scf_op_const_create, + [SCF_OP_NEW ] = _scf_op_const_new, [SCF_OP_VA_START ] = _scf_op_const_va_start, [SCF_OP_VA_ARG ] = _scf_op_const_va_arg, diff --git a/parse/scf_operator_handler_semantic.c b/parse/scf_operator_handler_semantic.c index 9e1974e..e05302e 100644 --- a/parse/scf_operator_handler_semantic.c +++ b/parse/scf_operator_handler_semantic.c @@ -479,7 +479,7 @@ static int _semantic_do_overloaded_assign(scf_ast_t* ast, scf_node_t** nodes, in return ret; } -static int _semantic_do_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, scf_handler_data_t* d) +static int _semantic_do_new(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, scf_handler_data_t* d) { scf_variable_t* v0; scf_variable_t* v_pf; @@ -489,7 +489,7 @@ static int _semantic_do_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, scf_node_t* parent = nodes[0]->parent; scf_node_t* node0 = nodes[0]; scf_node_t* node1 = nodes[1]; - scf_node_t* create = NULL; + scf_node_t* new = NULL; scf_node_t* node_pf = NULL; v0 = _scf_operand_get(nodes[0]); @@ -503,8 +503,8 @@ static int _semantic_do_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, assert(t); assert(pt); - create = scf_node_alloc(parent->w, SCF_OP_CREATE, NULL); - if (!create) + new = scf_node_alloc(parent->w, SCF_OP_NEW, NULL); + if (!new) return -ENOMEM; v_pf = SCF_VAR_ALLOC_BY_TYPE(t->w, pt, 1, 1, NULL); @@ -516,15 +516,15 @@ static int _semantic_do_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, if (!node_pf) return -ENOMEM; - ret = scf_node_add_child(create, node_pf); + ret = scf_node_add_child(new, node_pf); if (ret < 0) return ret; - ret = scf_node_add_child(create, node1); + ret = scf_node_add_child(new, node1); if (ret < 0) return ret; - create->parent = parent; - parent->nodes[1] = create; + new->parent = parent; + parent->nodes[1] = new; b = scf_block_alloc_cstr("multi_rets"); if (!b) @@ -719,7 +719,7 @@ static int _semantic_add_var(scf_node_t** pp, scf_ast_t* ast, scf_node_t* parent return 0; } -static int _scf_op_semantic_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) +static int _scf_op_semantic_new(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) { assert(nb_nodes >= 1); @@ -2645,7 +2645,7 @@ static int _semantic_multi_rets_assign(scf_ast_t* ast, scf_node_t** nodes, int n break; } - if (SCF_OP_CALL != call->type && SCF_OP_CREATE != call->type) { + if (SCF_OP_CALL != call->type && SCF_OP_NEW != call->type) { scf_loge("\n"); return -1; } @@ -2821,7 +2821,7 @@ static int _scf_op_semantic_assign(scf_ast_t* ast, scf_node_t** nodes, int nb_no if (scf_scope_find_function(t->scope, "__init")) { - int ret = _semantic_do_create(ast, nodes, nb_nodes, d); + int ret = _semantic_do_new(ast, nodes, nb_nodes, d); if (0 == ret) return 0; @@ -3148,7 +3148,7 @@ scf_operator_handler_pt semantic_operator_handlers[SCF_N_OPS] = [SCF_OP_ARRAY_INDEX] = _scf_op_semantic_array_index, [SCF_OP_POINTER ] = _scf_op_semantic_pointer, - [SCF_OP_CREATE ] = _scf_op_semantic_create, + [SCF_OP_NEW ] = _scf_op_semantic_new, [SCF_OP_VA_START ] = _scf_op_semantic_va_start, [SCF_OP_VA_ARG ] = _scf_op_semantic_va_arg,