}
#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)) {
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];
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
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)
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
{"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},
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) {
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);
{
[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,
&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,
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];
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];
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;
}
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;
}
Object* operator+(Object* this, Object* that)
{
- Object* res = create Object(this->d + that->d);
+ Object* res = new Object(this->d + that->d);
return res;
}
};
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);
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;
{
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;
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;
str* p0;
int err;
- p0, err = create str();
+ p0, err = new str();
if (err < 0)
return -1;
str* p0;
str* p1;
- p0 = create str();
+ p0 = new str();
p1 = p0;
printf("%s\n", p1->data);
{
string* s;
- s = create string();
+ s = new string();
if (!s)
return NULL, -1;
{"sizeof", SCF_LEX_WORD_KEY_SIZEOF},
- {"create", SCF_LEX_WORD_KEY_CREATE},
+ {"new", SCF_LEX_WORD_KEY_NEW},
{"operator", SCF_LEX_WORD_KEY_OPERATOR},
complex* res;
- res = create complex(0.0, 0.0);
+ res = new complex(0.0, 0.0);
if (!res)
return NULL, -1;
complex* res;
- res = create complex(0.0, 0.0);
+ res = new complex(0.0, 0.0);
if (!res)
return NULL, -1;
complex* res;
- res = create complex(0.0, 0.0);
+ res = new complex(0.0, 0.0);
if (!res)
return NULL, -1;
complex* res;
- res = create complex(0.0, 0.0);
+ res = new complex(0.0, 0.0);
if (!res)
return NULL, -1;
return res, 0;
}
};
-
-
{
string* s;
- s = create string();
+ s = new string();
if (!s)
return NULL, -1;
scf__auto_freep(&this->data, NULL);
}
};
-
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
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);
+++ /dev/null
-#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,
-};
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;
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);
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);
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);
--- /dev/null
+#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,
+};
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;
&dfa_module_identity,
&dfa_module_expr,
- &dfa_module_create,
+ &dfa_module_new,
&dfa_module_call,
&dfa_module_sizeof,
&dfa_module_container,
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);
[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,
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;
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]);
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);
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)
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);
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;
}
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;
[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,
projects / scf.git / commitdiff