From 6500c996699e1a4ab768768ffa821ace6c3c392c Mon Sep 17 00:00:00 2001 From: Savio Sena Date: Fri, 12 Sep 2014 16:50:09 -0300 Subject: [PATCH] eolian-cxx: Refactored eolian_cxx to cope with new Eolian API. --- src/bin/eolian_cxx/convert.cc | 328 ++++++++++++++------------------- src/bin/eolian_cxx/convert_comments.cc | 9 +- src/bin/eolian_cxx/convert_comments.hh | 21 ++- src/bin/eolian_cxx/eolian_cxx.cc | 7 +- 4 files changed, 162 insertions(+), 203 deletions(-) diff --git a/src/bin/eolian_cxx/convert.cc b/src/bin/eolian_cxx/convert.cc index 56f2c06..2cf8725 100644 --- a/src/bin/eolian_cxx/convert.cc +++ b/src/bin/eolian_cxx/convert.cc @@ -23,7 +23,7 @@ namespace eolian_cxx { extern efl::eina::log_domain domain; static efl::eolian::parameters_container_type -convert_eolian_parameters(Eina_Iterator *parameters, +_convert_eolian_parameters(Eina_Iterator *parameters, Eolian_Function_Type func_type) { if (parameters == NULL) return {}; @@ -46,126 +46,113 @@ convert_eolian_parameters(Eina_Iterator *parameters, } static efl::eolian::parameters_container_type -convert_eolian_parameters(Eolian_Function const& func, getter_t func_type) +_convert_eolian_parameters(Eolian_Function const& func, getter_t func_type) { - return convert_eolian_parameters + return _convert_eolian_parameters (::eolian_function_parameters_get(&func), func_type.value); } static efl::eolian::parameters_container_type -convert_eolian_parameters(Eina_Iterator *parameters, getter_t func_type) +_convert_eolian_parameters(Eina_Iterator *parameters, getter_t func_type) { - return convert_eolian_parameters(parameters, func_type.value); + return _convert_eolian_parameters(parameters, func_type.value); } static efl::eolian::parameters_container_type -convert_eolian_parameters(Eina_Iterator *parameters, setter_t func_type) +_convert_eolian_parameters(Eina_Iterator *parameters, setter_t func_type) { - return convert_eolian_parameters(parameters, func_type.value); + return _convert_eolian_parameters(parameters, func_type.value); } static efl::eolian::parameters_container_type -convert_eolian_parameters(Eolian_Function const& func) +_convert_eolian_parameters(Eolian_Function const& func) { - assert(function_type(func) != EOLIAN_PROPERTY); - return convert_eolian_parameters - (::eolian_function_parameters_get(&func), function_type(func)); + assert(function_op_type(func) != EOLIAN_PROPERTY); + return _convert_eolian_parameters + (::eolian_function_parameters_get(&func), function_op_type(func)); } -static efl::eolian::functions_container_type -convert_eolian_property_to_functions(Eolian_Class const& klass) +static efl::eolian::eo_function +_convert_property_set_to_function(Eolian_Class const& klass, + Eolian_Function const& prop_) { - efl::eolian::functions_container_type container; - std::string cxx_classname = safe_lower(class_name(klass)); - Eina_Iterator *properties = - ::eolian_class_functions_get(&klass, EOLIAN_PROPERTY); // XXX - void *curr; std::string prefix(class_prefix(klass)); - EINA_ITERATOR_FOREACH(properties, curr) + efl::eolian::eo_function set_ = { - Eolian_Function *prop_ = static_cast(curr); - if (property_is_getter(*prop_)) - { - efl::eolian::parameters_container_type params - = convert_eolian_parameters(*prop_, eolian_cxx::getter); - - efl::eolian::eo_function get_; - get_.type = efl::eolian::eo_function::regular_; - get_.name = function_name(*prop_) + "_get"; - get_.impl = function_impl(*prop_, prefix) + "_get"; + efl::eolian::eo_function::regular_, + function_name(prop_) + "_set", + function_impl(prop_, prefix) + "_set", + function_return_type(prop_, eolian_cxx::setter), + _convert_eolian_parameters(::eolian_function_parameters_get(&prop_), + eolian_cxx::setter), + convert_comments_function(klass, prop_, eolian_cxx::setter) + }; + efl::eolian::parameters_container_type keys = + _convert_eolian_parameters(::eolian_property_keys_get(&prop_), + eolian_cxx::setter); + if (!keys.empty()) + { + keys.reserve(keys.size() + set_.params.size()); + keys.insert(keys.end(), set_.params.begin(), + set_.params.end()); + set_.params = keys; + } + return set_; +} - efl::eolian::eolian_type_instance ret = - function_return_type(*prop_, eolian_cxx::getter); +static efl::eolian::eo_function +_convert_property_get_to_function(Eolian_Class const& klass, + Eolian_Function const& prop_) +{ + std::string prefix(class_prefix(klass)); + efl::eolian::eo_function get_ = + { + efl::eolian::eo_function::regular_, + function_name(prop_) + "_get", + function_impl(prop_, prefix) + "_get", + function_return_type(prop_, eolian_cxx::getter), + _convert_eolian_parameters(prop_, eolian_cxx::getter), + convert_comments_function(klass, prop_, eolian_cxx::getter) + }; - // if the getter has a single parameter and a void return - // it is transformed into a getter with no parameters - // that actually returns what would be the first argument. - if (params.size() == 1 && efl::eolian::type_is_void(ret) && - !function_return_is_explicit_void(*prop_, eolian_cxx::getter)) - { - get_.ret = params[0].type; - get_.params.clear(); - } - else // otherwise just create the described getter - { - get_.ret = ret; - get_.params = params; - std::transform - (params.begin(), params.end(), get_.params.begin(), - [](efl::eolian::eo_parameter const& param) - { - efl::eolian::eolian_type getter_param_type = - type_to_native(param.type); - getter_param_type.native += "*"; - return efl::eolian::eo_parameter - { { getter_param_type }, param.name }; - }); - } - efl::eolian::parameters_container_type keys = - convert_eolian_parameters(::eolian_property_keys_get(prop_), - eolian_cxx::getter); - if (!keys.empty()) - { - keys.reserve(keys.size() + get_.params.size()); - keys.insert(keys.end(), get_.params.begin(), - get_.params.end()); - get_.params = keys; - } - get_.comment = convert_comments_function(*prop_, eolian_cxx::getter); - container.push_back(get_); - } - if (property_is_setter(*prop_)) - { - efl::eolian::eo_function set_; - set_.type = efl::eolian::eo_function::regular_; - set_.name = function_name(*prop_) + "_set"; - set_.impl = function_impl(*prop_, prefix) + "_set"; - efl::eolian::parameters_container_type keys = - convert_eolian_parameters(::eolian_property_keys_get(prop_), - eolian_cxx::setter); - efl::eolian::parameters_container_type params = - convert_eolian_parameters(::eolian_function_parameters_get(prop_), - eolian_cxx::setter); - set_.params = params; - if (!keys.empty()) - { - keys.reserve(keys.size() + set_.params.size()); - keys.insert(keys.end(), set_.params.begin(), - set_.params.end()); - set_.params = keys; - } - set_.ret = function_return_type(*prop_, eolian_cxx::setter); - set_.comment = convert_comments_function(*prop_, eolian_cxx::setter); - container.push_back(set_); - } + // if the getter has a single parameter and a void return + // it is transformed into a getter with no parameters + // that actually returns what would be the first argument. + if (get_.params.size() == 1 && efl::eolian::type_is_void(get_.ret) && + !function_return_is_explicit_void(prop_, eolian_cxx::getter)) + { + get_.ret = get_.params[0].type; + get_.params.clear(); + } + else // otherwise just create the described getter + { + std::transform + (get_.params.begin(), get_.params.end(), get_.params.begin(), + [](efl::eolian::eo_parameter const& param) + { + efl::eolian::eolian_type getter_param_type = + type_to_native(param.type); + getter_param_type.native += "*"; + return efl::eolian::eo_parameter + { { getter_param_type }, param.name }; + }); + } + efl::eolian::parameters_container_type keys = + _convert_eolian_parameters(::eolian_property_keys_get(&prop_), + eolian_cxx::getter); + if (!keys.empty()) + { + keys.reserve(keys.size() + get_.params.size()); + keys.insert(keys.end(), get_.params.begin(), + get_.params.end()); + get_.params = keys; } - eina_iterator_free(properties); - return container; + return get_; } -std::string get_class_name(std::string const& name) +static std::string +_convert_class_name(std::string const& name) { - // "eo_base" is the Eolian name for EO_BASE_CLASS. return (name == "eo_base" || name == "eo::base" || name == "") ? "efl::eo::base" : name; @@ -188,103 +175,18 @@ convert_eolian_inheritances(efl::eolian::eo_class& cls, Eolian_Class const& klas { // First element is the parent const char *ptr = static_cast(curr); - cls.parent = get_class_name(class_format_cxx(safe_lower(ptr))); + cls.parent = _convert_class_name(class_format_cxx(safe_lower(ptr))); EINA_ITERATOR_FOREACH(inheritances, curr) { std::string extension = safe_lower(static_cast(curr)); - cls.extensions.push_back(get_class_name(class_format_cxx(extension))); + cls.extensions.push_back(_convert_class_name(class_format_cxx(extension))); } } eina_iterator_free(inheritances); } void -convert_eolian_implements(efl::eolian::eo_class& cls, Eolian_Class const& klass) -{ - std::string prefix(class_prefix(klass)); - Eina_Iterator *itr = ::eolian_class_implements_get(&klass); - void *impl_desc_; - - EINA_ITERATOR_FOREACH(itr, impl_desc_) - { - const Eolian_Implement *impl_desc = static_cast(impl_desc_); - const Eolian_Class *impl_class = eolian_implement_class_get(impl_desc); - Eolian_Function_Type impl_type; - const Eolian_Function *impl_func = eolian_implement_function_get(impl_desc, &impl_type); - /* fixme */ - if (eolian_function_is_constructing(impl_func)) - { - efl::eolian::eo_constructor constructor; - std::string parent = safe_lower(eolian_class_full_name_get(impl_class)); - if (parent == "eo_base" || parent == "eo.base") parent = "eo"; - constructor.name = parent + "_" + function_name(*impl_func); - constructor.params = convert_eolian_parameters(*impl_func); - constructor.comment = convert_comments_function(*impl_func, eolian_cxx::ctor); - cls.constructors.push_back(constructor); - } - } - eina_iterator_free(itr); -} - -void -convert_eolian_constructors(efl::eolian::eo_class& cls, Eolian_Class const& klass) -{ - void *curr; - std::string prefix(class_prefix(klass)); - Eina_Iterator *constructors = - ::eolian_class_functions_get(&klass, EOLIAN_METHOD); - EINA_ITERATOR_FOREACH(constructors, curr) - { - Eolian_Function *eo_constructor = static_cast(curr); - /* fixme */ - if (!eolian_function_is_constructing(eo_constructor)) - continue; - efl::eolian::eo_constructor constructor; - constructor.name = function_impl(*eo_constructor, prefix); - constructor.params = convert_eolian_parameters(*eo_constructor); - constructor.comment = convert_comments_function(*eo_constructor, eolian_cxx::ctor); - cls.constructors.push_back(constructor); - } - eina_iterator_free(constructors); -} - -void -convert_eolian_functions(efl::eolian::eo_class& cls, Eolian_Class const& klass) -{ - void *curr; - - Eina_Iterator *eolian_functions = - ::eolian_class_functions_get(&klass, EOLIAN_METHOD); - EINA_ITERATOR_FOREACH(eolian_functions, curr) - { - efl::eolian::eo_function func_; - Eolian_Function *eol_func = static_cast(curr); - /* fixme */ - if (eolian_function_is_constructing(eol_func)) - continue; - // XXX Eolian only provides regular methods so far - func_.type = efl::eolian::eo_function::regular_; - func_.name = function_name(*eol_func); - func_.impl = function_impl(*eol_func, class_prefix(klass)); - func_.ret = function_return_type(*eol_func); - func_.params = convert_eolian_parameters(*eol_func); - func_.comment = convert_comments_function(*eol_func, eolian_cxx::method); - cls.functions.push_back(func_); - } - eina_iterator_free(eolian_functions); -} - -void -convert_eolian_properties(efl::eolian::eo_class& cls, Eolian_Class const& klass) -{ - efl::eolian::functions_container_type properties - = convert_eolian_property_to_functions(klass); - cls.functions.insert - (cls.functions.end(), properties.begin(), properties.end()); -} - -void convert_eolian_events(efl::eolian::eo_class& cls, Eolian_Class const& klass) { efl::eolian::events_container_type events = event_list(klass); @@ -297,22 +199,74 @@ convert_eolian_class_new(Eolian_Class const& klass) { efl::eolian::eo_class cls; cls.type = class_type(klass); - cls.name = safe_lower(class_name(klass)); + cls.name = class_name(klass); cls.name_space = class_namespace_full(klass); cls.eo_name = class_eo_name(klass); cls.comment = convert_comments_class(klass); return cls; } +void +convert_eolian_implements(efl::eolian::eo_class& cls, Eolian_Class const& klass) +{ + std::string prefix(class_prefix(klass)); + efl::eina::iterator itr = implements_get(klass); + efl::eina::iterator end; + + while (itr != end) + { + const Eolian_Implement impl = *itr; + assert(!!implement_function(impl)); + assert(!!implement_class(impl)); + Eolian_Function const& func = *implement_function(impl); + Eolian_Class const& icls = *implement_class(impl); + + if (implement_is_property_get(impl)) + { + cls.functions.push_back + (_convert_property_get_to_function(icls, func)); + } + else if (implement_is_property_set(impl)) + { + cls.functions.push_back + (_convert_property_set_to_function(icls, func)); + } + else if (function_op_type(func) == eolian_cxx::property.value) + { + cls.functions.push_back + (_convert_property_get_to_function(icls, func)); + cls.functions.push_back + (_convert_property_set_to_function(icls, func)); + } + else if (function_is_constructor(klass, func)) + { + cls.constructors.push_back({ + function_impl(func, class_prefix(icls)), + _convert_eolian_parameters(func), + convert_comments_function(icls, func) + }); + } + else if (implement_is_visible(impl)) + { + cls.functions.push_back({ + function_type(func), + function_name(func), + function_impl(func, class_prefix(icls)), + function_return_type(func), + _convert_eolian_parameters(func), + convert_comments_function(icls, func, eolian_cxx::method) + }); + } + ++itr; + } +} + efl::eolian::eo_class convert_eolian_class(const Eolian_Class& klass) { efl::eolian::eo_class cls(eolian_cxx::convert_eolian_class_new(klass)); eolian_cxx::convert_eolian_inheritances(cls, klass); eolian_cxx::convert_eolian_implements(cls, klass); - eolian_cxx::convert_eolian_constructors(cls, klass); - eolian_cxx::convert_eolian_functions(cls, klass); - eolian_cxx::convert_eolian_properties(cls, klass); eolian_cxx::convert_eolian_events(cls, klass); efl::eolian::eo_class_validate(cls); return cls; diff --git a/src/bin/eolian_cxx/convert_comments.cc b/src/bin/eolian_cxx/convert_comments.cc index 43aadcd..381786e 100644 --- a/src/bin/eolian_cxx/convert_comments.cc +++ b/src/bin/eolian_cxx/convert_comments.cc @@ -38,7 +38,7 @@ _comment_parameters_list(Eina_Iterator *params) } static std::string -_comment_brief_and_params(Eolian_Function const& function, Eolian_Function_Type ftype = EOLIAN_METHOD) +_comment_brief_and_params(Eolian_Function const& function, Eolian_Function_Type ftype) { std::string doc = ""; std::string func = safe_str(::eolian_function_description_get(&function, ftype)); @@ -79,11 +79,12 @@ convert_comments_class(Eolian_Class const& klass) } std::string -convert_comments_function(Eolian_Function const& function, +convert_comments_function(Eolian_Class const& klass, + Eolian_Function const& function, Eolian_Function_Type func_type) { - std::string doc = _comment_brief_and_params(function); - if (func_type != eolian_cxx::ctor.value) + std::string doc = _comment_brief_and_params(function, func_type); + if (!function_is_constructor(klass, function)) doc += _comment_return(function, func_type); return doc; } diff --git a/src/bin/eolian_cxx/convert_comments.hh b/src/bin/eolian_cxx/convert_comments.hh index 75d420a..788362e 100644 --- a/src/bin/eolian_cxx/convert_comments.hh +++ b/src/bin/eolian_cxx/convert_comments.hh @@ -11,33 +11,34 @@ namespace eolian_cxx { -std::string convert_comments_class(Eolian_Class const& kls); +std::string convert_comments_class(Eolian_Class const& klass); -std::string convert_comments_function(Eolian_Function const& function, +std::string convert_comments_function(Eolian_Class const& klass, + Eolian_Function const& function, Eolian_Function_Type func_type); inline std::string -convert_comments_function(Eolian_Function const& constructor_, ctor_t func_type_) +convert_comments_function(Eolian_Class const& klass, Eolian_Function const& function_, method_t func_type_) { - return convert_comments_function(constructor_, func_type_.value); + return convert_comments_function(klass, function_, func_type_.value); } inline std::string -convert_comments_function(Eolian_Function const& function_, method_t func_type_) +convert_comments_function(Eolian_Class const& klass, Eolian_Function const& property_, getter_t func_type_) { - return convert_comments_function(function_, func_type_.value); + return convert_comments_function(klass, property_, func_type_.value); } inline std::string -convert_comments_function(Eolian_Function const& property_, getter_t func_type_) +convert_comments_function(Eolian_Class const& klass, Eolian_Function const& property_, setter_t func_type_) { - return convert_comments_function(property_, func_type_.value); + return convert_comments_function(klass, property_, func_type_.value); } inline std::string -convert_comments_function(Eolian_Function const& property_, setter_t func_type_) +convert_comments_function(Eolian_Class const& klass, Eolian_Function const& function_) { - return convert_comments_function(property_, func_type_.value); + return convert_comments_function(klass, function_, eolian_cxx::method); } } diff --git a/src/bin/eolian_cxx/eolian_cxx.cc b/src/bin/eolian_cxx/eolian_cxx.cc index 4a689c5..5aa477e 100644 --- a/src/bin/eolian_cxx/eolian_cxx.cc +++ b/src/bin/eolian_cxx/eolian_cxx.cc @@ -169,14 +169,17 @@ run(options_type const& opts) } else { - auto classes = class_list_all(); - for (const Eolian_Class& c : classes) + efl::eina::iterator it(class_list_all()); + efl::eina::iterator end; + while (it != end) { + Eolian_Class c = (*it); if (!generate(c, opts)) { klass = &c; goto err; } + ++it; } } return; -- 2.7.4