summaryrefslogtreecommitdiff
path: root/src/bin/eolian_mono/eolian/mono/parameter.hh
diff options
context:
space:
mode:
Diffstat (limited to 'src/bin/eolian_mono/eolian/mono/parameter.hh')
-rw-r--r--src/bin/eolian_mono/eolian/mono/parameter.hh236
1 files changed, 182 insertions, 54 deletions
diff --git a/src/bin/eolian_mono/eolian/mono/parameter.hh b/src/bin/eolian_mono/eolian/mono/parameter.hh
index 834ca1248d..55ea6f4115 100644
--- a/src/bin/eolian_mono/eolian/mono/parameter.hh
+++ b/src/bin/eolian_mono/eolian/mono/parameter.hh
@@ -8,8 +8,9 @@
#include "marshall_type.hh"
#include "type.hh"
#include "using_decl.hh"
-#include "keyword.hh"
+#include "name_helpers.hh"
+using namespace eolian_mono::name_helpers;
namespace eolian_mono {
struct parameter_generator;
@@ -22,6 +23,8 @@ namespace eolian_mono {
struct native_convert_out_variable_generator;
struct convert_out_variable_generator;
struct convert_out_assign_generator;
+ struct native_convert_in_ptr_assign_generator;
+ struct convert_in_ptr_assign_generator;
struct native_convert_out_assign_parameterized;
struct native_convert_out_assign_generator;
struct convert_return_generator;
@@ -136,6 +139,26 @@ struct attributes_needed< ::eolian_mono::convert_out_assign_generator> : std::in
}
template <>
+struct is_eager_generator< ::eolian_mono::native_convert_in_ptr_assign_generator> : std::true_type {};
+template <>
+struct is_generator< ::eolian_mono::native_convert_in_ptr_assign_generator> : std::true_type {};
+
+namespace type_traits {
+template <>
+struct attributes_needed< ::eolian_mono::native_convert_in_ptr_assign_generator> : std::integral_constant<int, 1> {};
+}
+
+template <>
+struct is_eager_generator< ::eolian_mono::convert_in_ptr_assign_generator> : std::true_type {};
+template <>
+struct is_generator< ::eolian_mono::convert_in_ptr_assign_generator> : std::true_type {};
+
+namespace type_traits {
+template <>
+struct attributes_needed< ::eolian_mono::convert_in_ptr_assign_generator> : std::integral_constant<int, 1> {};
+}
+
+template <>
struct is_eager_generator< ::eolian_mono::convert_return_variable_generator> : std::true_type {};
template <>
struct is_generator< ::eolian_mono::convert_return_variable_generator> : std::true_type {};
@@ -252,6 +275,10 @@ inline bool param_should_use_out_var(attributes::parameter_def const& param, boo
|| param_is_acceptable(param, "Eina_Inlist *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Hash *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Hash *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Hash *", !WANT_OWN, WANT_OUT)
@@ -266,10 +293,10 @@ inline bool param_should_use_out_var(attributes::parameter_def const& param, boo
return true;
auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (need_struct_conversion(regular))
+ if (helpers::need_struct_conversion(regular))
return true;
- if (param.type.is_ptr && need_pointer_conversion(regular))
+ if (param.type.is_ptr && helpers::need_pointer_conversion(regular))
return true;
return false;
@@ -298,6 +325,10 @@ inline bool param_should_use_in_var(attributes::parameter_def const& param, bool
|| param_is_acceptable(param, "const Eina_List *", WANT_OWN, !WANT_OUT)
|| param_is_acceptable(param, "Eina_Inlist *", !WANT_OWN, !WANT_OUT)
|| param_is_acceptable(param, "Eina_Inlist *", WANT_OWN, !WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, !WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, !WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, !WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, !WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", !WANT_OWN, !WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", WANT_OWN, !WANT_OUT)
|| param_is_acceptable(param, "Eina_Hash *", !WANT_OWN, !WANT_OUT)
@@ -314,10 +345,10 @@ inline bool param_should_use_in_var(attributes::parameter_def const& param, bool
return true;
auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (need_struct_conversion(regular))
+ if (helpers::need_struct_conversion(regular))
return true;
- if (param.type.is_ptr && need_pointer_conversion(regular))
+ if (param.type.is_ptr && helpers::need_pointer_conversion(regular))
return true;
return false;
@@ -341,16 +372,31 @@ inline std::string direction_modifier(attributes::parameter_def const& param)
}
else if (param.direction != attributes::parameter_direction::in)
{
- auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (param.type.c_type == "Eina_Slice" || param.type.c_type == "Eina_Rw_Slice"
- || need_struct_conversion(regular))
+ if (param.type.c_type == "Eina_Slice" || param.type.c_type == "Eina_Rw_Slice")
return " ref ";
else
return " out ";
}
+ else if (param.direction == attributes::parameter_direction::in && param.type.is_ptr)
+ {
+ auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
+ if (helpers::need_struct_conversion(regular))
+ return " ref "; // Don't add ref on Marshal if it is ptr
+ }
return " ";
}
+std::string marshall_direction_modifier(attributes::parameter_def const& param)
+{
+ if (param.direction == attributes::parameter_direction::in && param.type.is_ptr)
+ {
+ auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
+ if (helpers::need_struct_conversion(regular) && param.type.has_own)
+ return " "; // Don't add ref on Marshal if it is ptr
+ }
+ return direction_modifier(param);
+}
+
struct is_fp_visitor
{
typedef is_fp_visitor visitor_type;
@@ -375,11 +421,7 @@ struct type_name_visitor
std::string operator()(grammar::attributes::regular_type_def const &type) const
{
- std::stringstream type_name;
- for (auto&& i : escape_namespace(type.namespaces))
- type_name << i << ".";
- type_name << type.base_type;
- return type_name.str();
+ return name_helpers::type_full_eolian_name(type);
}
template<typename T>
@@ -412,7 +454,7 @@ struct marshall_parameter_generator
if (!param.type.original_type.visit(is_fp_visitor{}))
return as_generator(
- direction_modifier(param) << marshall_type << " " << string
+ marshall_direction_modifier(param) << marshall_type << " " << string
).generate(sink, std::make_tuple(param, param_name), context);
return as_generator(
@@ -421,14 +463,15 @@ struct marshall_parameter_generator
).generate(sink, param, context);
}
} const marshall_parameter {};
-
+
+// FIXME This seems to be used only in the else branch of the native function definition. Is it really needed?
struct argument_generator
{
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
{
std::string param_name = escape_keyword(param.param_name);
- std::string direction = direction_modifier(param);
+ std::string direction = marshall_direction_modifier(param);
if (!param.type.original_type.visit(is_fp_visitor{}))
return as_generator(
@@ -475,7 +518,7 @@ struct argument_invocation_generator
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
{
- std::string arg = direction_modifier(param);
+ std::string arg = marshall_direction_modifier(param);
if (use_conversion_vars && param_should_use_out_var(param, false))
arg += out_variable_name(param.param_name);
@@ -507,16 +550,16 @@ struct native_convert_in_variable_generator
return true;
auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (param.type.is_ptr && need_pointer_conversion(regular))
+ if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(param, regular))
{
return as_generator(
"var " << string << " = eina.PrimitiveConversion.PointerToManaged<" << type << ">(" << escape_keyword(param.param_name) << ");\n"
).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
}
- else if (need_struct_conversion(regular))
+ else if (helpers::need_struct_conversion(regular))
{
return as_generator(
- "var " << string << " = " << type << "_StructConvertion.ToExternal(" << escape_keyword(param.param_name) << ");\n"
+ "var " << string << " = " << type << "_StructConversion.ToExternal(" << escape_keyword(param.param_name) << ");\n"
).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
}
else if (param.type.c_type == "Eina_Binbuf *" || param.type.c_type == "const Eina_Binbuf *")
@@ -543,6 +586,7 @@ struct native_convert_in_variable_generator
|| param.type.c_type == "Eina_List *" || param.type.c_type == "const Eina_List *"
|| param.type.c_type == "Eina_Inlist *" || param.type.c_type == "const Eina_Inlist *"
|| param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
+ || param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
@@ -575,16 +619,16 @@ struct convert_in_variable_generator
return true;
auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (param.type.is_ptr && need_pointer_conversion(regular))
+ if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(param, regular))
{
return as_generator(
"var " << string << " = eina.PrimitiveConversion.ManagedToPointerAlloc(" << escape_keyword(param.param_name) << ");\n"
).generate(sink, in_variable_name(param.param_name), context);
}
- else if (need_struct_conversion(regular))
+ else if (helpers::need_struct_conversion(regular))
{
return as_generator(
- "var " << string << " = " << type << "_StructConvertion.ToInternal(" << escape_keyword(param.param_name) << ");\n"
+ "var " << string << " = " << type << "_StructConversion.ToInternal(" << escape_keyword(param.param_name) << ");\n"
).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
}
else if (param.type.c_type == "Eina_Binbuf *" || param.type.c_type == "const Eina_Binbuf *")
@@ -630,6 +674,7 @@ struct convert_in_variable_generator
|| param.type.c_type == "Eina_List *" || param.type.c_type == "const Eina_List *"
|| param.type.c_type == "Eina_Inlist *" || param.type.c_type == "const Eina_Inlist *"
|| param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
+ || param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
@@ -659,7 +704,8 @@ struct convert_in_variable_generator
}
} const convert_in_variable {};
-
+
+/* Some types require an intermediate variable to be filled as out parameter in the marshalled function */
struct convert_out_variable_generator
{
template <typename OutputIterator, typename Context>
@@ -669,17 +715,17 @@ struct convert_out_variable_generator
return true;
auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (param.type.is_ptr && need_pointer_conversion(regular))
+ if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(regular))
{
return as_generator(
"System.IntPtr " << string << " = System.IntPtr.Zero;\n"
).generate(sink, out_variable_name(param.param_name), context);
}
- else if (need_struct_conversion(regular))
+ else if (helpers::need_struct_conversion(regular))
{
return as_generator(
"var " << string << " = new " << marshall_type << "();\n"
- ).generate(sink, std::make_tuple(out_variable_name(param.param_name), param.type), context);
+ ).generate(sink, std::make_tuple(out_variable_name(param.param_name), param), context);
}
else if (param_is_acceptable(param, "Eina_Binbuf *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Binbuf *", !WANT_OWN, WANT_OUT)
@@ -707,6 +753,10 @@ struct convert_out_variable_generator
|| param_is_acceptable(param, "Eina_Inlist *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Hash *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Hash *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Hash *", WANT_OWN, WANT_OUT)
@@ -742,13 +792,13 @@ struct native_convert_out_variable_generator
return true;
auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (param.type.is_ptr && need_pointer_conversion(regular))
+ if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(regular))
{
return as_generator(
type << " " << string << " = default(" << type << ");\n"
).generate(sink, std::make_tuple(param, out_variable_name(param.param_name), param), context);
}
- else if (need_struct_conversion(regular)
+ else if (helpers::need_struct_conversion(regular)
|| param_is_acceptable(param, "const char *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Stringshare *", !WANT_OWN, WANT_OUT))
{
@@ -782,6 +832,10 @@ struct native_convert_out_variable_generator
|| param_is_acceptable(param, "Eina_Inlist *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Hash *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Hash *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Hash *", WANT_OWN, WANT_OUT)
@@ -819,6 +873,7 @@ struct native_convert_out_variable_generator
} const native_convert_out_variable {};
+/* Assign the Managed out variables from the marshalled intermediate ones if needed. */
struct convert_out_assign_generator
{
template <typename OutputIterator, typename Context>
@@ -828,16 +883,22 @@ struct convert_out_assign_generator
return true;
auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (param.type.is_ptr && need_pointer_conversion(regular))
+ if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(param.type, param.direction))
{
- return as_generator(
+ bool ret = as_generator(
string << " = eina.PrimitiveConversion.PointerToManaged<" << type << ">(" << out_variable_name(param.param_name) << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type), context);
+
+ if (param.type.has_own)
+ ret = ret && as_generator(scope_tab << scope_tab << "Marshal.FreeHGlobal(" << out_variable_name(param.param_name) << ");\n"
+ ).generate(sink, attributes::unused, context);
+
+ return ret;
}
- else if (need_struct_conversion(regular))
+ else if (helpers::need_struct_conversion(regular))
{
return as_generator(
- string << " = " << type << "_StructConvertion.ToExternal(" << out_variable_name(param.param_name) << ");\n"
+ string << " = " << type << "_StructConversion.ToExternal(" << out_variable_name(param.param_name) << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type), context);
}
else if (param_is_acceptable(param, "Eina_Binbuf *", WANT_OWN, WANT_OUT)
@@ -883,6 +944,10 @@ struct convert_out_assign_generator
|| param_is_acceptable(param, "Eina_Inlist *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Inlist *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Iterator *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Iterator *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Iterator *", WANT_OWN, WANT_OUT)
@@ -911,6 +976,40 @@ struct convert_out_assign_generator
} const convert_out_assign {};
+struct native_convert_in_ptr_assign_generator
+{
+ template <typename OutputIterator, typename Context>
+ bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
+ {
+ auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
+ if (param_should_use_in_var(param, true) && param.type.is_ptr && !param.type.has_own && helpers::need_struct_conversion(regular))
+ {
+ return as_generator(
+ string << " = " << type << "_StructConversion.ToInternal(" << in_variable_name(param.param_name) << ");\n"
+ ).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type), context);
+ }
+
+ return true;
+ }
+} const native_convert_in_ptr_assign {};
+
+struct convert_in_ptr_assign_generator
+{
+ template <typename OutputIterator, typename Context>
+ bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
+ {
+ auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
+ if (param_should_use_in_var(param, true) && param.type.is_ptr && !param.type.has_own && helpers::need_struct_conversion(regular))
+ {
+ return as_generator(
+ string << " = " << type << "_StructConversion.ToExternal(" << in_variable_name(param.param_name) << ");\n"
+ ).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type), context);
+ }
+
+ return true;
+ }
+} const convert_in_ptr_assign {};
+
struct convert_return_variable_generator
{
template <typename OutputIterator, typename Context>
@@ -923,23 +1022,25 @@ struct convert_return_variable_generator
} const convert_return_variable {};
-
+/* Converts the intermediate return variable to the proper API type */
struct convert_return_generator
{
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::type_def const& ret_type, Context const& context) const
{
auto regular = efl::eina::get<attributes::regular_type_def>(&ret_type.original_type);
- if (ret_type.is_ptr && need_pointer_conversion(regular))
+ if (ret_type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(ret_type, attributes::parameter_direction::unknown))
{
return as_generator(
- "return eina.PrimitiveConversion.PointerToManaged<" << type << ">(_ret_var);\n"
+ "var __ret_tmp = eina.PrimitiveConversion.PointerToManaged<" << type << ">(_ret_var);\n"
+ << scope_tab << scope_tab << (ret_type.has_own ? ("Marshal.FreeHGlobal(_ret_var);\n"): "\n")
+ << scope_tab << scope_tab << "return __ret_tmp;\n"
).generate(sink, ret_type, context);
}
- else if (need_struct_conversion(regular))
+ else if (helpers::need_struct_conversion(regular))
{
return as_generator(
- "return " << type << "_StructConvertion.ToExternal(_ret_var);\n"
+ "return " << type << "_StructConversion.ToExternal(_ret_var);\n"
).generate(sink, ret_type, context);
}
else if (ret_type.c_type == "Eina_Binbuf *" || ret_type.c_type == "const Eina_Binbuf *")
@@ -966,6 +1067,7 @@ struct convert_return_generator
|| ret_type.c_type == "Eina_List *" || ret_type.c_type == "const Eina_List *"
|| ret_type.c_type == "Eina_Inlist *" || ret_type.c_type == "const Eina_Inlist *"
|| ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *"
+ || ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *"
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
@@ -994,33 +1096,44 @@ struct native_convert_out_assign_generator
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
{
+ EINA_CXX_DOM_LOG_DBG(eolian_mono::domain) << "native_convert_out_assign_generator: " << param.param_name << std::endl;
if (param.direction == attributes::parameter_direction::in)
return true;
auto regular = efl::eina::get<attributes::regular_type_def>(&param.type.original_type);
- if (param.type.is_ptr && need_pointer_conversion(regular))
+ if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(param.type, param.direction))
{
return as_generator(
string << " = eina.PrimitiveConversion.ManagedToPointerAlloc(" << string << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), out_variable_name(param.param_name)), context);
}
- else if (need_struct_conversion(regular))
+ else if (helpers::need_struct_conversion(regular))
{
return as_generator(
- string << " = " << type << "_StructConvertion.ToInternal(" << string << ");\n"
+ string << " = " << type << "_StructConversion.ToInternal(" << string << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type, out_variable_name(param.param_name)), context);
}
else if (param_is_acceptable(param, "Eina_Stringshare *", !WANT_OWN, WANT_OUT))
{
+ if (klass == nullptr)
+ {
+ EINA_CXX_DOM_LOG_ERR(eolian_mono::domain) << "Null class found when trying to assign out stringshare from native wrapper." << std::endl;
+ return false;
+ }
return as_generator(
- string << "= efl.eo.Globals.cached_stringshare_to_intptr(((" << string << "Inherit)wrapper).cached_stringshares, " << string << ");\n"
- ).generate(sink, std::make_tuple(escape_keyword(param.param_name), klass->cxx_name, out_variable_name(param.param_name)), context);
+ string << "= efl.eo.Globals.cached_stringshare_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_stringshares, " << string << ");\n"
+ ).generate(sink, std::make_tuple(escape_keyword(param.param_name), out_variable_name(param.param_name)), context);
}
else if (param_is_acceptable(param, "const char *", !WANT_OWN, WANT_OUT))
{
+ if (klass == nullptr)
+ {
+ EINA_CXX_DOM_LOG_ERR(eolian_mono::domain) << "Null class found when trying to assign out string from native wrapper." << std::endl;
+ return false;
+ }
return as_generator(
- string << "= efl.eo.Globals.cached_string_to_intptr(((" << string << "Inherit)wrapper).cached_strings, " << string << ");\n"
- ).generate(sink, std::make_tuple(escape_keyword(param.param_name), klass->cxx_name, out_variable_name(param.param_name)), context);
+ string << "= efl.eo.Globals.cached_string_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_strings, " << string << ");\n"
+ ).generate(sink, std::make_tuple(escape_keyword(param.param_name), out_variable_name(param.param_name)), context);
}
else if (param_is_acceptable(param, "Eina_Binbuf *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Binbuf *", !WANT_OWN, WANT_OUT)
@@ -1085,6 +1198,10 @@ struct native_convert_out_assign_generator
|| param_is_acceptable(param, "Eina_Iterator *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Iterator *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Iterator *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
+ || param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
@@ -1131,25 +1248,30 @@ struct native_convert_return_generator
bool generate(OutputIterator sink, attributes::type_def const& ret_type, Context const& context) const
{
auto regular = efl::eina::get<attributes::regular_type_def>(&ret_type.original_type);
- if (ret_type.is_ptr && need_pointer_conversion(regular))
+ if (ret_type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(ret_type, attributes::parameter_direction::unknown) )
{
return as_generator(
"return eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);\n"
).generate(sink, attributes::unused, context);
}
- else if (need_struct_conversion(regular))
+ else if (helpers::need_struct_conversion(regular))
{
return as_generator(
- "return " << type << "_StructConvertion.ToInternal(_ret_var);\n"
+ "return " << type << "_StructConversion.ToInternal(_ret_var);\n"
).generate(sink, ret_type, context);
}
else if (ret_type.c_type == "const char *")
{
if(!ret_type.has_own)
{
+ if (klass == nullptr)
+ {
+ EINA_CXX_DOM_LOG_ERR(eolian_mono::domain) << "Null class found when trying to return string from native wrapper." << std::endl;
+ return false;
+ }
return as_generator(
- "return efl.eo.Globals.cached_string_to_intptr(((" << string << "Inherit)wrapper).cached_strings, _ret_var);\n"
- ).generate(sink, klass->cxx_name, context);
+ "return efl.eo.Globals.cached_string_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_strings, _ret_var);\n"
+ ).generate(sink, attributes::unused, context);
}
else
{
@@ -1160,9 +1282,14 @@ struct native_convert_return_generator
else if (ret_type.c_type == "Eina_Stringshare *") { // Correct check for string?
if (!ret_type.has_own)
{
+ if (klass == nullptr)
+ {
+ EINA_CXX_DOM_LOG_ERR(eolian_mono::domain) << "Null class found when trying to return stringshare from native wrapper." << std::endl;
+ return false;
+ }
return as_generator(
- "return efl.eo.Globals.cached_stringshare_to_intptr(((" << string << "Inherit)wrapper).cached_stringshares, _ret_var);\n"
- ).generate(sink, klass->cxx_name, context);
+ "return efl.eo.Globals.cached_stringshare_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_stringshares, _ret_var);\n"
+ ).generate(sink, attributes::unused, context);
}
else
{
@@ -1202,6 +1329,7 @@ struct native_convert_return_generator
|| ret_type.c_type == "Eina_List *" || ret_type.c_type == "const Eina_List *"
|| ret_type.c_type == "Eina_Inlist *" || ret_type.c_type == "const Eina_Inlist *"
|| ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *"
+ || ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *"
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
@@ -1277,7 +1405,7 @@ struct native_convert_function_pointer_generator
// Getting the type through C api
std::string type_name = param.type.original_type.visit(type_name_visitor{});
- const Eolian_Typedecl *tpd = ::eolian_typedecl_alias_get_by_name(param.unit, type_name.c_str());
+ const Eolian_Typedecl *tpd = ::eolian_unit_alias_by_name_get(param.unit, type_name.c_str());
if (!tpd)
{
EINA_LOG_ERR("Failed to get typedecl for c type [%s]", param.type.c_type.c_str());
@@ -1292,7 +1420,7 @@ struct native_convert_function_pointer_generator
EINA_LOG_ERR("Failed to get function pointer info for c type [%s]", param.type.c_type.c_str());
return false;
}
- attributes::function_def f(fd, EOLIAN_FUNCTION_POINTER, param.unit);
+ attributes::function_def f(fd, EOLIAN_FUNCTION_POINTER, tpd, param.unit);
std::string param_name = escape_keyword(param.param_name);
// Allocate GCHandle in "param_name"_handle for param;
View Lorry Controller Status