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; }