bool generate(OutputIterator sink, attributes::part_def const& part, Context const& ctx) const
{
if(!as_generator(scope_tab << "::efl::eolian::return_traits<::" << *(string << "::"))
.generate(sink, part.klass.namespaces, add_lower_case_context(ctx)))
return false;
if(!as_generator(string << ">::type " << string << "() const")
.generate(sink, std::make_tuple(part.klass.eolian_name, part.name), ctx))
return false;
return true;
}
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;
}
bool generate(OutputIterator sink, Attribute const& attribute, Context const& context) const
{
bool b;
for(auto&& c : attribute)
{
b = as_generator(generator).generate(sink, c, context);
if(!b)
return false;
}
return true;
}
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{});
if (param.type.original_type.visit(this->is_function_ptr))
{
return as_generator("fw_" << param.param_name << "->data_to_c(), fw_" << param.param_name << "->func_to_c(), fw_"
<< param.param_name << "->free_to_c()")
.generate(sink, param, ctx);
}
else
return as_generator
(
attribute_reorder<-1, -1, 2>
(
" ::efl::eolian::convert_to_c<" << c_type
<< ", " << parameter_type
<< (qualifier & qualifier_info::is_own
? ", true" : "")
<< ">(" << string << ")"
)
).generate(sink, param, ctx);
}
bool generate(OutputIterator sink, std::string const& cls, Context const& ctx) const
{
return as_generator("#include \"" << string << ".impl.hh\"\n")
.generate(sink, cls, add_lower_case_context(ctx));
}
bool generate(OutputIterator sink, attributes::klass_def const& cls, Context const& ctx) const
{
return as_generator("#include \"" << string << ".impl.hh\"\n")
.generate(sink, std::string(eolian_object_file_get((const Eolian_Object *)get_klass(get_klass_name(cls, unit_from_context(ctx))))), add_lower_case_context(ctx));
}
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.type.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;
}
