cxx: Add support for function pointers

This was tested on the function pointer Efl.Ui.Format_Func_Cb

8 files changed, 275 insertions, 25 deletions

diff --git a/src/lib/eolian_cxx/grammar/converting_argument.hpp b/src/lib/eolian_cxx/grammar/converting_argument.hpp
index 230608ffc3..eb7ef57376 100644
--- a/src/lib/eolian_cxx/grammar/converting_argument.hpp
+++ b/src/lib/eolian_cxx/grammar/converting_argument.hpp
@@ -33,24 +33,12 @@ struct converting_argument_generator
    bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& ctx) const
    {
      attributes::qualifier_def qualifier = param.type.original_type.visit(attributes::get_qualifier_visitor{});
-     bool is_function_ptr = param.type.original_type.visit(this->is_function_ptr);
-     if(is_function_ptr)
-       return as_generator
-       (
-        attribute_reorder<-1, -1, 2, -1, -1, -1, -1>
-        (
-         " ::efl::eolian::data_function_ptr_to_c<" << c_type
-         << ", " << parameter_type
-         << ">(" << string << ")"
-
-         ", ::efl::eolian::function_ptr_to_c<" << c_type
-         << ", " << parameter_type
-         << ">()"
-         ", ::efl::eolian::free_function_ptr_to_c<" << c_type
-         << ", " << parameter_type
-         << ">()"
-        )
-       ).generate(sink, param, ctx);
+     if (param.type.original_type.visit(this->is_function_ptr))
+       {
+          // FIXME: This supports only one function pointer.
+          return as_generator("fw->data_to_c(), fw->func_to_c(), fw->free_to_c()")
+                .generate(sink, param, ctx);
+       }
      else
        return as_generator
        (
diff --git a/src/lib/eolian_cxx/grammar/function_declaration.hpp b/src/lib/eolian_cxx/grammar/function_declaration.hpp
index e98fbf0a3a..641ae6560c 100644
--- a/src/lib/eolian_cxx/grammar/function_declaration.hpp
+++ b/src/lib/eolian_cxx/grammar/function_declaration.hpp
@@ -1,3 +1,4 @@
+
 #ifndef EOLIAN_CXX_FUNCTION_DECLARATION_HH
 #define EOLIAN_CXX_FUNCTION_DECLARATION_HH
 
@@ -42,6 +43,13 @@ struct function_declaration_generator
             !as_generator("#ifdef " << *(string << "_") << string << "_" << string << "_BETA\n")
             .generate(sink, std::make_tuple(_klass_name.namespaces, _klass_name.eolian_name, suffix), add_upper_case_context(ctx)))
         return false;
+
+      std::string template_statement(f.template_statement());
+      if (!template_statement.empty() &&
+          !as_generator(template_statement << " ")
+          .generate(sink, attributes::unused, ctx))
+        return false;
+
       if(!as_generator
             ("::efl::eolian::return_traits<" << grammar::type(true) << ">::type " << string << "(" << (parameter % ", ") << ") const;\n")
             .generate(sink, std::make_tuple(f.return_type, escape_keyword(f.name), f.parameters), ctx))
diff --git a/src/lib/eolian_cxx/grammar/function_definition.hpp b/src/lib/eolian_cxx/grammar/function_definition.hpp
index 50bd9970c5..55f56216fd 100644
--- a/src/lib/eolian_cxx/grammar/function_definition.hpp
+++ b/src/lib/eolian_cxx/grammar/function_definition.hpp
@@ -17,6 +17,7 @@
 #include "grammar/attribute_conditional.hpp"
 #include "grammar/attribute_reorder.hpp"
 #include "grammar/type_impl.hpp"
+#include "grammar/eps.hpp"
 
 namespace efl { namespace eolian { namespace grammar {
 
@@ -52,12 +53,24 @@ struct function_definition_generator
          !as_generator("#ifdef " << *(string << "_") << string << "_PROTECTED\n")
          .generate(sink, std::make_tuple(_klass_name.namespaces, _klass_name.eolian_name), add_upper_case_context(ctx)))
         return false;
-     
+
+      std::string template_statement(f.template_statement());
+      if (!template_statement.empty() &&
+          !as_generator(template_statement << "\n")
+          .generate(sink, attributes::unused, ctx))
+        return false;
+
       if(!as_generator
          ("inline ::efl::eolian::return_traits<" << grammar::type(true) << ">::type " << string << "::" << string << "(" << (parameter % ", ") << ") const\n{\n")
          .generate(sink, std::make_tuple(f.return_type, _klass_name.eolian_name, escape_keyword(f.name), f.parameters), ctx))
         return false;
 
+      std::vector<std::string> opening_statements(f.opening_statements());
+      if (!opening_statements.empty() &&
+          !as_generator(scope_tab << *(string) << "\n")
+          .generate(sink, std::make_tuple(opening_statements), ctx))
+        return false;
+
       auto out_declaration =
         attribute_conditional([] (attributes::parameter_def const& p) -> bool
                               { return p.direction == attributes::parameter_direction::out; })
@@ -118,8 +131,8 @@ struct function_definition_generator
             scope_tab << "::efl::eolian::assign_out<" << parameter_type << ", " << c_type
             <<
             (
-             attribute_conditional([] (attributes::type_def const& type)
-             { return type.original_type.visit(attributes::get_qualifier_visitor{}) & qualifier_info::is_own; })
+             attribute_conditional([] (attributes::type_def const& typ)
+             { return typ.original_type.visit(attributes::get_qualifier_visitor{}) & qualifier_info::is_own; })
              [
                ", true"
              ] | eps
diff --git a/src/lib/eolian_cxx/grammar/header.hpp b/src/lib/eolian_cxx/grammar/header.hpp
index 63a6095949..4f1df9233f 100644
--- a/src/lib/eolian_cxx/grammar/header.hpp
+++ b/src/lib/eolian_cxx/grammar/header.hpp
@@ -24,6 +24,7 @@ auto class_header =
     << "#include <Eina.hh>\n"
        "#include <Eo.hh>\n"
     << *header_include_directive // sequence<string>
+    <<  string                   // extra header <string>
     << *class_declaration          // sequence<class> | class
     << *class_forward_declaration          // sequence<class> | class
     << "\nnamespace eo_cxx {\n"
diff --git a/src/lib/eolian_cxx/grammar/klass_def.hpp b/src/lib/eolian_cxx/grammar/klass_def.hpp
index edfadc05bb..f7b12af578 100644
--- a/src/lib/eolian_cxx/grammar/klass_def.hpp
+++ b/src/lib/eolian_cxx/grammar/klass_def.hpp
@@ -433,6 +433,7 @@ struct function_def
   std::string filename;
   bool is_beta;
   bool is_protected;
+  bool is_function_pointer;
 
   friend inline bool operator==(function_def const& lhs, function_def const& rhs)
   {
@@ -442,17 +443,27 @@ struct function_def
       && lhs.c_name == rhs.c_name
       && lhs.filename == rhs.filename
       && lhs.is_beta == rhs.is_beta
-      && lhs.is_protected == rhs.is_protected;
+      && lhs.is_protected == rhs.is_protected
+      && lhs.is_function_pointer == rhs.is_function_pointer;
   }
   friend inline bool operator!=(function_def const& lhs, function_def const& rhs)
   {
     return !(lhs == rhs);
   }
-  
+  function_def() = default;
   function_def(type_def return_type, std::string name, std::vector<parameter_def> parameters
                , std::string c_name, std::string filename, bool is_beta)
     : return_type(return_type), name(name), parameters(parameters), c_name(c_name), filename(filename), is_beta(is_beta) {}
-  function_def() = default;
+  function_def(type_def _return_type, std::string const& _name,
+               std::vector<parameter_def> const& _parameters,
+               std::string const& _c_name,
+               bool _is_beta = false,
+               bool _is_protected = false,
+               bool _is_function_pointer = false)
+    : return_type(_return_type), name(_name), parameters(_parameters),
+      c_name(_c_name), is_beta(_is_beta), is_protected(_is_protected),
+      is_function_pointer(_is_function_pointer) {}
+
   function_def( ::Eolian_Function const* function, Eolian_Function_Type type, Eolian_Unit const* unit)
     : return_type(void_)
   {
@@ -517,6 +528,49 @@ struct function_def
      is_protected = eolian_function_scope_get(function, type) == EOLIAN_SCOPE_PROTECTED;
      is_protected = eolian_function_scope_get(function, type) == EOLIAN_SCOPE_PROTECTED;
   }
+
+  std::string template_statement() const
+  {
+     std::string statement;
+     char template_typename = 'F';
+     for (auto const& param : this->parameters)
+       {
+          attributes::regular_type_def const* typ =
+                efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
+          if (typ && typ->is_function_ptr)
+            {
+               char typenam[2] = { 0, };
+               typenam[0] = template_typename++;
+               if (statement.empty())
+                 statement = std::string("template <typename ") + typenam;
+               else
+                 statement += std::string(", typename ") + typenam;
+            }
+       }
+     if (statement.empty()) return statement;
+     else return statement + ">";
+  }
+
+  std::vector<std::string> opening_statements() const
+  {
+     // FIXME: Supports only one function pointer
+     std::vector<std::string> statements;
+     char template_typename = 'F';
+     for (auto const& param : this->parameters)
+       {
+          attributes::regular_type_def const* typ =
+                efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
+          if (typ && typ->is_function_ptr)
+            {
+               char typenam[2] = { 0, };
+               typenam[0] = template_typename++;
+               std::string statement = "auto fw = new ::efl::eolian::function_wrapper<";
+               statement += param.c_type + ", " + typenam + ">(" + param.param_name + ");";
+               statements.push_back(statement);
+            }
+       }
+     return statements;
+  }
 };
 
 template <>
diff --git a/src/lib/eolian_cxx/grammar/parameter.hpp b/src/lib/eolian_cxx/grammar/parameter.hpp
index f9e625a514..5d8d3aef5c 100644
--- a/src/lib/eolian_cxx/grammar/parameter.hpp
+++ b/src/lib/eolian_cxx/grammar/parameter.hpp
@@ -25,6 +25,12 @@ struct parameter_type_generator
             dir = "in";
           break;
         }
+
+      attributes::regular_type_def const* typ =
+            efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
+      if (typ && typ->is_function_ptr)
+        return as_generator("F").generate(sink, attributes::unused, context);
+
       return as_generator
         (
          " ::efl::eolian::" << string << "_traits<"
@@ -44,6 +50,8 @@ struct attributes_needed<parameter_type_generator> : std::integral_constant<int,
 
 parameter_type_generator const parameter_type = {};
 
+
+/* */
 struct parameter_generator
 {
    template <typename OutputIterator, typename Context>
@@ -59,9 +67,28 @@ template <>
 struct is_generator<parameter_generator> : std::true_type {};
 namespace type_traits {
 template <>
-struct attributes_needed<parameter_generator> : std::integral_constant<int, 1> {};  
+struct attributes_needed<parameter_generator> : std::integral_constant<int, 1> {};
 }
 parameter_generator const parameter = {};
+
+
+/* */
+struct parameter_as_argument_generator
+{
+   template <typename OutputIterator, typename Context>
+   bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
+   {
+      return as_generator(parameter_type << "(" << string << ")").generate(sink, std::make_tuple(param, param.param_name), context);
+   }
+};
+
+template <>
+struct is_eager_generator<parameter_as_argument_generator> : std::true_type {};
+namespace type_traits {
+template <>
+struct attributes_needed<parameter_as_argument_generator> : std::integral_constant<int, 1> {};
+}
+parameter_as_argument_generator const parameter_as_argument = {};
       
 } } }
 
diff --git a/src/lib/eolian_cxx/grammar/type_function_declaration.hpp b/src/lib/eolian_cxx/grammar/type_function_declaration.hpp
new file mode 100644
index 0000000000..eccedf8f4a
--- /dev/null
+++ b/src/lib/eolian_cxx/grammar/type_function_declaration.hpp
@@ -0,0 +1,121 @@
+#ifndef EOLIAN_CXX_TYPE_FUNCTION_DECLARATION_HH
+#define EOLIAN_CXX_TYPE_FUNCTION_DECLARATION_HH
+
+#include "grammar/generator.hpp"
+#include "grammar/klass_def.hpp"
+
+#include "grammar/string.hpp"
+#include "grammar/indentation.hpp"
+#include "grammar/list.hpp"
+#include "grammar/alternative.hpp"
+#include "grammar/type.hpp"
+#include "grammar/parameter.hpp"
+#include "grammar/keyword.hpp"
+#include "grammar/converting_argument.hpp"
+#include "grammar/eps.hpp"
+
+namespace efl { namespace eolian { namespace grammar {
+
+/** This generates the caller struct for function pointers. */
+struct type_function_declaration_generator {
+   type_function_declaration_generator() {}
+
+   template <typename OutputIterator, typename Context>
+   bool generate(OutputIterator sink, attributes::function_def const& f, Context const& ctx) const
+   {
+      std::string guard = f.c_name + "_defined";
+
+      if (!as_generator("#ifndef " << string << "\n" <<
+                        "#define " << string << "\n")
+          .generate(sink, std::make_tuple(guard, guard), add_upper_case_context(ctx)))
+        return false;
+
+      // efl::eolian::function_wrapper<T, F>
+      if (!as_generator("namespace efl { namespace eolian {\n")
+          .generate(sink, attributes::unused, add_lower_case_context(ctx)))
+      return false;
+
+      if (!as_generator(
+             "template <typename F>\n"
+             "struct function_wrapper<" << string << ", F> {\n"
+             << scope_tab << "function_wrapper(F cxx_func) : _cxx_func(cxx_func) {}\n"
+             ).generate(sink, f.c_name, ctx))
+        return false;
+
+      if (!as_generator(
+             scope_tab << "void *data_to_c() { return static_cast<void *>(this); }\n"
+             << scope_tab << string << " func_to_c() const { return &caller; }\n"
+             << scope_tab << "Eina_Free_Cb free_to_c() const { return &deleter; }\n"
+             << "private:\n"
+             << scope_tab << "F _cxx_func;\n"
+             << scope_tab << "static void deleter(void *data) {\n"
+             << scope_tab << scope_tab << "delete static_cast<function_wrapper<" << string << ", F>*>(data);\n"
+             << scope_tab << "}\n"
+             ).generate(sink, std::make_tuple(f.c_name, f.c_name), ctx))
+        return false;
+
+      std::vector<std::string> c_args;
+      for (auto itr : f.parameters)
+        c_args.push_back(", " + itr.c_type + " " + itr.param_name);
+      if (!as_generator(
+             scope_tab << "static " << string << " caller(void *cxx_call_data"
+             << *(string) << ") {\n"
+             << scope_tab << scope_tab << "auto fw = static_cast<function_wrapper<"
+             << string << ", F>*>(cxx_call_data);\n"
+             ).generate(sink, std::make_tuple(f.return_type.c_type, c_args, f.c_name), ctx))
+        return false;
+
+      if (f.return_type != attributes::void_
+          && !as_generator(scope_tab << scope_tab << "auto __return_value =\n")
+          .generate(sink, attributes::unused, ctx))
+        return false;
+
+      if (!f.parameters.empty())
+        {
+           std::vector<attributes::parameter_def> params;
+           for (auto itr = f.parameters.begin() + 1; itr != f.parameters.end(); itr++)
+             params.push_back(*itr);
+           if (!as_generator(
+                  scope_tab << scope_tab << "fw->_cxx_func(" << parameter_as_argument << *(", " << parameter_as_argument) << ");\n"
+                  ).generate(sink, std::make_tuple(*f.parameters.begin(), params), ctx))
+               return false;
+        }
+
+      if (f.return_type != attributes::void_
+          && !as_generator(scope_tab << scope_tab << "return ::efl::eolian::convert_to_c<"
+                           << type << ">(__return_value);\n")
+          .generate(sink, f.return_type, ctx))
+        return false;
+
+      if (!as_generator(scope_tab << "}\n").generate(sink, attributes::unused, ctx))
+        return false;
+
+      if (!as_generator("};\n"
+                        "} }\n"
+                        "#endif\n\n")
+          .generate(sink, attributes::unused, ctx))
+        return false;
+
+      return true;
+   }
+};
+
+template <>
+struct is_eager_generator<type_function_declaration_generator> : std::true_type {};
+
+namespace type_traits {
+template <>
+struct attributes_needed<type_function_declaration_generator> : std::integral_constant<int, 1> {};
+}
+
+struct type_function_declaration_terminal
+{
+  type_function_declaration_generator operator()() const
+  {
+    return type_function_declaration_generator{};
+  }
+} const type_function_declaration = {};
+
+} } }
+
+#endif
diff --git a/src/lib/eolian_cxx/grammar/types_definition.hpp b/src/lib/eolian_cxx/grammar/types_definition.hpp
new file mode 100644
index 0000000000..e4c40737d6
--- /dev/null
+++ b/src/lib/eolian_cxx/grammar/types_definition.hpp
@@ -0,0 +1,38 @@
+#ifndef EOLIAN_CXX_TYPES_DEFINITION_HH
+#define EOLIAN_CXX_TYPES_DEFINITION_HH
+
+#include "header_guards.hpp"
+#include "eps.hpp"
+#include "string.hpp"
+#include "sequence.hpp"
+#include "kleene.hpp"
+#include "header_include_directive.hpp"
+#include "type_function_declaration.hpp"
+
+namespace efl { namespace eolian { namespace grammar {
+
+struct types_definition_generator
+{
+   template <typename OutputIterator, typename Context>
+   bool generate(OutputIterator sink, std::vector<attributes::function_def> const& functions, Context const& ctx) const
+   {
+      if(!as_generator(*(type_function_declaration()))
+            .generate(sink, functions, ctx))
+        return false;
+      return true;
+   }
+};
+
+template <>
+struct is_eager_generator<types_definition_generator> : std::true_type {};
+
+namespace type_traits {
+template <>
+struct attributes_needed<types_definition_generator> : std::integral_constant<int, 1> {};
+}
+
+types_definition_generator const types_definition = {};
+
+} } }
+
+#endif