2014-07-11 03:31:48 -07:00
|
|
|
#include "eo_parser.h"
|
|
|
|
|
2014-09-11 03:18:48 -07:00
|
|
|
static Eina_Bool
|
2014-09-03 06:25:50 -07:00
|
|
|
_func_error(Eolian_Class *cl, Eolian_Implement *impl)
|
|
|
|
{
|
|
|
|
ERR("Error - %s%s not known in class %s", impl->full_name,
|
|
|
|
eolian_class_name_get(cl), (impl->is_prop_get ? ".get"
|
|
|
|
: (impl->is_prop_set ? ".set" : "")));
|
2014-09-11 03:18:48 -07:00
|
|
|
return EINA_FALSE;
|
2014-09-03 06:25:50 -07:00
|
|
|
}
|
|
|
|
|
2014-09-04 03:06:41 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_get_impl_func(Eolian_Class *cl, Eolian_Implement *impl,
|
|
|
|
Eolian_Function_Type ftype, Eolian_Function **foo_id)
|
|
|
|
{
|
|
|
|
size_t cllen = strlen(cl->full_name);
|
|
|
|
size_t imlen = strlen(impl->full_name);
|
|
|
|
const char *imstr = impl->full_name;
|
|
|
|
*foo_id = NULL;
|
|
|
|
if (imstr[0] == '.')
|
|
|
|
++imstr;
|
|
|
|
else if ((imlen > (cllen + 1)) && (*(imstr + cllen) == '.')
|
|
|
|
&& !strncmp(imstr, cl->full_name, cllen))
|
|
|
|
imstr += cllen + 1;
|
|
|
|
else
|
|
|
|
return EINA_TRUE;
|
|
|
|
if (strchr(imstr, '.'))
|
|
|
|
return EINA_FALSE;
|
2014-09-04 06:29:33 -07:00
|
|
|
impl->klass = cl;
|
2014-09-04 03:06:41 -07:00
|
|
|
*foo_id = (Eolian_Function*)eolian_class_function_get_by_name(cl, imstr,
|
|
|
|
ftype);
|
2014-09-04 07:15:38 -07:00
|
|
|
impl->foo_id = *foo_id;
|
2014-09-04 03:06:41 -07:00
|
|
|
return !!*foo_id;
|
|
|
|
}
|
|
|
|
|
2014-09-05 08:04:08 -07:00
|
|
|
static void
|
|
|
|
_write_impl(Eolian_Function *fid, Eolian_Implement *impl)
|
|
|
|
{
|
|
|
|
if (impl->is_prop_set)
|
|
|
|
fid->set_impl = impl;
|
|
|
|
else if (impl->is_prop_get)
|
|
|
|
fid->get_impl = impl;
|
|
|
|
else
|
|
|
|
fid->get_impl = fid->set_impl = impl;
|
|
|
|
}
|
|
|
|
|
2014-09-11 03:18:48 -07:00
|
|
|
static Eina_Bool
|
2014-07-11 03:31:48 -07:00
|
|
|
_db_fill_implement(Eolian_Class *cl, Eolian_Implement *impl)
|
|
|
|
{
|
|
|
|
const char *impl_name = impl->full_name;
|
|
|
|
|
2014-09-05 08:18:47 -07:00
|
|
|
Eolian_Function *foo_id;
|
2014-09-03 06:25:50 -07:00
|
|
|
Eolian_Function_Type ftype = EOLIAN_UNRESOLVED;
|
2014-07-11 03:31:48 -07:00
|
|
|
|
2014-09-03 06:25:50 -07:00
|
|
|
if (impl->is_prop_get)
|
|
|
|
ftype = EOLIAN_PROP_GET;
|
|
|
|
else if (impl->is_prop_set)
|
|
|
|
ftype = EOLIAN_PROP_SET;
|
2014-07-11 03:31:48 -07:00
|
|
|
|
2014-09-03 06:25:50 -07:00
|
|
|
if (impl->is_virtual)
|
|
|
|
{
|
2014-09-05 08:18:47 -07:00
|
|
|
foo_id = (Eolian_Function*)eolian_class_function_get_by_name(cl,
|
|
|
|
impl_name, ftype);
|
2014-09-05 08:04:08 -07:00
|
|
|
if (!foo_id)
|
|
|
|
return _func_error(cl, impl);
|
2014-08-29 03:40:29 -07:00
|
|
|
if (impl->is_prop_set)
|
2014-08-15 05:51:41 -07:00
|
|
|
foo_id->set_virtual_pure = EINA_TRUE;
|
|
|
|
else
|
|
|
|
foo_id->get_virtual_pure = EINA_TRUE;
|
2014-08-29 03:40:29 -07:00
|
|
|
|
2014-09-05 08:04:08 -07:00
|
|
|
impl->full_name = eina_stringshare_printf("%s.%s", cl->full_name,
|
|
|
|
impl_name);
|
|
|
|
eina_stringshare_del(impl_name);
|
|
|
|
impl_name = impl->full_name;
|
|
|
|
|
|
|
|
_write_impl(foo_id, impl);
|
2014-07-11 03:31:48 -07:00
|
|
|
}
|
2014-09-03 06:25:50 -07:00
|
|
|
else if (impl->is_auto)
|
|
|
|
{
|
2014-09-04 03:06:41 -07:00
|
|
|
if (!_get_impl_func(cl, impl, ftype, &foo_id))
|
|
|
|
return _func_error(cl, impl);
|
|
|
|
if (!foo_id)
|
|
|
|
goto pasttags;
|
2014-09-03 06:44:23 -07:00
|
|
|
if (impl->is_prop_set)
|
2014-09-03 06:25:50 -07:00
|
|
|
foo_id->set_auto = EINA_TRUE;
|
|
|
|
else
|
|
|
|
foo_id->get_auto = EINA_TRUE;
|
2014-09-04 06:48:39 -07:00
|
|
|
|
2014-09-05 08:04:08 -07:00
|
|
|
_write_impl(foo_id, impl);
|
2014-09-03 06:25:50 -07:00
|
|
|
}
|
|
|
|
else if (impl->is_empty)
|
|
|
|
{
|
2014-09-04 03:06:41 -07:00
|
|
|
if (!_get_impl_func(cl, impl, ftype, &foo_id))
|
|
|
|
return _func_error(cl, impl);
|
|
|
|
if (!foo_id)
|
|
|
|
goto pasttags;
|
2014-09-03 06:44:23 -07:00
|
|
|
if (impl->is_prop_set)
|
2014-09-03 06:25:50 -07:00
|
|
|
foo_id->set_empty = EINA_TRUE;
|
|
|
|
else
|
|
|
|
foo_id->get_empty = EINA_TRUE;
|
2014-09-04 06:48:39 -07:00
|
|
|
|
2014-09-05 08:04:08 -07:00
|
|
|
_write_impl(foo_id, impl);
|
2014-09-03 06:25:50 -07:00
|
|
|
}
|
2014-09-05 08:21:39 -07:00
|
|
|
else if (!_get_impl_func(cl, impl, ftype, &foo_id))
|
|
|
|
return _func_error(cl, impl);
|
2014-08-29 03:40:29 -07:00
|
|
|
|
2014-09-03 06:25:50 -07:00
|
|
|
pasttags:
|
2014-08-29 06:13:34 -07:00
|
|
|
if (impl_name[0] == '.')
|
|
|
|
{
|
|
|
|
impl->full_name = eina_stringshare_printf("%s%s", cl->full_name,
|
|
|
|
impl_name);
|
|
|
|
eina_stringshare_del(impl_name);
|
|
|
|
}
|
|
|
|
|
2014-09-11 03:18:48 -07:00
|
|
|
return EINA_TRUE;
|
2014-07-11 03:31:48 -07:00
|
|
|
}
|
|
|
|
|
2014-09-05 08:30:56 -07:00
|
|
|
static void
|
2014-09-04 06:48:39 -07:00
|
|
|
_db_build_implement(Eolian_Class *cl, Eolian_Function *foo_id)
|
|
|
|
{
|
2014-09-05 08:04:08 -07:00
|
|
|
if (foo_id->type == EOLIAN_PROP_SET)
|
|
|
|
{
|
2014-09-05 08:30:56 -07:00
|
|
|
if (foo_id->set_impl) return;
|
2014-09-05 08:04:08 -07:00
|
|
|
}
|
|
|
|
else if (foo_id->type == EOLIAN_PROP_GET)
|
|
|
|
{
|
2014-09-05 08:30:56 -07:00
|
|
|
if (foo_id->get_impl) return;
|
2014-09-05 08:04:08 -07:00
|
|
|
}
|
2014-09-05 08:30:56 -07:00
|
|
|
else if (foo_id->get_impl && foo_id->set_impl) return;
|
|
|
|
|
2014-09-04 06:48:39 -07:00
|
|
|
Eolian_Implement *impl = calloc(1, sizeof(Eolian_Implement));
|
|
|
|
|
|
|
|
if (foo_id->type == EOLIAN_PROP_SET)
|
|
|
|
impl->base = foo_id->set_base;
|
|
|
|
else
|
|
|
|
impl->base = foo_id->base;
|
|
|
|
eina_stringshare_ref(impl->base.file);
|
|
|
|
|
|
|
|
impl->klass = cl;
|
2014-09-04 07:15:38 -07:00
|
|
|
impl->foo_id = foo_id;
|
2014-09-04 06:48:39 -07:00
|
|
|
impl->full_name = eina_stringshare_printf("%s.%s", cl->full_name,
|
|
|
|
foo_id->name);
|
|
|
|
|
2014-09-05 08:04:08 -07:00
|
|
|
if (foo_id->type == EOLIAN_PROPERTY)
|
|
|
|
{
|
|
|
|
if (foo_id->get_impl)
|
|
|
|
{
|
|
|
|
impl->is_prop_set = EINA_TRUE;
|
|
|
|
foo_id->set_impl = impl;
|
|
|
|
}
|
|
|
|
else if (foo_id->set_impl)
|
|
|
|
{
|
|
|
|
impl->is_prop_get = EINA_TRUE;
|
|
|
|
foo_id->get_impl = impl;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
foo_id->get_impl = foo_id->set_impl = impl;
|
|
|
|
}
|
|
|
|
else if (foo_id->type == EOLIAN_PROP_SET)
|
2014-09-05 08:19:56 -07:00
|
|
|
{
|
|
|
|
impl->is_prop_set = EINA_TRUE;
|
|
|
|
foo_id->set_impl = impl;
|
|
|
|
}
|
2014-09-05 08:04:08 -07:00
|
|
|
else if (foo_id->type == EOLIAN_PROP_GET)
|
2014-09-05 08:19:56 -07:00
|
|
|
{
|
|
|
|
impl->is_prop_get = EINA_TRUE;
|
|
|
|
foo_id->get_impl = impl;
|
|
|
|
}
|
2014-09-05 08:04:08 -07:00
|
|
|
else
|
|
|
|
foo_id->get_impl = foo_id->set_impl = impl;
|
2014-09-04 06:48:39 -07:00
|
|
|
|
|
|
|
cl->implements = eina_list_append(cl->implements, impl);
|
|
|
|
}
|
|
|
|
|
2014-07-11 03:31:48 -07:00
|
|
|
static Eina_Bool
|
2014-09-11 02:50:48 -07:00
|
|
|
_db_fill_implements(Eolian_Class *cl, Eolian_Class *kls)
|
2014-07-11 03:31:48 -07:00
|
|
|
{
|
|
|
|
Eolian_Implement *impl;
|
2014-09-04 06:48:39 -07:00
|
|
|
Eolian_Function *foo_id;
|
2014-07-11 03:31:48 -07:00
|
|
|
Eina_List *l;
|
|
|
|
|
2014-09-11 03:18:48 -07:00
|
|
|
cl->implements = kls->implements; kls->implements = NULL;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(cl->implements, l, impl)
|
|
|
|
if (!_db_fill_implement(cl, impl))
|
|
|
|
return EINA_FALSE;
|
2014-09-04 06:48:39 -07:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH(cl->properties, l, foo_id)
|
2014-09-05 08:30:56 -07:00
|
|
|
_db_build_implement(cl, foo_id);
|
2014-09-04 06:48:39 -07:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH(cl->methods, l, foo_id)
|
2014-09-05 08:30:56 -07:00
|
|
|
_db_build_implement(cl, foo_id);
|
2014-09-04 06:48:39 -07:00
|
|
|
|
2014-07-11 03:31:48 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2014-09-11 02:50:48 -07:00
|
|
|
_db_fill_class(Eolian_Class *kls)
|
2014-07-11 03:31:48 -07:00
|
|
|
{
|
2014-09-11 02:58:09 -07:00
|
|
|
Eolian_Class *cl = calloc(1, sizeof(Eolian_Class));
|
2014-07-11 03:31:48 -07:00
|
|
|
|
2014-09-11 02:58:09 -07:00
|
|
|
eina_hash_set(_classes, kls->full_name, cl);
|
2014-08-08 07:19:52 -07:00
|
|
|
eina_hash_set(_classesf, kls->base.file, cl);
|
2014-07-11 03:31:48 -07:00
|
|
|
|
2014-09-11 02:58:09 -07:00
|
|
|
cl->namespaces = kls->namespaces; kls->namespaces = NULL;
|
|
|
|
cl->full_name = kls->full_name; kls->full_name = NULL;
|
|
|
|
cl->name = kls->name; kls->name = NULL;
|
|
|
|
cl->type = kls->type;
|
|
|
|
|
2014-09-11 03:18:48 -07:00
|
|
|
cl->description = kls->description; kls->description = NULL;
|
|
|
|
cl->inherits = kls->inherits ; kls->inherits = NULL;
|
2014-07-11 03:31:48 -07:00
|
|
|
|
2014-09-11 03:18:48 -07:00
|
|
|
cl->legacy_prefix = kls->legacy_prefix; kls->legacy_prefix = NULL;
|
|
|
|
cl->eo_prefix = kls->eo_prefix ; kls->eo_prefix = NULL;
|
|
|
|
cl->data_type = kls->data_type ; kls->data_type = NULL;
|
2014-07-11 03:31:48 -07:00
|
|
|
|
2014-09-10 08:58:29 -07:00
|
|
|
cl->properties = kls->properties; kls->properties = NULL;
|
2014-09-11 02:29:48 -07:00
|
|
|
cl->methods = kls->methods ; kls->methods = NULL;
|
2014-09-10 07:53:20 -07:00
|
|
|
|
2014-09-11 03:18:48 -07:00
|
|
|
if (!_db_fill_implements(cl, kls)) return EINA_FALSE;
|
|
|
|
|
|
|
|
cl->constructors = kls->constructors; kls->constructors = NULL;
|
|
|
|
cl->events = kls->events ; kls->events = NULL;
|
|
|
|
|
|
|
|
cl->class_ctor_enable = kls->class_ctor_enable;
|
|
|
|
cl->class_dtor_enable = kls->class_dtor_enable;
|
2014-07-11 03:31:48 -07:00
|
|
|
|
2014-08-04 06:29:13 -07:00
|
|
|
cl->base = kls->base;
|
2014-08-07 07:15:07 -07:00
|
|
|
kls->base.file = NULL;
|
2014-08-04 06:29:13 -07:00
|
|
|
|
2014-07-11 03:31:48 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
eo_parser_database_fill(const char *filename, Eina_Bool eot)
|
|
|
|
{
|
|
|
|
Eina_List *k;
|
|
|
|
Eo_Node *nd;
|
|
|
|
Eina_Bool has_class = EINA_FALSE;
|
|
|
|
|
|
|
|
Eo_Lexer *ls = eo_lexer_new(filename);
|
|
|
|
if (!ls)
|
|
|
|
{
|
|
|
|
ERR("unable to create lexer");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* read first token */
|
|
|
|
eo_lexer_get(ls);
|
|
|
|
|
|
|
|
if (!eo_parser_walk(ls, eot))
|
|
|
|
{
|
|
|
|
eo_lexer_free(ls);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2014-07-21 03:42:05 -07:00
|
|
|
if (eot) goto done;
|
2014-07-11 03:31:48 -07:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH(ls->nodes, k, nd) if (nd->type == NODE_CLASS)
|
|
|
|
{
|
|
|
|
has_class = EINA_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!has_class)
|
|
|
|
{
|
|
|
|
ERR("No classes for file %s", filename);
|
|
|
|
eo_lexer_free(ls);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(ls->nodes, k, nd)
|
|
|
|
{
|
|
|
|
switch (nd->type)
|
|
|
|
{
|
|
|
|
case NODE_CLASS:
|
2014-07-23 09:15:00 -07:00
|
|
|
if (!_db_fill_class(nd->def_class))
|
2014-07-11 03:31:48 -07:00
|
|
|
goto error;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-21 03:42:05 -07:00
|
|
|
done:
|
2014-07-11 03:31:48 -07:00
|
|
|
eo_lexer_free(ls);
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
error:
|
|
|
|
eo_lexer_free(ls);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|