eolian-cxx: Pass references instead of pointers.

Fix Eolian-Cxx API to pass references instead of pointers.

src/bin/eolian_cxx/convert.cc

@@ -73,12 +73,12 @@ convert_eolian_parameters(Eolian_Function const& func)
 }
 
 static efl::eolian::functions_container_type
-convert_eolian_property_to_functions(Eolian_Class const *& klass)
+convert_eolian_property_to_functions(Eolian_Class const& klass)
 {
    efl::eolian::functions_container_type container;
    std::string cxx_classname = safe_lower(class_name(klass));
    const Eina_List *properties =
-     eolian_class_functions_list_get(klass, EOLIAN_PROPERTY); // XXX
+     ::eolian_class_functions_list_get(&klass, EOLIAN_PROPERTY); // XXX
    const Eina_List *it;
    void *curr;
    std::string prefix(class_prefix(klass));
@@ -156,10 +156,10 @@ convert_eolian_property_to_functions(Eolian_Class const *& klass)
 }
 
 void
-convert_eolian_inheritances(efl::eolian::eo_class& cls, Eolian_Class const *& klass)
+convert_eolian_inheritances(efl::eolian::eo_class& cls, Eolian_Class const& klass)
 {
    const Eina_List *inheritances =
-     ::eolian_class_inherits_list_get(klass);
+     ::eolian_class_inherits_list_get(&klass);
    const Eina_List *it;
    void *curr;
 
@@ -190,13 +190,13 @@ convert_eolian_inheritances(efl::eolian::eo_class& cls, Eolian_Class const *& kl
 }
 
 void
-convert_eolian_implements(efl::eolian::eo_class& cls, Eolian_Class const *& klass)
+convert_eolian_implements(efl::eolian::eo_class& cls, Eolian_Class const& klass)
 {
    const Eina_List *it;
    std::string prefix(class_prefix(klass));
    void *impl_desc_;
 
-   EINA_LIST_FOREACH(eolian_class_implements_list_get(klass), it, impl_desc_)
+   EINA_LIST_FOREACH(::eolian_class_implements_list_get(&klass), it, impl_desc_)
      {
         Eolian_Implement *impl_desc = static_cast<Eolian_Implement*>(impl_desc_);
         Eolian_Class *impl_class;
@@ -218,13 +218,13 @@ convert_eolian_implements(efl::eolian::eo_class& cls, Eolian_Class const *& klas
 }
 
 void
-convert_eolian_constructors(efl::eolian::eo_class& cls, Eolian_Class const *& klass)
+convert_eolian_constructors(efl::eolian::eo_class& cls, Eolian_Class const& klass)
 {
    const Eina_List *it;
    void *curr;
    std::string prefix(class_prefix(klass));
    const Eina_List *constructors =
-     eolian_class_functions_list_get(klass, EOLIAN_CTOR);
+     ::eolian_class_functions_list_get(&klass, EOLIAN_CTOR);
    EINA_LIST_FOREACH (constructors, it, curr)
      {
         Eolian_Function eo_constructor = static_cast<Eolian_Function>(curr);
@@ -237,13 +237,13 @@ convert_eolian_constructors(efl::eolian::eo_class& cls, Eolian_Class const *& kl
 }
 
 void
-convert_eolian_functions(efl::eolian::eo_class& cls, Eolian_Class const *& klass)
+convert_eolian_functions(efl::eolian::eo_class& cls, Eolian_Class const& klass)
 {
    const Eina_List *it;
    void *curr;
 
    const Eina_List *eolian_functions =
-     eolian_class_functions_list_get(klass, EOLIAN_METHOD);
+     ::eolian_class_functions_list_get(&klass, EOLIAN_METHOD);
    EINA_LIST_FOREACH (eolian_functions, it, curr)
      {
         efl::eolian::eo_function func_;
@@ -260,7 +260,7 @@ convert_eolian_functions(efl::eolian::eo_class& cls, Eolian_Class const *& klass
 }
 
 void
-convert_eolian_properties(efl::eolian::eo_class& cls, Eolian_Class const *& klass)
+convert_eolian_properties(efl::eolian::eo_class& cls, Eolian_Class const& klass)
 {
    efl::eolian::functions_container_type properties
      = convert_eolian_property_to_functions(klass);
@@ -269,7 +269,7 @@ convert_eolian_properties(efl::eolian::eo_class& cls, Eolian_Class const *& klas
 }
 
 void
-convert_eolian_events(efl::eolian::eo_class& cls, Eolian_Class const *& klass)
+convert_eolian_events(efl::eolian::eo_class& cls, Eolian_Class const& klass)
 {
    efl::eolian::events_container_type events = event_list(klass);
    cls.events.reserve(cls.events.size() + events.size());
@@ -277,7 +277,7 @@ convert_eolian_events(efl::eolian::eo_class& cls, Eolian_Class const *& klass)
 }
 
 efl::eolian::eo_class
-convert_eolian_class_new(Eolian_Class const *& klass)
+convert_eolian_class_new(Eolian_Class const& klass)
 {
    efl::eolian::eo_class cls;
    cls.type = class_type(klass);
@@ -289,9 +289,8 @@ convert_eolian_class_new(Eolian_Class const *& klass)
 }
 
 efl::eolian::eo_class
-convert_eolian_class(const Eolian_Class *klass)
+convert_eolian_class(const Eolian_Class& klass)
 {
-   assert(klass != NULL);
    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);

src/bin/eolian_cxx/convert.hh

@@ -12,7 +12,7 @@ namespace eolian_cxx
 /// @param cls The Eolian class.
 /// @return The @p eo_class describing @p classname.
 ///
-efl::eolian::eo_class convert_eolian_class(const Eolian_Class *klass);
+efl::eolian::eo_class convert_eolian_class(const Eolian_Class& klass);
 
 }
 

src/bin/eolian_cxx/convert_comments.cc

@@ -10,7 +10,7 @@ _comment_parameter(Eolian_Function_Parameter *param)
    Eolian_Parameter_Dir direction;
    Eina_Stringshare *description;
 
-   eolian_parameter_information_get
+   ::eolian_parameter_information_get
      (param, &direction, NULL, NULL, &description);
 
    std::string doc = "@param";
@@ -19,7 +19,7 @@ _comment_parameter(Eolian_Function_Parameter *param)
    else if (direction == EOLIAN_INOUT_PARAM) doc += "[inout] ";
    else assert(false);
 
-   doc += safe_strshare(eolian_parameter_name_get(param));
+   doc += safe_strshare(::eolian_parameter_name_get(param));
    doc += " ";
    doc += safe_str(description);
 
@@ -45,12 +45,12 @@ _comment_brief_and_params(Eolian_Function function,
                           const char *key = EOLIAN_COMMENT)
 {
    std::string doc = "";
-   std::string func = safe_str(eolian_function_description_get(function, key));
+   std::string func = safe_str(::eolian_function_description_get(function, key));
    if (func != "")
      {
         doc += "@brief " + func + "\n\n";
      }
-   std::string params = _comment_parameters_list(eolian_parameters_list_get(function));
+   std::string params = _comment_parameters_list(::eolian_parameters_list_get(function));
    if (params != "")
      {
         doc += params + "\n";
@@ -62,13 +62,13 @@ static std::string
 _comment_return(Eolian_Function function,
                 Eolian_Function_Type rettype)
 {
-   Eolian_Type *rettypet = eolian_function_return_type_get(function, rettype);
+   Eolian_Type *rettypet = ::eolian_function_return_type_get(function, rettype);
    const char *rettypes = NULL;
-   if (rettypet) rettypes = eolian_type_c_type_get(rettypet);
+   if (rettypet) rettypes = ::eolian_type_c_type_get(rettypet);
    std::string doc = "";
    std::string ret = safe_str(rettypes);
    if (rettypes) eina_stringshare_del(rettypes);
-   std::string comment = safe_str(eolian_function_return_comment_get(function, rettype));
+   std::string comment = safe_str(::eolian_function_return_comment_get(function, rettype));
    if (ret != "void" && ret != "" && comment != "")
      {
         doc = "@return " + comment;
@@ -77,9 +77,9 @@ _comment_return(Eolian_Function function,
 }
 
 std::string
-convert_comments_class(Eolian_Class const *& klass)
+convert_comments_class(Eolian_Class const& klass)
 {
-   return safe_str(eolian_class_description_get(klass));
+   return safe_str(::eolian_class_description_get(&klass));
 }
 
 std::string

src/bin/eolian_cxx/convert_comments.hh

@@ -11,7 +11,7 @@
 
 namespace eolian_cxx {
 
-std::string convert_comments_class(Eolian_Class const *& kls);
+std::string convert_comments_class(Eolian_Class const& kls);
 
 std::string convert_comments_function(Eolian_Function const& function,
                                       Eolian_Function_Type func_type);

src/bin/eolian_cxx/eolian_cxx.cc

@@ -88,17 +88,17 @@ opts_check(eolian_cxx::options_type const& opts)
 }
 
 efl::eolian::eo_generator_options
-generator_options(const Eolian_Class *klass)
+generator_options(const Eolian_Class& klass)
 {
    efl::eolian::eo_generator_options gen_opts;
    gen_opts.c_headers.push_back(class_base_file(klass) + ".h");
 
    void *cur = NULL;
-   const Eina_List *itr, *inheritances = eolian_class_inherits_list_get(klass);
+   const Eina_List *itr, *inheritances = ::eolian_class_inherits_list_get(&klass);
    EINA_LIST_FOREACH(inheritances, itr, cur)
      {
-        const Eolian_Class *ext = eolian_class_find_by_name(static_cast<const char*>(cur));
-        std::string eo_parent_file = class_base_file(ext);
+        const Eolian_Class *ext = ::eolian_class_find_by_name(static_cast<const char*>(cur));
+        std::string eo_parent_file = class_base_file(*ext);
         if (!eo_parent_file.empty())
           {
              // we have our own eo_base.hh
@@ -121,9 +121,8 @@ generator_options(const Eolian_Class *klass)
 }
 
 static bool
-generate(const Eolian_Class *klass, eolian_cxx::options_type const& opts)
+generate(const Eolian_Class& klass, eolian_cxx::options_type const& opts)
 {
-   assert(!!klass);
    efl::eolian::eo_class cls = eolian_cxx::convert_eolian_class(klass);
    efl::eolian::eo_generator_options gen_opts = generator_options(klass);
    std::string outname = opts.out_file.empty() ? (class_base_file(klass) + ".hh") : opts.out_file;
@@ -164,17 +163,17 @@ run(options_type const& opts)
      klass = class_from_file(opts.in_file);
    if (klass)
      {
-        if (!generate(klass, opts))
+        if (!generate(*klass, opts))
           goto err;
      }
    else
      {
         auto classes = class_list_all();
-        for (const Eolian_Class *c : classes)
+        for (const Eolian_Class& c : classes)
           {
              if (!generate(c, opts))
                {
-                  klass = c;
+                  klass = &c;
                   goto err;
                }
           }
@@ -182,7 +181,7 @@ run(options_type const& opts)
    return;
  err:
    EINA_CXX_DOM_LOG_ERR(eolian_cxx::domain)
-     << "Error generating: " << class_name(klass)
+     << "Error generating: " << class_name(*klass)
      << std::endl;
    std::abort();
 }

src/bin/eolian_cxx/eolian_wrappers.hh

@@ -27,34 +27,34 @@ method_t const method = {};
 struct ctor_t { static constexpr ::Eolian_Function_Type value = ::EOLIAN_CTOR; };
 ctor_t const ctor = {};
 
-inline Eolian_Class *
+inline Eolian_Class*
 class_from_file(std::string const& file)
 {
    return ::eolian_class_find_by_file(file.c_str());
 }
 
 inline std::string
-class_file(Eolian_Class const *& klass)
+class_file(Eolian_Class const& klass)
 {
-   return safe_str(::eolian_class_file_get(klass));
+   return safe_str(::eolian_class_file_get(&klass));
 }
 
 inline std::string
-class_base_file(Eolian_Class const *& klass)
+class_base_file(Eolian_Class const& klass)
 {
-   return path_base(safe_str(::eolian_class_file_get(klass)));
+   return path_base(safe_str(::eolian_class_file_get(&klass)));
 }
 
 inline std::string
-class_name(Eolian_Class const *& klass)
+class_name(Eolian_Class const& klass)
 {
-   return safe_str(::eolian_class_name_get(klass));
+   return safe_str(::eolian_class_name_get(&klass));
 }
 
 inline std::string
-class_full_name(Eolian_Class const *& klass)
+class_full_name(Eolian_Class const& klass)
 {
-   return safe_str(::eolian_class_full_name_get(klass));
+   return safe_str(::eolian_class_full_name_get(&klass));
 }
 
 inline Eolian_Class *
@@ -64,10 +64,10 @@ class_from_name(std::string const& classname)
 }
 
 inline std::string
-class_eo_name(Eolian_Class const *& klass)
+class_eo_name(Eolian_Class const& klass)
 {
    std::string suffix;
-   switch (eolian_class_type_get(klass))
+   switch (::eolian_class_type_get(&klass))
      {
         case EOLIAN_CLASS_REGULAR:
         case EOLIAN_CLASS_ABSTRACT:
@@ -105,9 +105,9 @@ class_format_cxx(std::string const& fullname)
 }
 
 inline std::string
-class_prefix(Eolian_Class const *& klass)
+class_prefix(Eolian_Class const& klass)
 {
-   std::string prefix = safe_lower(::eolian_class_eo_prefix_get(klass));
+   std::string prefix = safe_lower(::eolian_class_eo_prefix_get(&klass));
    if (prefix.empty())
      prefix = safe_lower(find_replace(class_full_name(klass), ".", "_"));
    assert(!prefix.empty());
@@ -115,11 +115,10 @@ class_prefix(Eolian_Class const *& klass)
 }
 
 inline efl::eolian::eo_class::eo_class_type
-class_type(Eolian_Class const *& klass)
+class_type(Eolian_Class const& klass)
 {
-   assert(klass != NULL);
    efl::eolian::eo_class::eo_class_type type;
-   Eolian_Class_Type cls_type = ::eolian_class_type_get(klass);
+   Eolian_Class_Type cls_type = ::eolian_class_type_get(&klass);
 
    if (cls_type == EOLIAN_CLASS_REGULAR)
      type = efl::eolian::eo_class::regular_;
@@ -135,11 +134,11 @@ class_type(Eolian_Class const *& klass)
 }
 
 inline std::string
-class_namespace_full(Eolian_Class const *& klass)
+class_namespace_full(Eolian_Class const& klass)
 {
    std::string s;
    const Eina_List* list =
-     ::eolian_class_namespaces_list_get(klass), *itr;
+     ::eolian_class_namespaces_list_get(&klass), *itr;
    void* name;
    EINA_LIST_FOREACH(list, itr, name)
      {
@@ -151,10 +150,10 @@ class_namespace_full(Eolian_Class const *& klass)
    return safe_lower(s);
 }
 
-inline efl::eina::range_ptr_list<const Eolian_Class *>
+inline efl::eina::range_ptr_list<const Eolian_Class>
 class_list_all()
 {
-   return (Eina_List*)::eolian_all_classes_list_get();
+   return ::eolian_all_classes_list_get();
 }
 
 inline std::string
@@ -308,7 +307,7 @@ parameter_type(Eolian_Function_Parameter const *& parameter, setter_t func_type)
 }
 
 inline efl::eolian::eo_event
-event_create(Eolian_Class const *& klass, const Eolian_Event *event_)
+event_create(Eolian_Class const& klass, const Eolian_Event *event_)
 {
    efl::eolian::eo_event event;
    const char *name, *type, *comment;
@@ -325,10 +324,10 @@ event_create(Eolian_Class const *& klass, const Eolian_Event *event_)
 }
 
 inline efl::eolian::events_container_type
-event_list(Eolian_Class const *& klass)
+event_list(Eolian_Class const& klass)
 {
    efl::eolian::events_container_type events;
-   const Eina_List* list = eolian_class_events_list_get(klass);
+   const Eina_List* list = ::eolian_class_events_list_get(&klass);
    unsigned int length = eina_list_count(list);
    for (unsigned int i = 0; i < length; ++i)
      {