eolian-cxx: Refactored eolian_cxx to cope with new Eolian API.

diff --git a/src/bin/eolian_cxx/convert.cc b/src/bin/eolian_cxx/convert.cc
index 56f2c06..2cf8725 100644 (file)
--- 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<Eolian_Function*>(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<const char*>(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<const char*>(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<Eolian_Implement*>(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<Eolian_Function*>(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<Eolian_Function*>(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<const Eolian_Implement> itr = implements_get(klass);
+   efl::eina::iterator<const Eolian_Implement> 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 (file)
--- 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 (file)
--- 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 (file)
--- 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<const Eolian_Class> it(class_list_all());
+        efl::eina::iterator<const Eolian_Class> end;
+        while (it != end)
           {
+             Eolian_Class c = (*it);
              if (!generate(c, opts))
                {
                   klass = &c;
                   goto err;
                }
+             ++it;
           }
     }
    return;