return 0;
}
+static int _find_typedef_by_name(scf_node_t* node, void* arg, scf_vector_t* vec)
+{
+ if (SCF_FUNCTION == node->type)
+ return 1;
+
+ if (node->class_flag)
+ return 1;
+
+ if (SCF_OP_BLOCK == node->type) {
+
+ scf_block_t* b = (scf_block_t*)node;
+
+ if (!b->scope)
+ return 0;
+
+ scf_variable_t* v = scf_scope_find_typedef(b->scope, arg);
+ if (!v)
+ return 0;
+
+ assert(!v->local_flag && !v->member_flag);
+
+ if (v->static_flag)
+ return 0;
+
+ return scf_vector_add(vec, v);
+ }
+ return 0;
+}
+
int scf_ast_find_global_function(scf_function_t** pf, scf_ast_t* ast, char* fname)
{
scf_vector_t* vec = scf_vector_alloc();
return 0;
}
+int scf_ast_find_global_typedef(scf_variable_t** pv, scf_ast_t* ast, char* name)
+{
+ scf_vector_t* vec = scf_vector_alloc();
+ if (!vec)
+ return -ENOMEM;
+
+ int ret = scf_node_search_bfs((scf_node_t*)ast->root_block, name, vec, -1, _find_type_by_name);
+ if (ret < 0) {
+ scf_vector_free(vec);
+ return ret;
+ }
+
+ if (0 == vec->size) {
+ *pv = NULL;
+ scf_vector_free(vec);
+ return 0;
+ }
+
+ scf_variable_t* v2 = vec->data[0];
+ scf_variable_t* v;
+ int n = 0;
+ int i;
+ for (i = 0; i < vec->size; i++) {
+ v = vec->data[i];
+
+ if (!v->extern_flag) {
+ v2 = v;
+ n++;
+ }
+ }
+
+ if (n > 1) {
+ for (i = 0; i < vec->size; i++) {
+ v = vec->data[i];
+
+ if (!v->extern_flag)
+ scf_loge("multi-define: '%s' in file: %s, line: %d\n", name, v->w->file->data, v->w->line);
+ }
+
+ scf_vector_free(vec);
+ return -1;
+ }
+
+ *pv = v2;
+
+ scf_vector_free(vec);
+ return 0;
+}
+
static int _type_check(scf_type_t** pt, scf_vector_t* vec)
{
scf_type_t* t2 = vec->data[0];
return scf_ast_find_global_variable(pv, ast, name);
}
+int scf_ast_find_typedef(scf_variable_t** pv, scf_ast_t* ast, char* name)
+{
+ *pv = scf_block_find_typedef(ast->current_block, name);
+ if (*pv)
+ return 0;
+
+ return scf_ast_find_global_typedef(pv, ast, name);
+}
+
int scf_ast_find_type(scf_type_t** pt, scf_ast_t* ast, char* name)
{
*pt = scf_block_find_type(ast->current_block, name);
int scf_ast_find_proper_function (scf_function_t** pf, scf_ast_t* ast, scf_vector_t* fvec, scf_vector_t* argv);
int scf_ast_find_global_function (scf_function_t** pf, scf_ast_t* ast, char* name);
int scf_ast_find_global_variable (scf_variable_t** pv, scf_ast_t* ast, char* name);
+
+int scf_ast_find_global_typedef (scf_variable_t** pv, scf_ast_t* ast, char* name);
int scf_ast_find_global_type (scf_type_t** pt, scf_ast_t* ast, char* name);
int scf_ast_find_global_type_type(scf_type_t** pt, scf_ast_t* ast, int type);
int scf_ast_find_function (scf_function_t** pf, scf_ast_t* ast, char* name);
int scf_ast_find_variable (scf_variable_t** pv, scf_ast_t* ast, char* name);
+
+int scf_ast_find_typedef (scf_variable_t** pv, scf_ast_t* ast, char* name);
int scf_ast_find_type (scf_type_t** pt, scf_ast_t* ast, char* name);
int scf_ast_find_type_type(scf_type_t** pt, scf_ast_t* ast, int type);
return NULL;
}
+scf_variable_t* scf_block_find_typedef(scf_block_t* b, const char* name)
+{
+ assert(b);
+ while (b) {
+ if (SCF_OP_BLOCK == b->node.type || SCF_FUNCTION == b->node.type || b->node.type >= SCF_STRUCT) {
+
+ if (b->scope) {
+ scf_variable_t* v = scf_scope_find_typedef(b->scope, name);
+ if (v)
+ return v;
+ }
+ }
+ b = (scf_block_t*)(b->node.parent);
+ }
+ return NULL;
+}
+
scf_variable_t* scf_block_find_variable(scf_block_t* b, const char* name)
{
assert(b);
};
-scf_block_t* scf_block_alloc(scf_lex_word_t* w);
+scf_block_t* scf_block_alloc(scf_lex_word_t* w);
-scf_block_t* scf_block_alloc_cstr(const char* name);
+scf_block_t* scf_block_alloc_cstr(const char* name);
-void scf_block_free(scf_block_t* b);
+void scf_block_free(scf_block_t* b);
-scf_type_t* scf_block_find_type(scf_block_t* b, const char* name);
+scf_type_t* scf_block_find_type (scf_block_t* b, const char* name);
+scf_type_t* scf_block_find_type_type(scf_block_t* b, const int type);
+scf_variable_t* scf_block_find_typedef (scf_block_t* b, const char* name);
-scf_type_t* scf_block_find_type_type(scf_block_t* b, const int type);
+scf_variable_t* scf_block_find_variable(scf_block_t* b, const char* name);
-scf_variable_t* scf_block_find_variable(scf_block_t* b, const char* name);
+scf_function_t* scf_block_find_function(scf_block_t* b, const char* name);
-scf_function_t* scf_block_find_function(scf_block_t* b, const char* name);
-
-scf_label_t* scf_block_find_label(scf_block_t* b, const char* name);
+scf_label_t* scf_block_find_label(scf_block_t* b, const char* name);
#endif
scf_string_t* signature;
+ scf_vector_t* typedef_vars;
+
scf_list_t list; // for scope
scf_vector_t* rets; // return values
SCF_LEX_WORD_KEY_VA_START, // va_start
SCF_LEX_WORD_KEY_VA_END, // va_end
- // class
SCF_LEX_WORD_KEY_CLASS, // class
SCF_LEX_WORD_KEY_TYPEDEF, // typedef
return NULL;
}
+ scope->typedef_vars = scf_vector_alloc();
+ if (!scope->typedef_vars) {
+ scf_vector_free(scope->vars);
+ free(scope);
+ return NULL;
+ }
+
scf_list_init(&scope->list);
scf_list_init(&scope->types);
scf_list_init(&scope->operators);
return scope;
}
-void scf_scope_push_var(scf_scope_t* scope, scf_variable_t* var)
+int scf_scope_push_var(scf_scope_t* scope, scf_variable_t* var)
{
scf_vector_add(scope->vars, var);
}
return NULL;
}
+scf_variable_t* scf_scope_find_typedef(scf_scope_t* scope, const char* name)
+{
+ scf_variable_t* v;
+ int i;
+
+ for (i = 0; i < scope->typedef_vars->size; i++) {
+ v = scope->typedef_vars->data[i];
+
+ if (v->w && !strcmp(name, v->w->text->data))
+ return v;
+ }
+ return NULL;
+}
+
scf_variable_t* scf_scope_find_variable(scf_scope_t* scope, const char* name)
{
scf_variable_t* v;
{
scf_list_t list; // scope list
- scf_vector_t* vars; // vars in this scope, should not have the same name
- scf_list_t types; // type list in this scope, not define the same type
- scf_list_t operators; // operator list in this scope
- scf_list_t functions; // function list in this scope
- scf_list_t labels; // label list in this scope
+ scf_vector_t* vars; // vars in this scope, should not have the same name
+ scf_list_t types; // type list in this scope, not define the same type
+ scf_list_t operators; // operator list in this scope
+ scf_list_t functions; // function list in this scope
+ scf_list_t labels; // label list in this scope
+
+ scf_vector_t* typedef_vars; // typedef vars for type alias name
};
scf_scope_t* scf_scope_alloc();
void scf_scope_free(scf_scope_t* scope);
-void scf_scope_push_var (scf_scope_t* scope, scf_variable_t* var);
+int scf_scope_push_var (scf_scope_t* scope, scf_variable_t* var);
void scf_scope_push_type(scf_scope_t* scope, scf_type_t* t);
void scf_scope_push_operator(scf_scope_t* scope, scf_function_t* op);
scf_type_t* scf_scope_find_type (scf_scope_t* scope, const char* name);
scf_type_t* scf_scope_find_type_type(scf_scope_t* scope, const int type);
+scf_variable_t* scf_scope_find_typedef (scf_scope_t* scope, const char* name);
scf_variable_t* scf_scope_find_variable (scf_scope_t* scope, const char* name);
scf_function_t* scf_scope_find_function (scf_scope_t* scope, const char* name);
scf_scope_t* scope;
scf_string_t* name;
+ scf_vector_t* typedef_vars;
+
// list for scope's type_list_head
scf_list_t list;
uint32_t static_flag :1;
uint32_t extern_flag :1;
uint32_t extra_flag :1;
+ uint32_t typedef_flag:1;
uint32_t tmp_flag :1;
uint32_t local_flag :1;
--- /dev/null
+int printf(const char* fmt, ...);
+
+typedef int (*pf_t[2])(const char* fmt, ...);
+
+int main()
+{
+ pf_t pf = {printf, printf};
+
+ pf[0]("hello world\n");
+ return 0;
+}
--- /dev/null
+int printf(const char* fmt, ...);
+
+struct a_s;
+
+int main()
+{
+ a_s* p = NULL;
+
+ printf("a_s* p: %p\n", p);
+ return 0;
+}
--- /dev/null
+int printf(const char* fmt, ...);
+
+typedef struct a_s {
+ int x;
+} a_t, *a_p;
+
+typedef a_t a2_t[2];
+
+typedef int* intptr;
+
+int main()
+{
+ a2_t a = {{1}, {2}};
+ a_p p = &a[1];
+
+ int i = 3;
+ intptr pi = &i;
+
+ printf("typedef p: %p, p->x: %d, pi: %p, *pi: %d\n", p, p->x, pi, *pi);
+ return 0;
+}
--- /dev/null
+int printf(const char* fmt, ...);
+
+typedef int (*add_pt)(int a, int b);
+
+int add(int a, int b)
+{
+ return a + b;
+}
+
+int main()
+{
+ add_pt f = add;
+
+ printf("typedef f: %p, f(1, 2): %d\n", f, f(1, 2));
+ return 0;
+}
if (x64_inst_data_is_reg(&inst->dst))
__x64_peep_mov_by_lea(inst, std);
+
+ std->nb_used++;
break;
} else if (scf_inst_data_same(&std->src, &inst->src))
int nb_lbs;
int nb_rbs;
-} dfa_class_data_t;
-static int _class_is_class(scf_dfa_t* dfa, void* word)
-{
- scf_lex_word_t* w = word;
+ uint8_t typedef_flag:1;
+} dfa_class_data_t;
- return SCF_LEX_WORD_KEY_CLASS == w->type
- || SCF_LEX_WORD_KEY_STRUCT == w->type
- || SCF_LEX_WORD_KEY_UNION == w->type;
-}
static int _class_action_lb(scf_dfa_t* dfa, scf_vector_t* words, void* data)
{
scf_stack_t* s = d->module_datas[dfa_module_class.index];
scf_type_t* t = NULL;
+ while (d->current_identities->size > 0) {
+
+ dfa_identity_t* id = scf_stack_pop(d->current_identities);
+ if (id) {
+ free(id);
+ id = NULL;
+ }
+ }
+
if (SCF_LEX_WORD_ID == key->type) {
t = scf_block_find_type(ast->current_block, key->text->data);
return SCF_DFA_ERROR;
ast->nb_structs++;
+
+ scf_scope_push_type(ast->current_block->scope, t);
+ scf_node_add_child((scf_node_t*)ast->current_block, (scf_node_t*)t);
}
assert(words->size >= 3);
ast->nb_structs++;
+ scf_scope_push_type(ast->current_block->scope, t);
+ scf_node_add_child((scf_node_t*)ast->current_block, (scf_node_t*)t);
+
t->node.anon_flag = 1;
}
if (!t->scope)
t->scope = scf_scope_alloc();
- scf_scope_push_type(ast->current_block->scope, t);
-
switch (key->type)
{
case SCF_LEX_WORD_KEY_STRUCT:
case SCF_LEX_WORD_KEY_UNION:
t->node.union_flag = 1;
break;
+
default:
+ scf_loge("key word '%s' NOT support, file: %s, line: %d\n", key->text->data, key->file->data, key->line);
return SCF_DFA_ERROR;
break;
};
- scf_node_add_child((scf_node_t*)ast->current_block, (scf_node_t*)t);
-
dfa_class_data_t* cd = calloc(1, sizeof(dfa_class_data_t));
if (!cd)
return -ENOMEM;
cd->current_type = t;
cd->nb_lbs++;
+ cd->typedef_flag = d->typedef_flag;
+ d ->typedef_flag = 0;
+
ast->current_block = (scf_block_t*)t;
SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "class_end"), SCF_DFA_HOOK_END);
dfa->ops->push_word(dfa, w);
+ d ->typedef_flag = cd->typedef_flag;
+ cd->typedef_flag = 0;
+
} else if (SCF_LEX_WORD_SEMICOLON == w->type
&& s->size > 1
&& cd->current_type->node.anon_flag) {
return SCF_DFA_NEXT_WORD;
}
+int __class_add_type(scf_ast_t* ast, scf_lex_word_t* key, scf_lex_word_t* name)
+{
+ if (SCF_LEX_WORD_ID == name->type
+ && (SCF_LEX_WORD_KEY_STRUCT == key->type
+ || SCF_LEX_WORD_KEY_UNION == key->type
+ || SCF_LEX_WORD_KEY_CLASS == key->type)) {
+
+ scf_type_t* t = scf_block_find_type(ast->current_block, name->text->data);
+ if (t)
+ return SCF_DFA_OK;
+
+ t = scf_type_alloc(name, name->text->data, SCF_STRUCT + ast->nb_structs, 0);
+ if (!t)
+ return SCF_DFA_ERROR;
+
+ switch (key->type)
+ {
+ case SCF_LEX_WORD_KEY_STRUCT:
+ case SCF_LEX_WORD_KEY_CLASS:
+ t->node.class_flag = 1;
+ break;
+
+ case SCF_LEX_WORD_KEY_UNION:
+ t->node.union_flag = 1;
+ break;
+ default:
+ scf_loge("key word '%s' NOT support, file: %s, line: %d\n", key->text->data, key->file->data, key->line);
+
+ scf_type_free(t);
+ t = NULL;
+ return SCF_DFA_ERROR;
+ break;
+ };
+
+ ast->nb_structs++;
+
+ scf_scope_push_type(ast->current_block->scope, t);
+ scf_node_add_child((scf_node_t*)ast->current_block, (scf_node_t*)t);
+ }
+
+ return SCF_DFA_OK;
+}
+
static int _class_action_semicolon(scf_dfa_t* dfa, scf_vector_t* words, void* data)
{
+ scf_parse_t* parse = dfa->priv;
+ scf_ast_t* ast = parse->ast;
+ scf_lex_word_t* name;
+ scf_lex_word_t* key;
+
+ if (words->size >= 3) {
+ name = words->data[words->size - 2];
+ key = words->data[words->size - 3];
+
+ return __class_add_type(ast, key, name);
+ }
+
return SCF_DFA_OK;
}
static int _dfa_init_module_class(scf_dfa_t* dfa)
{
- SCF_DFA_MODULE_NODE(dfa, class, _class, _class_is_class, NULL);
-
- SCF_DFA_MODULE_NODE(dfa, class, identity, scf_dfa_is_identity, NULL);
SCF_DFA_MODULE_NODE(dfa, class, lb, scf_dfa_is_lb, _class_action_lb);
SCF_DFA_MODULE_NODE(dfa, class, rb, scf_dfa_is_rb, _class_action_rb);
SCF_DFA_MODULE_NODE(dfa, class, semicolon, scf_dfa_is_semicolon, _class_action_semicolon);
static int _dfa_init_syntax_class(scf_dfa_t* dfa)
{
- SCF_DFA_GET_MODULE_NODE(dfa, class, _class, _class);
- SCF_DFA_GET_MODULE_NODE(dfa, class, identity, type_name);
SCF_DFA_GET_MODULE_NODE(dfa, class, lb, lb);
SCF_DFA_GET_MODULE_NODE(dfa, class, rb, rb);
SCF_DFA_GET_MODULE_NODE(dfa, class, end, end);
SCF_DFA_GET_MODULE_NODE(dfa, type, entry, member);
- scf_vector_add(dfa->syntaxes, _class);
-
- // class start
- scf_dfa_node_add_child(_class, type_name);
-
- scf_dfa_node_add_child(type_name, semicolon);
- scf_dfa_node_add_child(type_name, lb);
-
- // anonymous class
- scf_dfa_node_add_child(_class, lb);
+ // class start define in scf_dfa_type.c
// empty class
scf_dfa_node_add_child(lb, rb);
return SCF_DFA_ERROR;
if (!var) {
- scf_logw("var '%s' not found, maybe it's a function\n", w->text->data);
+ scf_logw("var '%s' not found, it may be a function\n", w->text->data);
if (scf_ast_find_type_type(&pt, parse->ast, SCF_FUNCTION_PTR) < 0)
return SCF_DFA_ERROR;
return SCF_DFA_ERROR;
if (!f) {
- scf_loge("function '%s' not found\n", w->text->data);
- return SCF_DFA_ERROR;
+ scf_logw("function '%s' not found, it may be a struct\n", w->text->data);
+ return SCF_DFA_NEXT_SYNTAX;
}
var = SCF_VAR_ALLOC_BY_TYPE(id->identity, pt, 1, 1, f);
if (!d->expr) {
d->expr = scf_expr_alloc();
- if (!d->expr) {
- scf_loge("expr alloc failed\n");
+ if (!d->expr)
return SCF_DFA_ERROR;
- }
}
- scf_logd("d->expr: %p\n", d->expr);
-
return words->size > 0 ? SCF_DFA_CONTINUE : SCF_DFA_NEXT_WORD;
}
dfa_identity_t* id = scf_stack_top(d->current_identities);
if (id && id->identity) {
- if (_expr_add_var(parse, d) < 0)
- return SCF_DFA_ERROR;
+
+ int ret = _expr_add_var(parse, d);
+
+ if (SCF_DFA_OK != ret)
+ return ret;
}
if (md->parent_block) {
scf_parse_t* parse = dfa->priv;
dfa_data_t* d = data;
- if (_expr_fini_expr(parse, d, 0) < 0)
- return SCF_DFA_ERROR;
+ int ret = _expr_fini_expr(parse, d, 0);
+
+ if (SCF_DFA_OK != ret)
+ return ret;
return SCF_DFA_NEXT_WORD;
}
static int _expr_action_semicolon(scf_dfa_t* dfa, scf_vector_t* words, void* data)
{
- scf_parse_t* parse = dfa->priv;
- dfa_data_t* d = data;
- expr_module_data_t* md = d->module_datas[dfa_module_expr.index];
+ scf_parse_t* parse = dfa->priv;
+ dfa_data_t* d = data;
- if (_expr_fini_expr(parse, d, 1) < 0)
- return SCF_DFA_ERROR;
+ int ret = _expr_fini_expr(parse, d, 1);
+
+ if (SCF_DFA_OK != ret)
+ return ret;
return SCF_DFA_OK;
}
extern scf_dfa_module_t dfa_module_function;
typedef struct {
-
scf_block_t* parent_block;
- int pf_pointers;
+ scf_variable_t* v_pf;
+
int pf_lps;
int pf_rps;
} dfa_fun_data_t;
int _function_add_function(scf_dfa_t* dfa, dfa_data_t* d)
{
- if (d->current_identities->size < 2) {
- scf_loge("d->current_identities->size: %d\n", d->current_identities->size);
- return SCF_DFA_ERROR;
- }
-
scf_parse_t* parse = dfa->priv;
scf_ast_t* ast = parse->ast;
- dfa_identity_t* id = scf_stack_pop(d->current_identities);
+ dfa_identity_t* id = NULL;
dfa_fun_data_t* fd = d->module_datas[dfa_module_function.index];
+ scf_lex_word_t* name = NULL;
+ dfa_identity_t* id0;
scf_variable_t* v_pf = NULL;
scf_function_t* f;
scf_variable_t* v;
scf_block_t* b;
scf_type_t* t;
- if (!id || !id->identity) {
- scf_loge("function identity not found\n");
- return SCF_DFA_ERROR;
+ if (d->current_var) {
+ name = scf_lex_word_clone(d->current_var->w);
+ if (!name)
+ return -ENOMEM;
+
+ } else {
+ id = scf_stack_pop(d->current_identities);
+
+ if (!id || !id->identity) {
+ scf_loge("function identity not found\n");
+ return SCF_DFA_ERROR;
+ }
+
+ name = id->identity;
}
uint32_t local_flag = 0;
assert(global_flag || local_flag || member_flag);
- if (fd->pf_pointers > 0) {
+ if (d->pf_pointers > 0) {
t = NULL;
- int pf_pointers = fd->pf_pointers;
+ int ret;
+ int pf_pointers = d->pf_pointers;
- fd->pf_pointers = 0;
+ d->pf_pointers = 0;
- int ret = scf_ast_find_type_type(&t, ast, SCF_FUNCTION_PTR);
- if (ret < 0)
- return ret;
+ if (!d->current_var) {
+ ret = scf_ast_find_type_type(&t, ast, SCF_FUNCTION_PTR);
+ if (ret < 0)
+ return ret;
- v_pf = SCF_VAR_ALLOC_BY_TYPE(id->identity, t, 0, pf_pointers, NULL);
- if (!v_pf)
- return -ENOMEM;
+ v_pf = SCF_VAR_ALLOC_BY_TYPE(name, t, 0, pf_pointers, NULL);
+ if (!v_pf)
+ return -ENOMEM;
+
+ v_pf->local_flag = local_flag;
+ v_pf->global_flag = global_flag;
+ v_pf->member_flag = member_flag;
+ } else
+ v_pf = d->current_var;
+
+ assert(d->current_identities->size > 0);
+ id0 = d->current_identities->data[0];
+
+ if (id0->typedef_flag) {
+ id0->typedef_flag = 0;
- scf_scope_push_var(ast->current_block->scope, v_pf);
+ v_pf->typedef_flag = 1;
+
+ ret = scf_vector_add(ast->current_block->scope->typedef_vars, v_pf);
+ } else
+ ret = scf_scope_push_var(ast->current_block->scope, v_pf);
+
+ if (ret < 0) {
+ scf_variable_free(v_pf);
+ return ret;
+ }
- ret = scf_string_cat_cstr(id->identity->text, "_pt");
+ ret = scf_string_cat_cstr(name->text, "__");
if (ret < 0)
return ret;
- v_pf->local_flag = local_flag;
- v_pf->global_flag = global_flag;
- v_pf->member_flag = member_flag;
+ fd->v_pf = v_pf;
}
- f = scf_function_alloc(id->identity);
+ f = scf_function_alloc(name);
if (!f)
return SCF_DFA_ERROR;
f->member_flag = member_flag;
- free(id);
- id = NULL;
+ if (id) {
+ free(id);
+ id = NULL;
+ }
- scf_logi("function: %s,line:%d, member_flag: %d\n", f->node.w->text->data, f->node.w->line, f->member_flag);
+ scf_logi("function: %s(), line: %d, member_flag: %d\n", f->node.w->text->data, f->node.w->line, f->member_flag);
int void_flag = 0;
dfa_data_t* d = data;
dfa_fun_data_t* fd = d->module_datas[dfa_module_function.index];
- fd->pf_pointers++;
+ d->pf_pointers++;
return SCF_DFA_NEXT_WORD;
}
fd->pf_lps = 0;
if (id && id->identity)
- scf_logw("pf: %s(), nb_pointers: %d\n", id->identity->text->data, fd->pf_pointers);
+ scf_logw("pf: %s(), nb_pointers: %d\n", id->identity->text->data, d->pf_pointers);
} else {
SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "function_pf_rp"), SCF_DFA_HOOK_PRE);
}
assert(!d->current_node);
- d->current_var = NULL;
+ if (d->pf_pointers <= 0)
+ d->current_var = NULL;
if (_function_add_function(dfa, d) < 0)
return SCF_DFA_ERROR;
+ d->current_var = NULL;
+
SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "function_rp"), SCF_DFA_HOOK_PRE);
SCF_DFA_PUSH_HOOK(scf_dfa_find_node(dfa, "function_comma"), SCF_DFA_HOOK_PRE);
SCF_DFA_GET_MODULE_NODE(dfa, type, identity, identity);
SCF_DFA_GET_MODULE_NODE(dfa, block, entry, block);
+ SCF_DFA_GET_MODULE_NODE(dfa, var, ls, ls);
+ SCF_DFA_GET_MODULE_NODE(dfa, var, rs, rs);
+ SCF_DFA_GET_MODULE_NODE(dfa, var, assign, assign);
+
// function pointer
scf_dfa_node_add_child(base_type, pf_lp);
scf_dfa_node_add_child(type_name, pf_lp);
scf_dfa_node_add_child(pf_star, identity);
scf_dfa_node_add_child(identity, pf_rp);
+ scf_dfa_node_add_child(identity, ls);
+ scf_dfa_node_add_child(identity, assign);
+ scf_dfa_node_add_child(rs, pf_rp);
+
scf_dfa_node_add_child(pf_star, pf_star);
scf_dfa_node_add_child(pf_lp, pf_lp);
scf_dfa_node_add_child(pf_rp, pf_rp);
extern scf_dfa_module_t dfa_module_type;
+int __class_add_type(scf_ast_t* ast, scf_lex_word_t* key, scf_lex_word_t* name);
+
static int _type_is__struct(scf_dfa_t* dfa, void* word)
{
scf_lex_word_t* w = word;
|| SCF_LEX_WORD_KEY_UNION == w->type;
}
+static int _type_action_typedef(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+{
+ dfa_data_t* d = data;
+
+ d->typedef_flag = 1;
+
+ return SCF_DFA_NEXT_WORD;
+}
+
static int _type_action_const(scf_dfa_t* dfa, scf_vector_t* words, void* data)
{
dfa_data_t* d = data;
return SCF_DFA_ERROR;
}
- id->type_w = w;
+ id->type_w = w;
- id->const_flag = d->const_flag;
- id->static_flag = d->static_flag;
- id->extern_flag = d->extern_flag;
- id->inline_flag = d->inline_flag;
+ id->const_flag = d->const_flag;
+ id->static_flag = d->static_flag;
+ id->extern_flag = d->extern_flag;
+ id->inline_flag = d->inline_flag;
+ id->typedef_flag = d->typedef_flag;
- d ->const_flag = 0;
- d ->static_flag = 0;
- d ->extern_flag = 0;
- d ->inline_flag = 0;
+ d->const_flag = 0;
+ d->static_flag = 0;
+ d->extern_flag = 0;
+ d->inline_flag = 0;
+ d->typedef_flag = 0;
return SCF_DFA_NEXT_WORD;
}
if (!id->identity)
return 0;
- id->type = scf_block_find_type(parse->ast->current_block, id->identity->text->data);
- if (!id->type) {
+ int ret = scf_ast_find_type(&id->type, parse->ast, id->identity->text->data);
+ if (ret < 0)
+ return SCF_DFA_ERROR;
- int ret = scf_ast_find_global_type(&id->type, parse->ast, id->identity->text->data);
- if (ret < 0) {
- scf_loge("find global function error\n");
+ if (!id->type) {
+ ret = scf_ast_find_typedef(&id->type_def, parse->ast, id->identity->text->data);
+ if (ret < 0)
return SCF_DFA_ERROR;
- }
- if (!id->type) {
+ if (id->type_def) {
+ scf_logw("find typedef '%s'\n", id->identity->text->data);
+
+ ret = scf_ast_find_type_type(&id->type, parse->ast, id->type_def->type);
+ if (ret < 0)
+ return SCF_DFA_ERROR;
+
+ id->func_ptr = id->type_def->func_ptr;
+
+ assert(id->type);
+ } else {
+ scf_logw("can't find type '%s', it may be an function ptr\n", id->identity->text->data);
+
id->type = scf_block_find_type_type(parse->ast->current_block, SCF_FUNCTION_PTR);
if (!id->type) {
}
}
- if (SCF_FUNCTION_PTR == id->type->node.type) {
+ if (SCF_FUNCTION_PTR == id->type->node.type && !id->type_def) {
id->func_ptr = _type_find_function(parse->ast->current_block, id->identity->text->data);
scf_lex_word_t* w = words->data[words->size - 1];
dfa_data_t* d = data;
scf_stack_t* s = d->current_identities;
+ dfa_identity_t* type = NULL;
dfa_identity_t* id = NULL;
+ int ret;
if (s->size > 0) {
- id = scf_stack_top(s);
+ type = scf_stack_top(s);
- int ret = _type_find_type(dfa, id);
+ if (d->typedef_flag) {
+
+ if (words->size < 3) {
+ scf_loge("\n");
+ return SCF_DFA_ERROR;
+ }
+
+ scf_lex_word_t* name = words->data[words->size - 2];
+ scf_lex_word_t* key = words->data[words->size - 3];
+
+ if (SCF_LEX_WORD_KEY_STRUCT == key->type
+ || SCF_LEX_WORD_KEY_UNION == key->type
+ || SCF_LEX_WORD_KEY_CLASS == key->type) {
+
+ ret = __class_add_type(parse->ast, key, name);
+ if (ret < 0)
+ return ret;
+ }
+ }
+
+ ret = _type_find_type(dfa, type);
if (ret < 0) {
scf_loge("\n");
return ret;
}
+
+ if (d->typedef_flag) {
+ type->typedef_flag = d->typedef_flag;
+
+ d->typedef_flag = 0;
+ }
}
- id = calloc(1, sizeof(dfa_identity_t));
+ id = calloc(1, sizeof(dfa_identity_t));
if (!id)
return SCF_DFA_ERROR;
free(id);
return SCF_DFA_ERROR;
}
+
id->identity = w;
return SCF_DFA_NEXT_WORD;
SCF_DFA_MODULE_NODE(dfa, type, _struct, _type_is__struct, NULL);
+ SCF_DFA_MODULE_NODE(dfa, type, _typedef, scf_dfa_is_typedef, _type_action_typedef);
SCF_DFA_MODULE_NODE(dfa, type, _const, scf_dfa_is_const, _type_action_const);
SCF_DFA_MODULE_NODE(dfa, type, _static, scf_dfa_is_static, _type_action_static);
SCF_DFA_MODULE_NODE(dfa, type, _extern, scf_dfa_is_extern, _type_action_extern);
{
SCF_DFA_GET_MODULE_NODE(dfa, type, entry, entry);
+ SCF_DFA_GET_MODULE_NODE(dfa, type, _typedef, _typedef);
SCF_DFA_GET_MODULE_NODE(dfa, type, _const, _const);
SCF_DFA_GET_MODULE_NODE(dfa, type, _static, _static);
SCF_DFA_GET_MODULE_NODE(dfa, type, _extern, _extern);
SCF_DFA_GET_MODULE_NODE(dfa, identity, identity, type_name);
+ SCF_DFA_GET_MODULE_NODE(dfa, class, lb, class_lb);
+ SCF_DFA_GET_MODULE_NODE(dfa, class, semicolon, class_semicolon);
+
scf_vector_add(dfa->syntaxes, entry);
+ scf_dfa_node_add_child(entry, _typedef);
scf_dfa_node_add_child(entry, _static);
scf_dfa_node_add_child(entry, _extern);
scf_dfa_node_add_child(entry, _const);
scf_dfa_node_add_child(entry, base_type);
scf_dfa_node_add_child(entry, type_name);
+ scf_dfa_node_add_child(_typedef, _const);
+ scf_dfa_node_add_child(_typedef, _struct);
+ scf_dfa_node_add_child(_typedef, base_type);
+ scf_dfa_node_add_child(_typedef, type_name);
+
scf_dfa_node_add_child(_static, _struct);
scf_dfa_node_add_child(_static, base_type);
scf_dfa_node_add_child(_static, type_name);
scf_dfa_node_add_child(_extern, _const);
scf_dfa_node_add_child(_inline, _const);
+ // struct / union / class
scf_dfa_node_add_child(_struct, type_name);
+ scf_dfa_node_add_child(type_name, class_semicolon); // only declare
+ scf_dfa_node_add_child(type_name, class_lb); // define
+ scf_dfa_node_add_child(_struct, class_lb); // define anonymous
// multi-pointer
scf_dfa_node_add_child(star, star);
static int _var_add_var(scf_dfa_t* dfa, dfa_data_t* d)
{
scf_parse_t* parse = dfa->priv;
+ scf_ast_t* ast = parse->ast;
dfa_identity_t* id = scf_stack_top(d->current_identities);
+ dfa_identity_t* id0 = NULL;
+ scf_variable_t* v = NULL;
+ scf_type_t* t = NULL;
if (id && id->identity) {
- scf_variable_t* v = scf_scope_find_variable(parse->ast->current_block->scope, id->identity->text->data);
+ v = scf_scope_find_variable(ast->current_block->scope, id->identity->text->data);
if (v) {
scf_loge("repeated declare var '%s', line: %d\n", id->identity->text->data, id->identity->line);
return SCF_DFA_ERROR;
assert(d->current_identities->size >= 2);
- dfa_identity_t* id0 = d->current_identities->data[0];
+ id0 = d->current_identities->data[0];
+
assert(id0 && id0->type);
- scf_block_t* b = parse->ast->current_block;
+ t = id0->type;
+
+ int const_flag = id0->const_flag;
+ int nb_pointers = id0->nb_pointers;
+ void* func_ptr = id0->func_ptr;
+
+ if (id0->type_def) {
+ const_flag |= id0->type_def->const_flag;
+ nb_pointers += id0->type_def->nb_pointers;
+
+ if (!func_ptr)
+ func_ptr = id0->type_def->func_ptr;
+ }
+
+ if (d->pf_pointers > 0) {
+ nb_pointers = d->pf_pointers;
+
+ t = scf_block_find_type_type(ast->current_block, SCF_FUNCTION_PTR);
+ }
+
+ if (SCF_VAR_VOID == t->node.type && 0 == nb_pointers) {
+ scf_loge("void var must be a pointer, like 'void*'\n");
+ return SCF_DFA_ERROR;
+ }
+
+ if (SCF_FUNCTION_PTR == t->node.type && 0 == nb_pointers) {
+ scf_loge("invalid func ptr\n");
+ return SCF_DFA_ERROR;
+ }
+
+ scf_block_t* b = ast->current_block;
while (b) {
if (b->node.type >= SCF_STRUCT || SCF_FUNCTION == b->node.type)
break;
global_flag = 0;
member_flag = 1;
- if (0 == id0->nb_pointers && id0->type->node.type >= SCF_STRUCT) {
+ if (0 == nb_pointers && t->node.type >= SCF_STRUCT) {
// if not pointer var, check if define recursive struct/union/class var
- if (_check_recursive((scf_type_t*)b, id0->type, id->identity) < 0) {
+ if (_check_recursive((scf_type_t*)b, t, id->identity) < 0) {
scf_loge("recursive define when define var '%s', line: %d\n",
id->identity->text->data, id->identity->line);
}
}
- if (SCF_FUNCTION_PTR == id0->type->node.type
- && (!id0->func_ptr || 0 == id0->nb_pointers)) {
- scf_loge("invalid func ptr\n");
- return SCF_DFA_ERROR;
- }
-
if (id0->extern_flag) {
if (!global_flag) {
scf_loge("extern var must be global.\n");
return SCF_DFA_ERROR;
}
- scf_variable_t* v = scf_block_find_variable(parse->ast->current_block, id->identity->text->data);
+ v = scf_block_find_variable(ast->current_block, id->identity->text->data);
if (v) {
scf_loge("extern var already declared, line: %d\n", v->w->line);
return SCF_DFA_ERROR;
}
}
- if (SCF_VAR_VOID == id0->type->node.type && 0 == id0->nb_pointers) {
- scf_loge("void var must be a pointer, like void*\n");
- return SCF_DFA_ERROR;
- }
-
- v = SCF_VAR_ALLOC_BY_TYPE(id->identity, id0->type, id0->const_flag, id0->nb_pointers, id0->func_ptr);
+ v = SCF_VAR_ALLOC_BY_TYPE(id->identity, t, const_flag, nb_pointers, func_ptr);
if (!v) {
scf_loge("alloc var failed\n");
return SCF_DFA_ERROR;
}
- v->local_flag = local_flag;
- v->global_flag = global_flag;
- v->member_flag = member_flag;
+ v->local_flag = local_flag;
+ v->global_flag = global_flag;
+ v->member_flag = member_flag;
+
+ v->static_flag = id0->static_flag;
+ v->extern_flag = id0->extern_flag;
+ v->typedef_flag = id0->typedef_flag;
+
+ if (id0->type_def) {
+ int i;
+ scf_dimention_t* dim;
- v->static_flag = id0->static_flag;
- v->extern_flag = id0->extern_flag;
+ for (i = 0; i < id0->type_def->nb_dimentions; i++) {
+ dim = &id0->type_def->dimentions[i];
- scf_logi("type: %d, nb_pointers: %d,nb_dimentions: %d, var: %s,line:%d,pos:%d, local: %d, global: %d, member: %d, extern: %d, static: %d\n\n",
- v->type, v->nb_pointers, v->nb_dimentions,
+ scf_variable_add_array_dimention(v, dim->num, NULL);
+ }
+
+ v->const_literal_flag = id0->type_def->nb_dimentions > 0;
+ }
+
+ scf_logi("typedef_flag: %u, type: %d, nb_pointers: %d, nb_dimentions: %d, var: %s, line:%d, pos:%d, local: %d, global: %d, member: %d, extern: %d, static: %d\n\n",
+ v->typedef_flag, v->type, v->nb_pointers, v->nb_dimentions,
v->w->text->data, v->w->line, v->w->pos,
v->local_flag, v->global_flag, v->member_flag,
v->extern_flag, v->static_flag);
- scf_scope_push_var(parse->ast->current_block->scope, v);
+ scf_scope_push_var(ast->current_block->scope, v);
- d->current_var = v;
- d->current_var_w = id->identity;
- id0->nb_pointers = 0;
- id0->const_flag = 0;
- id0->static_flag = 0;
- id0->extern_flag = 0;
+ d->current_var = v;
+ d->current_var_w = id->identity;
+ id0->nb_pointers = 0;
+ id0->const_flag = 0;
+ id0->static_flag = 0;
+ id0->extern_flag = 0;
scf_stack_pop(d->current_identities);
free(id);
return 0;
}
+static int _var_add_typedef(scf_ast_t* ast, dfa_data_t* d)
+{
+ scf_variable_t* v;
+
+ if (d->expr) {
+ scf_expr_free(d->expr);
+ d->expr = NULL;
+ }
+
+ if (d->expr_local_flag > 0)
+ d->expr_local_flag--;
+
+ if (d->current_var) {
+ v = scf_block_find_typedef(ast->current_block, d->current_var->w->text->data);
+ if (v) {
+ scf_loge("repeated typedef '%s', 1st in file: %s, line: %d, 2nd in file: %s, line: %d\n",
+ v->w->text->data, v->w->file->data, v->w->line,
+ d->current_var->w->file->data,
+ d->current_var->w->line);
+ return SCF_DFA_REPEATED;
+ }
+
+ v = d->current_var;
+
+ scf_logi("typedef_flag: %u, type: %d, nb_pointers: %d, nb_dimentions: %d, var: %s, line:%d, pos:%d, local: %d, global: %d, member: %d, extern: %d, static: %d\n\n",
+ v->typedef_flag, v->type, v->nb_pointers, v->nb_dimentions,
+ v->w->text->data, v->w->line, v->w->pos,
+ v->local_flag, v->global_flag, v->member_flag,
+ v->extern_flag, v->static_flag);
+
+ int ret = scf_vector_add(ast->current_block->scope->typedef_vars, d->current_var);
+ if (ret < 0)
+ return ret;
+
+ assert(0 == scf_vector_del(ast->current_block->scope->vars, d->current_var));
+
+ d->current_var->vla_flag = 0;
+ d->current_var = NULL;
+ }
+
+ return 0;
+}
+
static int _var_action_comma(scf_dfa_t* dfa, scf_vector_t* words, void* data)
{
scf_parse_t* parse = dfa->priv;
if (d->current_var) {
scf_variable_size(d->current_var);
+ if (d->current_var->typedef_flag) {
+
+ int ret = _var_add_typedef(parse->ast, d);
+ if (ret < 0)
+ return ret;
+
+ return SCF_DFA_SWITCH_TO;
+ }
+
if (d->current_var->vla_flag) {
if (_var_add_vla(parse->ast, d->current_var) < 0)
if (d->current_var) {
scf_variable_size(d->current_var);
+ if (d->current_var->typedef_flag) {
+
+ int ret = _var_add_typedef(parse->ast, d);
+ if (ret < 0)
+ return ret;
+
+ return SCF_DFA_OK;
+ }
+
if (d->current_var->vla_flag) {
if (_var_add_vla(parse->ast, d->current_var) < 0)
static int _var_action_assign(scf_dfa_t* dfa, scf_vector_t* words, void* data)
{
- scf_parse_t* parse = dfa->priv;
- dfa_data_t* d = data;
+ scf_parse_t* parse = dfa->priv;
+ dfa_data_t* d = data;
+ scf_lex_word_t* w = words->data[words->size - 1];
if (_var_add_var(dfa, d) < 0) {
scf_loge("add var error\n");
d->nb_lss = 0;
d->nb_rss = 0;
- scf_lex_word_t* w = words->data[words->size - 1];
-
if (!d->current_var) {
scf_loge("\n");
return SCF_DFA_ERROR;
}
+ if (d->current_var->typedef_flag) {
+ scf_loge("typedef can't be assigned by '%s', file: %s, line: %d\n", w->text->data, w->file->data, w->line);
+ return SCF_DFA_ERROR;
+ }
+
if (d->current_var->extern_flag) {
- scf_loge("extern var '%s' can't be inited here, line: %d\n",
- d->current_var->w->text->data, w->line);
+ scf_loge("extern var '%s' can't be inited here, line: %d\n", d->current_var->w->text->data, w->line);
return SCF_DFA_ERROR;
}
}
if (d->current_var->nb_dimentions > 0) {
- scf_logi("var array '%s' init, nb_dimentions: %d\n",
- d->current_var->w->text->data, d->current_var->nb_dimentions);
+ scf_logi("var array '%s' init, nb_dimentions: %d\n", d->current_var->w->text->data, d->current_var->nb_dimentions);
return SCF_DFA_NEXT_WORD;
}
return SCF_DFA_ERROR;
}
- assert(!d->expr);
+ if (d->expr) {
+ scf_expr_free(d->expr);
+ d->expr = NULL;
+ }
+
scf_variable_add_array_dimention(d->current_var, -1, NULL);
d->current_var->const_literal_flag = 1;
scf_logd("d->expr: %p\n", d->expr);
- if (d->expr) {
- while(d->expr->parent)
- d->expr = d->expr->parent;
+ if (!d->expr)
+ return SCF_DFA_SWITCH_TO;
- if (scf_expr_calculate(parse->ast, d->expr, &r) < 0) {
- scf_loge("scf_expr_calculate\n");
+ while(d->expr->parent)
+ d->expr = d->expr->parent;
- scf_expr_free(d->expr);
- d->expr = NULL;
- return SCF_DFA_ERROR;
- }
+ if (scf_expr_calculate(parse->ast, d->expr, &r) < 0)
+ goto error;
- assert(d->current_var->dim_index < d->current_var->nb_dimentions);
+ assert(d->current_var->dim_index < d->current_var->nb_dimentions);
- if (!scf_variable_const(r) && SCF_OP_ASSIGN != d->expr->nodes[0]->type) {
+ if (!scf_variable_const(r) && SCF_OP_ASSIGN != d->expr->nodes[0]->type) {
- if (!d->current_var->local_flag) {
- scf_loge("variable length array '%s' must in local scope, file: %s, line: %d\n",
- d->current_var->w->text->data, w->file->data, w->line);
+ if (d->current_var->typedef_flag) {
+ scf_loge("variable length array '%s' can't be type defined, file: %s, line: %d\n",
+ d->current_var->w->text->data, w->file->data, w->line);
+ goto error;
+ }
- scf_variable_free(r);
- r = NULL;
+ if (!d->current_var->local_flag) {
+ scf_loge("variable length array '%s' must in local scope, file: %s, line: %d\n",
+ d->current_var->w->text->data, w->file->data, w->line);
+ goto error;
+ }
- scf_expr_free(d->expr);
- d->expr = NULL;
- return SCF_DFA_ERROR;
- }
+ scf_logw("define variable length array, file: %s, line: %d\n", w->file->data, w->line);
- scf_logw("define variable length array, file: %s, line: %d\n", w->file->data, w->line);
+ d->current_var->dimentions[d->current_var->dim_index].vla = d->expr;
+ d->current_var->vla_flag = 1;
+ d->expr = NULL;
+ } else {
+ d->current_var->dimentions[d->current_var->dim_index].num = r->data.i;
- d->current_var->dimentions[d->current_var->dim_index].vla = d->expr;
- d->current_var->vla_flag = 1;
- d->expr = NULL;
- } else {
- d->current_var->dimentions[d->current_var->dim_index].num = r->data.i;
+ scf_logi("dimentions: %d, size: %d\n",
+ d->current_var->dim_index, d->current_var->dimentions[d->current_var->dim_index].num);
- scf_logi("dimentions: %d, size: %d\n",
- d->current_var->dim_index, d->current_var->dimentions[d->current_var->dim_index].num);
+ scf_expr_free(d->expr);
+ d->expr = NULL;
+ }
- scf_expr_free(d->expr);
- d->expr = NULL;
- }
+ d->current_var->dim_index++;
- d->current_var->dim_index++;
+ scf_variable_free(r);
+ r = NULL;
+ return SCF_DFA_SWITCH_TO;
+error:
+ if (r) {
scf_variable_free(r);
r = NULL;
}
- return SCF_DFA_SWITCH_TO;
+ scf_expr_free(d->expr);
+ d->expr = NULL;
+ return SCF_DFA_ERROR;
}
static int _dfa_init_module_var(scf_dfa_t* dfa)
}
d = parse->debug->abbrevs->data[parse->debug->abbrevs->size - 1];
- d->has_children = t->scope->vars->size > 0;
+
+ d->has_children = t->scope && t->scope->vars->size > 0;
}
types = parse->debug->struct_types;
static int _debug_add_struct_type(scf_dwarf_info_entry_t** pie, scf_dwarf_abbrev_declaration_t** pad, scf_parse_t* parse, scf_type_t* t)
{
-// scf_dwarf_abbrev_declaration_t* d;
- scf_dwarf_abbrev_attribute_t* attr;
- scf_dwarf_info_entry_t* ie;
- scf_dwarf_info_attr_t* iattr;
+ scf_dwarf_abbrev_attribute_t* attr;
+ scf_dwarf_info_entry_t* ie;
+ scf_dwarf_info_attr_t* iattr;
+ scf_dwarf_info_entry_t* ie_member;
+ scf_variable_t* v_member;
+ scf_type_t* t_member;
int ret;
int i;
int nb_pointers = 0;
- for (i = 0; i < t->scope->vars->size; i++) {
+ if (t->scope) {
+ for (i = 0; i < t->scope->vars->size; i++) {
+ v_member = t->scope->vars->data[i];
+ t_member = NULL;
- scf_dwarf_info_entry_t* ie_member;
- scf_variable_t* v_member;
- scf_type_t* t_member;
+ ret = scf_ast_find_type_type(&t_member, parse->ast, v_member->type);
+ if (ret < 0)
+ return ret;
- v_member = t->scope->vars->data[i];
- ret = scf_ast_find_type_type(&t_member, parse->ast, v_member->type);
- if (ret < 0)
- return ret;
+ ie_member = _debug_find_type(parse, t_member, v_member->nb_pointers);
+ if (!ie_member) {
- ie_member = _debug_find_type(parse, t_member, v_member->nb_pointers);
- if (!ie_member) {
+ if (t_member != t) {
+ ret = _debug_add_type(&ie_member, parse, t_member, v_member->nb_pointers);
+ if (ret < 0) {
+ scf_loge("\n");
+ return ret;
+ }
+ } else {
+ assert(v_member->nb_pointers > 0);
- if (t_member != t) {
- ret = _debug_add_type(&ie_member, parse, t_member, v_member->nb_pointers);
- if (ret < 0) {
- scf_loge("\n");
- return ret;
+ if (nb_pointers < v_member->nb_pointers)
+ nb_pointers = v_member->nb_pointers;
}
- } else {
- assert(v_member->nb_pointers > 0);
-
- if (nb_pointers < v_member->nb_pointers)
- nb_pointers = v_member->nb_pointers;
}
+
+ if (scf_vector_add(ie_member_types, ie_member) < 0)
+ return -ENOMEM;
}
- if (scf_vector_add(ie_member_types, ie_member) < 0)
- return -ENOMEM;
+ assert(ie_member_types->size == t->scope->vars->size);
}
- assert(ie_member_types->size == t->scope->vars->size);
-
+ ie = NULL;
ret = __debug_add_type(&ie, pad, parse, t, 0, NULL);
if (ret < 0) {
scf_loge("\n");
return -ENOMEM;
}
- for (i = 0; i < t->scope->vars->size; i++) {
-
- scf_dwarf_info_entry_t* ie_member;
- scf_variable_t* v_member;
-
- v_member = t->scope->vars->data[i];
+ if (t->scope) {
+ for (i = 0; i < t->scope->vars->size; i++) {
+ v_member = t->scope->vars->data[i];
+ ie_member = NULL;
- ret = __debug_add_member_var(&ie_member, parse, v_member, ie_member_types->data[i]);
- if (ret < 0) {
- scf_loge("\n");
- return ret;
- }
+ ret = __debug_add_member_var(&ie_member, parse, v_member, ie_member_types->data[i]);
+ if (ret < 0) {
+ scf_loge("\n");
+ return ret;
+ }
- if (nb_pointers > 0) {
- if (scf_vector_add(refills, ie_member) < 0) {
- return -ENOMEM;
+ if (nb_pointers > 0) {
+ if (scf_vector_add(refills, ie_member) < 0)
+ return -ENOMEM;
}
}
}
int j;
for (j = 1; j <= nb_pointers; j++) {
+ ie_pointer = NULL;
+
ret = _debug_add_type(&ie_pointer, parse, t, j);
if (ret < 0) {
scf_loge("\n");
return ret;
}
- for (i = 0; i < t->scope->vars->size; i++) {
-
- scf_dwarf_info_entry_t* ie_member;
- scf_variable_t* v_member;
+ if (!t->scope)
+ continue;
+ for (i = 0; i < t->scope->vars->size; i++) {
v_member = t->scope->vars->data[i];
if (v_member->type != t->node.type)
scf_lex_word_t* identity;
scf_lex_word_t* type_w;
scf_type_t* type;
+ scf_variable_t* type_def;
int number;
int nb_pointers;
scf_function_t* func_ptr;
- uint32_t const_flag :1;
- uint32_t extern_flag:1;
- uint32_t static_flag:1;
- uint32_t inline_flag:1;
+ uint32_t const_flag :1;
+ uint32_t extern_flag :1;
+ uint32_t static_flag :1;
+ uint32_t inline_flag :1;
+ uint32_t typedef_flag:1;
} dfa_identity_t;
scf_function_t* current_function;
int argc;
+ int pf_pointers;
scf_lex_word_t* current_async_w;
projects / scf.git / commitdiff