<script>
-function P(x)
-{
- this.x = x;
-}
+var a = Math.PI;
-var a = create P(1);
-
-document.write(a.x);
+document.write(Math.sqrt(a));
</script>
CFILES += ../js/parse/scf_dfa_include.c
CFILES += ../js/parse/scf_dfa_call.c
-CFILES += ../js/parse/scf_dfa_create.c
+CFILES += ../js/parse/scf_dfa_new.c
CFILES += ../js/parse/scf_dfa_sizeof.c
CFILES += ../js/parse/scf_dfa_container.c
CFILES += ../js/parse/scf_dfa_va_arg.c
SCF_OP_CALL, // () function call
SCF_OP_TYPE_CAST, // (char*) type cast
- SCF_OP_CREATE, // create
+ SCF_OP_NEW, // new
SCF_OP_SIZEOF, // sizeof
SCF_OP_CONTAINER, // container_of
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
int nb_nodes; // children nodes count
scf_node_t** nodes; // children nodes
- scf_expr_t* js_create; // the expr which created this node, only for js!
+ scf_expr_t* js_new; // the expr which created this node, only for js!
union {
scf_variable_t* var;
{"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,
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* Boolean(Object* this)
{
- Object* res = create Object();
+ Object* res = new Object();
if (!res)
return NULL;
Object* Boolean(Object* this, int64_t i)
{
- Object* res = create Object();
+ Object* res = new Object();
if (!res)
return NULL;
Object* Boolean(Object* this, Object* that)
{
- Object* res = create Object();
+ Object* res = new Object();
if (!res)
return NULL;
Object* Date(Object* this)
{
- Object* res = create Object(0);
+ Object* res = new Object(0);
if (!res)
return NULL;
void write(Object* this, double d)
{
- abc_html_write_i(this, d);
+ abc_html_write_d(this, d);
}
Object* operator+(Object* this, Object* that)
{
- Object* res = create Object(this->d + that->d);
+ Object* res = new Object(this->d + that->d);
return res;
}
// printf("\n");
}
+
+ Object* Math_sqrt(Object* this, double d)
+ {
+ Object* res = new Object(sqrt(d));
+ return res;
+ }
+
+ Object* Math_sqrt(Object* this, Object* obj)
+ {
+ Object* res = new Object(sqrt(obj->d));
+ return res;
+ }
};
+const double Math_PI = 3.1415926;
+
void Object_func_arguments(Object* this, int i, Object* arg)
{
if (i < this->length) {
{"goto", SCF_LEX_WORD_KEY_GOTO},
{"sizeof", SCF_LEX_WORD_KEY_SIZEOF},
-
- {"create", SCF_LEX_WORD_KEY_CREATE},
+ {"new", SCF_LEX_WORD_KEY_NEW},
{"operator", SCF_LEX_WORD_KEY_OPERATOR},
return 0;
}
+static int __lex_math(scf_lex_t* lex, scf_lex_word_t* w)
+{
+ scf_lex_word_t* w1 = NULL;
+ scf_lex_word_t* w2 = NULL;
+
+ int ret = __lex_pop_word(lex, &w1);
+ if (ret < 0)
+ return ret;
+
+ if (SCF_LEX_WORD_DOT != w1->type) {
+ scf_loge("needs '.' after 'Math', file: %s, line: %d\n", w1->file->data, w1->line);
+
+ scf_lex_word_free(w1);
+ return -1;
+ }
+ scf_lex_word_free(w1);
+ w1 = NULL;
+
+ ret = scf_string_cat_cstr_len(w->text, "_", 1);
+ if (ret < 0)
+ return ret;
+
+ ret = __lex_pop_word(lex, &w2);
+ if (ret < 0)
+ return ret;
+
+ if (SCF_LEX_WORD_ID != w2->type) {
+ scf_loge("needs an identity (but '%s') after 'Math.', file: %s, line: %d\n", w2->text->data, w2->file->data, w2->line);
+
+ scf_lex_word_free(w2);
+ return -1;
+ }
+
+ ret = scf_string_cat(w->text, w2->text);
+
+ scf_lex_word_free(w2);
+ return ret;
+}
+
int scf_lex_pop_word(scf_lex_t* lex, scf_lex_word_t** pword)
{
if (!lex || (!lex->fp && !lex->text) || !pword)
scf_lex_word_t* w = NULL;
scf_lex_word_t* w1 = NULL;
+ scf_lex_word_t* w2 = NULL;
int ret = __lex_pop_word(lex, &w);
if (ret < 0)
return ret;
+ if (!strcmp(w->text->data, "Math")) {
+ ret = __lex_math(lex, w);
+
+ if (ret < 0) {
+ scf_lex_word_free(w);
+ return ret;
+ }
+ }
+
// parse macro
while (SCF_LEX_WORD_HASH == w->type) {
int memcpy (void* dst, const void* src, uintptr_t n);
int memcmp (void* dst, const void* src, uintptr_t n);
+double sqrt(double d);
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;
{
string* s;
- s = create string();
+ s = new string();
if (!s)
return NULL, -1;
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
{
"/lib64/ld-linux-x86-64.so.2",
"libc.so.6",
+ "libm.so.6",
};
static char* __arm64_objs[] =
scf_variable_t* v;
scf_block_t* b;
scf_type_t* pt = scf_block_find_type_type(ast->current_block, SCF_FUNCTION_PTR);
- scf_node_t* create;
+ scf_node_t* new;
scf_node_t* assign;
scf_node_t* node;
scf_node_t* arguments;
}
b = NULL;
- // add create()
- create = scf_node_alloc(w, SCF_OP_CREATE, NULL);
- if (!create) {
+ // add new()
+ new = scf_node_alloc(w, SCF_OP_NEW, NULL);
+ if (!new) {
scf_node_free(assign);
return -ENOMEM;
}
- ret = scf_node_add_child(assign, create);
+ ret = scf_node_add_child(assign, new);
if (ret < 0) {
- scf_node_free(create);
+ scf_node_free(new);
scf_node_free(assign);
return ret;
}
return -ENOMEM;
}
- ret = scf_node_add_child(create, node);
+ ret = scf_node_add_child(new, node);
if (ret < 0) {
scf_node_free(node);
scf_node_free(assign);
}
// add obj name
- ret = scf_ast_add_const_str(ast, create, Object->w);
+ ret = scf_ast_add_const_str(ast, new, Object->w);
if (ret < 0) {
scf_node_free(assign);
return ret;
}
// add obj members
- ret = scf_ast_add_const_var(ast, create, SCF_VAR_INT, n_members);
+ ret = scf_ast_add_const_var(ast, new, SCF_VAR_INT, n_members);
if (ret < 0) {
scf_node_free(assign);
return ret;
return ret;
}
- e->js_create = e2;
+ e->js_new = e2;
return 0;
}
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);
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);
#include"scf_parse.h"
#include"scf_stack.h"
-extern scf_dfa_module_t dfa_module_create;
+extern scf_dfa_module_t dfa_module_new;
typedef struct {
int nb_lps;
int nb_rps;
- scf_node_t* create;
+ scf_node_t* new;
scf_expr_t* parent_expr;
-} create_module_data_t;
+} new_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)
+static int _new_is_new(scf_dfa_t* dfa, void* word)
{
scf_lex_word_t* w = word;
- return SCF_LEX_WORD_KEY_CREATE == w->type;
+ return SCF_LEX_WORD_KEY_NEW == w->type;
}
static int __js_init_func(scf_ast_t* ast, scf_function_t* f)
scf_type_t* pt = NULL;
scf_node_t* node;
scf_node_t* assign;
- scf_node_t* create;
+ scf_node_t* new;
scf_node_t* _return;
scf_expr_t* e;
scf_block_t* b;
f->argv->data[0] = that;
scf_scope_push_var(f->scope, that);
- // this = create Object()
+ // this = new Object()
// add 'this'
node = scf_node_alloc(NULL, this->type, this);
if (!node)
return ret;
}
- // add 'create'
- create = scf_node_alloc(this->w, SCF_OP_CREATE, NULL);
- if (!create) {
+ // add 'new'
+ new = scf_node_alloc(this->w, SCF_OP_NEW, NULL);
+ if (!new) {
scf_node_free(assign);
return -ENOMEM;
}
- ret = scf_node_add_child(assign, create);
+ ret = scf_node_add_child(assign, new);
if (ret < 0) {
- scf_node_free(create);
+ scf_node_free(new);
scf_node_free(assign);
return ret;
}
return -ENOMEM;
}
- ret = scf_node_add_child(create, node);
+ ret = scf_node_add_child(new, node);
if (ret < 0) {
scf_node_free(node);
scf_node_free(assign);
return 0;
}
-static int _create_action_lp_stat(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+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_create.index];
- create_module_data_t* md = d->module_datas[dfa_module_create.index];
+ 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, "create_lp_stat"), 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 _create_action_create(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+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];
- 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];
+ new_module_data_t* md = d->module_datas[dfa_module_new.index];
- SCF_CHECK_ERROR(md->create, SCF_DFA_ERROR, "\n");
+ SCF_CHECK_ERROR(md->new, SCF_DFA_ERROR, "\n");
- md->create = scf_node_alloc(w, SCF_OP_CREATE, NULL);
- if (!md->create)
+ md->new = scf_node_alloc(w, SCF_OP_NEW, NULL);
+ if (!md->new)
return SCF_DFA_ERROR;
md->nb_lps = 0;
return SCF_DFA_NEXT_WORD;
}
-static int _create_action_identity(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+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];
- scf_function_t* f = NULL;
- 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];
+ scf_function_t* f = NULL;
+ new_module_data_t* md = d->module_datas[dfa_module_new.index];
scf_type_t* t = NULL;
scf_type_t* pt = NULL;
if (f && f->js_flag) {
t->node.js_flag = 1;
- md->create->js_flag = 1;
+ md->new->js_flag = 1;
if (!f->init_flag) {
if (__js_init_func(parse->ast, f) < 0)
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);
+ 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->create);
+ 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->create;
+ d->expr = md->new;
- md->create = NULL;
+ md->new = 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)
+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];
- 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];
+ 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, "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);
+ 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 _create_action_rp(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+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];
- create_module_data_t* md = d->module_datas[dfa_module_create.index];
- scf_type_t* Object = NULL;
+ 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* Object = NULL;
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);
+ 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) {
- if (md->create->js_flag) {
+ if (md->new->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);
+ ret = _call_add_obj(parse->ast, w, md->new, d->expr, Object);
if (ret < 0)
return ret;
}
- int ret = scf_node_add_child(md->create, 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 (md->create->js_flag)
- md->create->type = SCF_OP_CALL;
+ if (md->new->js_flag)
+ md->new->type = SCF_OP_CALL;
if (d->expr) {
- int ret = scf_expr_add_node(d->expr, md->create);
+ 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->create;
+ d->expr = md->new;
- md->create = NULL;
+ md->new = 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)
+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];
- create_module_data_t* md = d->module_datas[dfa_module_create.index];
- scf_type_t* Object = NULL;
+ 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* Object = NULL;
SCF_CHECK_ERROR(!d->expr, SCF_DFA_ERROR, "\n");
- if (md->create->js_flag) {
+ if (md->new->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);
+ ret = _call_add_obj(parse->ast, w, md->new, d->expr, Object);
if (ret < 0)
return ret;
}
- int ret = scf_node_add_child(md->create, 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");
- 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);
+ 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_create(scf_dfa_t* dfa)
+static int _dfa_init_module_new(scf_dfa_t* dfa)
{
- SCF_DFA_MODULE_NODE(dfa, create, create, _create_is_create, _create_action_create);
+ 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, create, identity, scf_dfa_is_identity, _create_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_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];
+ 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(create_module_data_t));
+ md = calloc(1, sizeof(new_module_data_t));
if (!md) {
scf_loge("\n");
return SCF_DFA_ERROR;
}
- d->module_datas[dfa_module_create.index] = md;
+ d->module_datas[dfa_module_new.index] = md;
return SCF_DFA_OK;
}
-static int _dfa_fini_module_create(scf_dfa_t* dfa)
+static int _dfa_fini_module_new(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];
+ 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_create.index] = NULL;
+ d->module_datas[dfa_module_new.index] = NULL;
}
return SCF_DFA_OK;
}
-static int _dfa_init_syntax_create(scf_dfa_t* dfa)
+static int _dfa_init_syntax_new(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, 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_GET_MODULE_NODE(dfa, expr, entry, expr);
- scf_dfa_node_add_child(create, identity);
+ scf_dfa_node_add_child(new, identity);
scf_dfa_node_add_child(identity, lp);
scf_dfa_node_add_child(lp, rp);
return 0;
}
-scf_dfa_module_t dfa_module_create =
+scf_dfa_module_t dfa_module_new =
{
- .name = "create",
- .init_module = _dfa_init_module_create,
- .init_syntax = _dfa_init_syntax_create,
+ .name = "new",
+ .init_module = _dfa_init_module_new,
+ .init_syntax = _dfa_init_syntax_new,
- .fini_module = _dfa_fini_module_create,
+ .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,
d->expr->nodes[0] = node0;
node0->parent = d->expr;
+ if (d->current_var->const_flag) {
+ scf_variable_t* r = NULL;
+
+ int ret = scf_expr_calculate(parse->ast, d->expr, &r);
+
+ scf_expr_free(d->expr);
+ d->expr = NULL;
+ if (ret < 0)
+ return SCF_DFA_ERROR;
+
+ if (!scf_variable_const(r)) {
+ scf_loge("\n");
+ scf_variable_free(r);
+ return SCF_DFA_ERROR;
+ }
+
+ scf_variable_free(r);
+ return 0;
+ }
+
scf_node_add_child((scf_node_t*)parse->ast->current_block, (scf_node_t*)d->expr);
scf_logd("d->expr->parent->type: %d\n", d->expr->parent->type);
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);
parent->nodes[i - 1] = NULL;
parent->nb_nodes--;
- assert(arguments->js_create);
- arguments->js_create->_3ac_done = 1;
+ assert(arguments->js_new);
+ arguments->js_new->_3ac_done = 1;
scf_node_free(arguments);
arguments = NULL;
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")) {
- ret = _semantic_do_create(ast, nodes, nb_nodes, d);
+ 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,
#include"scf_dfa.h"
#include"scf_parse.h"
-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,
+static int __object_new(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)
{
scf_variable_t* v;
scf_block_t* b;
scf_type_t* pt = scf_block_find_type_type(ast->current_block, SCF_FUNCTION_PTR);
- scf_node_t* create;
+ scf_node_t* new;
scf_node_t* assign;
scf_node_t* node;
assign->nodes[0] = (scf_node_t*)b;
b->node.parent = assign;
- create = scf_node_alloc(w, SCF_OP_CREATE, NULL);
- if (!create)
+ new = scf_node_alloc(w, SCF_OP_NEW, NULL);
+ if (!new)
return -ENOMEM;
// add construct() for obj
v = SCF_VAR_ALLOC_BY_TYPE(Object->w, pt, 1, 1, NULL);
if (!v) {
- scf_node_free(create);
+ scf_node_free(new);
return -ENOMEM;
}
v->const_literal_flag = 1;
scf_variable_free(v);
v = NULL;
if (!node) {
- scf_node_free(create);
+ scf_node_free(new);
return -ENOMEM;
}
- ret = scf_node_add_child(create, node);
+ ret = scf_node_add_child(new, node);
if (ret < 0) {
scf_node_free(node);
- scf_node_free(create);
+ scf_node_free(new);
return ret;
}
// add obj name
- ret = scf_ast_add_const_str(ast, create, var->w);
+ ret = scf_ast_add_const_str(ast, new, var->w);
if (ret < 0) {
- scf_node_free(create);
+ scf_node_free(new);
return ret;
}
// add obj members
- ret = scf_ast_add_const_var(ast, create, SCF_VAR_INT, n_members);
+ ret = scf_ast_add_const_var(ast, new, SCF_VAR_INT, n_members);
if (ret < 0) {
- scf_node_free(create);
+ scf_node_free(new);
return ret;
}
scf_logi("var: %s\n", var->w->text->data);
- ret = scf_node_add_child(create, ie->expr);
+ ret = scf_node_add_child(new, ie->expr);
if (ret < 0) {
- scf_node_free(create);
+ scf_node_free(new);
return ret;
}
}
}
- ret = scf_expr_add_node(e, create);
+ ret = scf_expr_add_node(e, new);
if (ret < 0) {
- scf_node_free(create);
+ scf_node_free(new);
return ret;
}
return 0;
var->w->text->data, array_dim, obj->nb_dimentions,
obj->dimentions[array_dim].num);
- ret = __object_create(e, ast, w, var, obj->dimentions[array_dim].num, Object, NULL, NULL);
+ ret = __object_new(e, ast, w, var, obj->dimentions[array_dim].num, Object, NULL, NULL);
} else if (t->type >= SCF_STRUCT) {
scf_logd("var: %s\n", var->w->text->data);
- ret = __object_create(e, ast, w, var, t->scope->vars->size, Object, NULL, NULL);
+ ret = __object_new(e, ast, w, var, t->scope->vars->size, Object, NULL, NULL);
} else {
scf_logd("var: %s\n", var->w->text->data);
- ret = __object_create(e, ast, w, var, 0, Object, init_exprs, init_pos);
+ ret = __object_new(e, ast, w, var, 0, Object, init_exprs, init_pos);
}
if (ret < 0) {
scf_expr_free(e);
CFILES += ../js/parse/scf_dfa_include.c
CFILES += ../js/parse/scf_dfa_call.c
-CFILES += ../js/parse/scf_dfa_create.c
+CFILES += ../js/parse/scf_dfa_new.c
CFILES += ../js/parse/scf_dfa_sizeof.c
CFILES += ../js/parse/scf_dfa_container.c
CFILES += ../js/parse/scf_dfa_va_arg.c
projects / abc.git / commitdiff