kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

eolian: simplify namespace handling 

This is mostly a preparation for rework of name(space) APIs.
This commit is contained in:
Daniel Kolesa 2018-03-11 15:55:10 +01:00
parent 2355df0e4f
commit 665fc62916
10 changed files with 108 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/lib/eolian/database_class.c
View File

@ -13,7 +13,6 @@ database_class_del(Eolian_Class *cl)
Eolian_Part *pt;
Eolian_Implement *impl;
Eolian_Constructor *ctor;
const char *s;
if (!cl || eolian_object_unref(&cl->base)) return;
@ -31,7 +30,6 @@ database_class_del(Eolian_Class *cl)
EINA_LIST_FREE(cl->events, ev) database_event_del(ev);
EINA_LIST_FREE(cl->parts, pt) database_part_del(pt);
if (cl->name) eina_stringshare_del(cl->name);
if (cl->legacy_prefix) eina_stringshare_del(cl->legacy_prefix);
if (cl->eo_prefix) eina_stringshare_del(cl->eo_prefix);
if (cl->ev_prefix) eina_stringshare_del(cl->ev_prefix);
@ -39,8 +37,5 @@ database_class_del(Eolian_Class *cl)
database_doc_del(cl->doc);
if (cl->namespaces) EINA_LIST_FREE(cl->namespaces, s)
if (s) eina_stringshare_del(s);
free(cl);
}

8
src/lib/eolian/database_class_api.c
View File

@ -15,14 +15,13 @@ eolian_class_full_name_get(const Eolian_Class *cl)
EAPI Eina_Stringshare *
eolian_class_name_get(const Eolian_Class *cl)
{
return cl ? cl->name : NULL;
return database_object_short_name_get((const Eolian_Object *)cl);
}
EAPI Eina_Iterator *
eolian_class_namespaces_get(const Eolian_Class *cl)
{
return ((cl && cl->namespaces) ? eina_list_iterator_new(cl->namespaces)
: NULL);
return database_object_namespaces_get((const Eolian_Object *)cl);
}
EAPI Eolian_Class_Type
@ -114,7 +113,8 @@ eolian_class_function_get_by_name(const Eolian_Class *cl, const char *func_name,
}
}
_eolian_log("function '%s' not found in class '%s'", func_name, cl->name);
_eolian_log("function '%s' not found in class '%s'", func_name,
database_object_short_name_get(&cl->base));
return NULL;
}

2
src/lib/eolian/database_expr.c
View File

@ -600,7 +600,7 @@ database_expr_eval_type(const Eolian_Unit *unit, Eolian_Expression *expr,
{
if (database_type_is_ownable(unit, type))
return database_expr_eval(unit, expr, EOLIAN_MASK_NULL);
int kw = eo_lexer_keyword_str_to_id(type->name);
int kw = eo_lexer_keyword_str_to_id(type->base.name);
if (!kw || kw < KW_byte || kw >= KW_void)
{
const Eolian_Typedecl *base = database_type_decl_find(unit, type);

78
src/lib/eolian/database_type.c
View File

@ -9,14 +9,10 @@ void
database_type_del(Eolian_Type *tp)
{
if (!tp || eolian_object_unref(&tp->base)) return;
const char *sp;
eina_stringshare_del(tp->base.file);
eina_stringshare_del(tp->base.name);
database_type_del(tp->base_type);
database_type_del(tp->next_type);
if (tp->name) eina_stringshare_del(tp->name);
if (tp->namespaces) EINA_LIST_FREE(tp->namespaces, sp)
eina_stringshare_del(sp);
if (tp->freefunc) eina_stringshare_del(tp->freefunc);
free(tp);
}
@ -25,15 +21,11 @@ void
database_typedecl_del(Eolian_Typedecl *tp)
{
if (!tp || eolian_object_unref(&tp->base)) return;
const char *sp;
eina_stringshare_del(tp->base.file);
eina_stringshare_del(tp->base.name);
database_type_del(tp->base_type);
if (tp->name) eina_stringshare_del(tp->name);
if (tp->fields) eina_hash_free(tp->fields);
if (tp->field_list) eina_list_free(tp->field_list);
if (tp->namespaces) EINA_LIST_FREE(tp->namespaces, sp)
eina_stringshare_del(sp);
if (tp->legacy) eina_stringshare_del(tp->legacy);
if (tp->freefunc) eina_stringshare_del(tp->freefunc);
database_doc_del(tp->doc);
@ -75,7 +67,7 @@ database_type_is_ownable(const Eolian_Unit *unit, const Eolian_Type *tp)
return EINA_TRUE;
if (tp->type == EOLIAN_TYPE_REGULAR)
{
int kw = eo_lexer_keyword_str_to_id(tp->name);
int kw = eo_lexer_keyword_str_to_id(tp->base.name);
const char *ct = eo_lexer_get_c_type(kw);
if (!ct)
{
@ -102,6 +94,19 @@ _buf_add_suffix(Eina_Strbuf *buf, const char *suffix)
eina_strbuf_append(buf, suffix);
}
static void
_append_name(const Eolian_Object *obj, Eina_Strbuf *buf)
{
Eina_Iterator *itr = database_object_namespaces_get(obj);
const char *sp;
EINA_ITERATOR_FOREACH(itr, sp)
{
eina_strbuf_append(buf, sp);
eina_strbuf_append_char(buf, '_');
}
eina_strbuf_append(buf, database_object_short_name_get(obj));
}
void
database_type_to_str(const Eolian_Type *tp,
Eina_Strbuf *buf, const char *name,
@ -118,18 +123,11 @@ database_type_to_str(const Eolian_Type *tp,
if (tp->type == EOLIAN_TYPE_REGULAR
|| tp->type == EOLIAN_TYPE_CLASS)
{
Eina_List *l;
const char *sp;
EINA_LIST_FOREACH(tp->namespaces, l, sp)
{
eina_strbuf_append(buf, sp);
eina_strbuf_append_char(buf, '_');
}
int kw = eo_lexer_keyword_str_to_id(tp->name);
int kw = eo_lexer_keyword_str_to_id(tp->base.name);
if (kw && eo_lexer_is_type_keyword(kw))
eina_strbuf_append(buf, eo_lexer_get_c_type(kw));
else
eina_strbuf_append(buf, tp->name);
_append_name(&tp->base, buf);
}
else if (tp->type == EOLIAN_TYPE_VOID)
eina_strbuf_append(buf, "void");
@ -154,19 +152,13 @@ database_type_to_str(const Eolian_Type *tp,
static void
_stype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
{
Eolian_Struct_Type_Field *sf;
Eina_List *l;
const char *sp;
eina_strbuf_append(buf, "struct ");
EINA_LIST_FOREACH(tp->namespaces, l, sp)
{
eina_strbuf_append(buf, sp);
eina_strbuf_append_char(buf, '_');
}
eina_strbuf_append(buf, tp->name);
_append_name(&tp->base, buf);
if (tp->type == EOLIAN_TYPEDECL_STRUCT_OPAQUE)
return;
eina_strbuf_append(buf, " { ");
Eina_List *l;
Eolian_Struct_Type_Field *sf;
EINA_LIST_FOREACH(tp->field_list, l, sf)
{
database_type_to_str(sf->type, buf, sf->base.name,
@ -179,17 +171,11 @@ _stype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
static void
_etype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
{
Eolian_Enum_Type_Field *ef;
Eina_List *l;
const char *sp;
eina_strbuf_append(buf, "enum ");
EINA_LIST_FOREACH(tp->namespaces, l, sp)
{
eina_strbuf_append(buf, sp);
eina_strbuf_append_char(buf, '_');
}
eina_strbuf_append(buf, tp->name);
_append_name(&tp->base, buf);
eina_strbuf_append(buf, " { ");
Eina_List *l;
Eolian_Enum_Type_Field *ef;
EINA_LIST_FOREACH(tp->field_list, l, ef)
{
eina_strbuf_append(buf, ef->base.name);
@ -209,20 +195,6 @@ _etype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
eina_strbuf_append(buf, " }");
}
static void
_append_name(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
{
Eina_List *l;
const char *sp;
EINA_LIST_FOREACH(tp->namespaces, l, sp)
{
eina_strbuf_append(buf, sp);
eina_strbuf_append_char(buf, '_');
}
eina_strbuf_append(buf, tp->name);
}
static void
_atype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
{
@ -230,17 +202,17 @@ _atype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
if (tp->base_type->type == EOLIAN_TYPE_REGULAR)
{
if (!strcmp(tp->base_type->name, "__builtin_free_cb"))
if (!strcmp(tp->base_type->base.name, "__builtin_free_cb"))
{
eina_strbuf_append(buf, "void (*");
_append_name(tp, buf);
_append_name(&tp->base, buf);
eina_strbuf_append(buf, ")(void *data)");
return;
}
}
Eina_Strbuf *fulln = eina_strbuf_new();
_append_name(tp, fulln);
_append_name(&tp->base, fulln);
database_type_to_str(tp->base_type, buf, eina_strbuf_string_get(fulln),
EOLIAN_C_TYPE_DEFAULT);
eina_strbuf_free(fulln);

14
src/lib/eolian/database_type_api.c
View File

@ -268,15 +268,13 @@ eolian_typedecl_c_type_get(const Eolian_Typedecl *tp)
EAPI Eina_Stringshare *
eolian_type_name_get(const Eolian_Type *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
return tp->name;
return database_object_short_name_get((const Eolian_Object *)tp);
}
EAPI Eina_Stringshare *
eolian_typedecl_name_get(const Eolian_Typedecl *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
return tp->name;
return database_object_short_name_get((const Eolian_Object *)tp);
}
EAPI Eina_Stringshare *
@ -296,17 +294,13 @@ eolian_typedecl_full_name_get(const Eolian_Typedecl *tp)
EAPI Eina_Iterator *
eolian_type_namespaces_get(const Eolian_Type *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
if (!tp->namespaces) return NULL;
return eina_list_iterator_new(tp->namespaces);
return database_object_namespaces_get((const Eolian_Object *)tp);
}
EAPI Eina_Iterator *
eolian_typedecl_namespaces_get(const Eolian_Typedecl *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
if (!tp->namespaces) return NULL;
return eina_list_iterator_new(tp->namespaces);
return database_object_namespaces_get((const Eolian_Object *)tp);
}
EAPI Eina_Stringshare *

4
src/lib/eolian/database_var.c
View File

@ -9,14 +9,10 @@ void
database_var_del(Eolian_Variable *var)
{
if (!var || eolian_object_unref(&var->base)) return;
const char *sp;
eina_stringshare_del(var->base.file);
eina_stringshare_del(var->base.name);
if (var->base_type)
database_type_del(var->base_type);
if (var->name) eina_stringshare_del(var->name);
if (var->namespaces) EINA_LIST_FREE(var->namespaces, sp)
eina_stringshare_del(sp);
if (var->value) database_expr_del(var->value);
database_doc_del(var->doc);
free(var);

7
src/lib/eolian/database_var_api.c
View File

@ -36,8 +36,7 @@ eolian_variable_value_get(const Eolian_Variable *var)
EAPI Eina_Stringshare *
eolian_variable_name_get(const Eolian_Variable *var)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(var, NULL);
return var->name;
return database_object_short_name_get((const Eolian_Object *)var);
}
EAPI Eina_Stringshare *
@ -50,9 +49,7 @@ eolian_variable_full_name_get(const Eolian_Variable *var)
EAPI Eina_Iterator *
eolian_variable_namespaces_get(const Eolian_Variable *var)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(var, NULL);
if (!var->namespaces) return NULL;
return eina_list_iterator_new(var->namespaces);
return database_object_namespaces_get((const Eolian_Object *)var);
}
EAPI Eina_Bool

52
src/lib/eolian/eo_parser.c
View File

@ -243,30 +243,6 @@ parse_name(Eo_Lexer *ls, Eina_Strbuf *buf)
return buf;
}
static void
_fill_name(const char *input, Eina_Stringshare **full_name,
Eina_Stringshare **name, Eina_List **namespaces)
{
char *fname = strdup(input);
char *sname = fname, *dot = fname;
*full_name = input;
do
{
dot = strchr(dot, '.');
if (dot)
{
*dot = '\0';
*namespaces = eina_list_append(*namespaces,
eina_stringshare_add(sname));
++dot;
sname = dot;
}
}
while (dot);
*name = eina_stringshare_add(sname);
free(fname);
}
static Eolian_Expression *
push_expr(Eo_Lexer *ls)
{
@ -529,7 +505,7 @@ parse_struct(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
int bline = ls->line_number, bcolumn = ls->column;
Eolian_Typedecl *def = push_typedecl(ls);
def->is_extern = is_extern;
if (name) _fill_name(name, &def->base.name, &def->name, &def->namespaces);
def->base.name = name;
def->type = EOLIAN_TYPEDECL_STRUCT;
def->fields = eina_hash_string_small_new(EINA_FREE_CB(_struct_field_free));
def->freefunc = freefunc;
@ -585,7 +561,7 @@ parse_enum(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
int bline = ls->line_number, bcolumn = ls->column;
Eolian_Typedecl *def = push_typedecl(ls);
def->is_extern = is_extern;
_fill_name(name, &def->base.name, &def->name, &def->namespaces);
def->base.name = name;
def->type = EOLIAN_TYPEDECL_ENUM;
def->fields = eina_hash_string_small_new(EINA_FREE_CB(_enum_field_free));
check_next(ls, '{');
@ -800,8 +776,7 @@ parse_type_void(Eo_Lexer *ls)
if (eo_lexer_is_type_keyword(ls->t.kw))
{
def->btype = ls->t.kw - KW_byte + 1;
_fill_name(eina_stringshare_ref(ls->t.value.s), &def->base.name,
&def->name, &def->namespaces);
def->base.name = eina_stringshare_ref(ls->t.value.s);
eo_lexer_get(ls);
if (tpid >= KW_accessor && tpid <= KW_future)
{
@ -857,8 +832,7 @@ parse_type_void(Eo_Lexer *ls)
free(fnm);
def->type = EOLIAN_TYPE_CLASS;
}
_fill_name(eina_stringshare_add(nm), &def->base.name, &def->name,
&def->namespaces);
def->base.name = eina_stringshare_add(nm);
eo_lexer_context_pop(ls);
pop_strbuf(ls);
}
@ -883,8 +857,7 @@ parse_typedef(Eo_Lexer *ls)
eo_lexer_context_push(ls);
FILL_BASE(def->base, ls, ls->line_number, ls->column, TYPEDECL);
parse_name(ls, buf);
_fill_name(eina_stringshare_add(eina_strbuf_string_get(buf)),
&def->base.name, &def->name, &def->namespaces);
def->base.name = eina_stringshare_add(eina_strbuf_string_get(buf));
Eolian_Object *decl = _eolian_decl_get(ls, def->base.name);
if (decl)
{
@ -918,8 +891,7 @@ parse_variable(Eo_Lexer *ls, Eina_Bool global)
eo_lexer_context_push(ls);
FILL_BASE(def->base, ls, ls->line_number, ls->column, VARIABLE);
parse_name(ls, buf);
_fill_name(eina_stringshare_add(eina_strbuf_string_get(buf)),
&def->base.name, &def->name, &def->namespaces);
def->base.name = eina_stringshare_add(eina_strbuf_string_get(buf));
Eolian_Object *decl = _eolian_decl_get(ls, def->base.name);
if (decl)
{
@ -1374,16 +1346,14 @@ parse_function_pointer(Eo_Lexer *ls)
eo_lexer_get(ls);
parse_name(ls, buf);
_fill_name(eina_stringshare_add(eina_strbuf_string_get(buf)),
&def->base.name, &def->name, &def->namespaces);
def->base.name = eina_stringshare_add(eina_strbuf_string_get(buf));
pop_strbuf(ls);
meth = calloc(1, sizeof(Eolian_Function));
meth->klass = NULL;
meth->type = EOLIAN_FUNCTION_POINTER;
meth->get_scope = meth->set_scope = EOLIAN_SCOPE_PUBLIC;
meth->base.name = eina_stringshare_ref(def->name);
meth->base.name = eina_stringshare_ref(def->base.name);
def->function_pointer = meth;
eolian_object_ref(&meth->base);
@ -2104,9 +2074,7 @@ parse_class(Eo_Lexer *ls, Eolian_Class_Type type)
eo_lexer_context_restore(ls);
eo_lexer_syntax_error(ls, "class and file names differ");
}
_fill_name(eina_stringshare_add(eina_strbuf_string_get(buf)),
&ls->tmp.kls->base.name, &ls->tmp.kls->name,
&ls->tmp.kls->namespaces);
ls->tmp.kls->base.name = eina_stringshare_add(eina_strbuf_string_get(buf));
Eolian_Object *decl = _eolian_decl_get(ls, ls->tmp.kls->base.name);
if (decl)
{
@ -2241,7 +2209,7 @@ parse_unit(Eo_Lexer *ls, Eina_Bool eot)
def->type = EOLIAN_TYPEDECL_STRUCT_OPAQUE;
def->freefunc = freefunc;
pop_str(ls);
_fill_name(name, &def->base.name, &def->name, &def->namespaces);
def->base.name = name;
eo_lexer_get(ls);
FILL_DOC(ls, def, doc);
FILL_BASE(def->base, ls, line, col, TYPEDECL);

59
src/lib/eolian/eolian_database.c
View File

@ -18,6 +18,65 @@ database_object_add(Eolian_Unit *unit, const Eolian_Object *obj)
((Eina_List *)eina_hash_find(unit->state->objects_f, obj->file), obj));
}
typedef struct _Eolian_Namespace_List
{
Eina_Iterator itr;
char *curp;
} Eolian_Namespace_List;
static Eina_Bool
_nmsp_iterator_next(Eolian_Namespace_List *it, void **data)
{
if (!it || !it->curp)
return EINA_FALSE;
char *ndot = strchr(it->curp, '.');
if (!ndot)
return EINA_FALSE;
*ndot = '\0';
if (data) *data = it->curp;
it->curp = ndot + 1;
return EINA_TRUE;
}
static void *
_nmsp_container_get(Eina_Iterator *it EINA_UNUSED)
{
return NULL;
}
Eina_Iterator *
database_object_namespaces_get(const Eolian_Object *obj)
{
if (!obj || !obj->name || !strchr(obj->name, '.')) return NULL;
size_t nstrl = strlen(obj->name) + 1;
size_t anstrl = nstrl - 1 - (nstrl - 1) % sizeof(void *) + sizeof(void *);
Eolian_Namespace_List *it = malloc(sizeof(Eolian_Namespace_List) + anstrl);
memset(&it->itr, 0, sizeof(Eina_Iterator));
it->curp = (char *)(it + 1);
memcpy(it->curp, obj->name, nstrl);
EINA_MAGIC_SET(&it->itr, EINA_MAGIC_ITERATOR);
it->itr.version = EINA_ITERATOR_VERSION;
it->itr.next = FUNC_ITERATOR_NEXT(_nmsp_iterator_next);
it->itr.get_container = _nmsp_container_get;
it->itr.free = FUNC_ITERATOR_FREE(free);
return &it->itr;
}
const char *
database_object_short_name_get(const Eolian_Object *obj)
{
if (!obj || !obj->name) return NULL;
const char *ldot = strrchr(obj->name, '.');
if (ldot)
return ldot + 1;
return obj->name;
}
void database_doc_del(Eolian_Documentation *doc)
{
if (!doc) return;

11
src/lib/eolian/eolian_database.h
View File

@ -111,8 +111,6 @@ struct _Eolian_Documentation
struct _Eolian_Class
{
Eolian_Object base;
Eina_List *namespaces; /* List Eina_Stringshare * */
Eina_Stringshare *name;
Eolian_Class_Type type;
Eolian_Documentation *doc;
Eina_Stringshare *legacy_prefix;
@ -199,8 +197,6 @@ struct _Eolian_Type
Eolian_Type_Builtin_Type btype;
Eolian_Type *base_type;
Eolian_Type *next_type;
Eina_Stringshare *name;
Eina_List *namespaces;
Eina_Stringshare *freefunc;
union
{
@ -218,8 +214,6 @@ struct _Eolian_Typedecl
Eolian_Object base;
Eolian_Typedecl_Type type;
Eolian_Type *base_type;
Eina_Stringshare *name;
Eina_List *namespaces;
Eina_Hash *fields;
Eina_List *field_list;
Eolian_Function *function_pointer;
@ -312,8 +306,6 @@ struct _Eolian_Variable
{
Eolian_Object base;
Eolian_Variable_Type type;
Eina_Stringshare *name;
Eina_List *namespaces;
Eolian_Type *base_type;
Eolian_Expression *value;
Eolian_Documentation *doc;
@ -325,6 +317,9 @@ Eina_Bool database_validate(Eolian_State *state, const Eolian_Unit *src);
void database_object_add(Eolian_Unit *unit, const Eolian_Object *obj);
Eina_Iterator *database_object_namespaces_get(const Eolian_Object *obj);
const char *database_object_short_name_get(const Eolian_Object *obj);
void database_doc_del(Eolian_Documentation *doc);
void database_unit_init(Eolian_State *state, Eolian_Unit *unit, const char *file);