From da7de06534b4b5b6e2f894476c4365c4e9fb23d1 Mon Sep 17 00:00:00 2001 From: Daniel Zaoui Date: Sun, 30 Mar 2014 16:22:14 +0300 Subject: Eolian: generation of Eo2. The generation of Eo2 can be enabled by defining EO2 flag in common_funcs.h. It is still in progress. --- src/bin/eolian/common_funcs.h | 2 + src/bin/eolian/eo1_generator.c | 251 ++++++++++++++++++++++++++++++++------ src/bin/eolian/legacy_generator.c | 13 +- 3 files changed, 227 insertions(+), 39 deletions(-) diff --git a/src/bin/eolian/common_funcs.h b/src/bin/eolian/common_funcs.h index bbe88c3c37..485b0acb6b 100644 --- a/src/bin/eolian/common_funcs.h +++ b/src/bin/eolian/common_funcs.h @@ -3,6 +3,8 @@ #include +//#define EO2 + extern int _eolian_gen_log_dom; #ifdef ERR diff --git a/src/bin/eolian/eo1_generator.c b/src/bin/eolian/eo1_generator.c index fa3804e8ac..e1f0db9f55 100644 --- a/src/bin/eolian/eo1_generator.c +++ b/src/bin/eolian/eo1_generator.c @@ -33,6 +33,12 @@ static const Eo_Op_Description _@#class_op_desc[] = {@#list_op\n\ EO_OP_DESCRIPTION_SENTINEL\n\ };\n\n"; +static const char +tmpl_eo2_ops_desc[] = "\ +static Eo2_Op_Description _@#class_op_desc[] = {@#list_op\n\ + EO2_OP_SENTINEL\n\ +};\n\n"; + static const char tmpl_events_desc[] = "\ static const Eo_Event_Description *_@#class_event_desc[] = {@#list_evdesc\n\ @@ -48,13 +54,13 @@ tmpl_eo_src[] = "\ @#ops_desc\ @#events_desc\ static const Eo_Class_Description _@#class_class_desc = {\n\ - EO_VERSION,\n\ + @#EO_VERSION,\n\ \"@#Class\",\n\ @#type_class,\n\ @#eo_class_desc_ops,\n\ @#Events_Desc,\n\ @#SizeOfData,\n\ - _gen_@#class_class_constructor,\n\ + @#ctor_name,\n\ @#dtor_name\n\ };\n\ \n\ @@ -62,13 +68,19 @@ EO_DEFINE_CLASS(@#eoprefix_class_get, &_@#class_class_desc, @#list_inheritNULL); "; static const char -tmpl_eo_op_desc[] = "\n EO_OP_DESCRIPTION(@#EOPREFIX_SUB_ID_@#FUNC, \"@#desc\"),"; +tmpl_eo1_op_desc[] = "\n EO_OP_DESCRIPTION(@#EOPREFIX_SUB_ID_@#FUNC, \"@#desc\"),"; + +static const char +tmpl_eo1_func_desc[] = "\n EO_OP_FUNC(@#EOPREFIX_ID(@#EOPREFIX_SUB_ID_@#FUNC), _eo_obj_@#class_@#func),"; + +static const char +tmpl_eo2_func_desc[] = "\n EO2_OP_FUNC_OVERRIDE(@#eoprefix_@#func, _@#class_@#func),"; static const char -tmpl_eo_func_desc[] = "\n EO_OP_FUNC(@#EOPREFIX_ID(@#EOPREFIX_SUB_ID_@#FUNC), _eo_obj_@#class_@#func),"; +tmpl_eo1base_func_desc[] = "\n EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_@#FUNC), _eo_obj_@#class_@#func),"; static const char -tmpl_eobase_func_desc[] = "\n EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_@#FUNC), _eo_obj_@#class_@#func),"; +tmpl_eo2_op_desc[] = "\n EO2_OP_FUNC(@#eoprefix_@#func, _@#class_@#func, \"@#desc\"),"; static const char tmpl_eo_obj_header[] = "\ @@ -101,30 +113,40 @@ static const char tmpl_eo_subid_apnd[] = " @#EOPREFIX_SUB_ID_@#FUNC,\n"; static const char -tmpl_eo_funcdef[] = "\n\ +tmpl_eo_funcdef_doxygen[] = "\n\ /**\n\ * @def @#eoprefix_@#func\n\ *\n\ @#desc\n\ *\n\ @#list_desc_param\ +@#ret_desc\ *\n\ - */\n\ -#define @#eoprefix_@#func(@#list_param) @#EOPREFIX_ID(@#EOPREFIX_SUB_ID_@#FUNC)@#list_typecheck\n\ -"; + */\n"; + +static const char +tmpl_eo1_funcdef[] = "#define @#eoprefix_@#func(@#list_param) @#EOPREFIX_ID(@#EOPREFIX_SUB_ID_@#FUNC)@#list_typecheck\n"; + +static const char +tmpl_eo2_funcdef[] = "EAPI @#rettype @#eoprefix_@#func(@#full_params);\n"; static const char tmpl_eo_pardesc[] =" * @param[%s] %s %s\n"; +#if 0 static const char -tmpl_eobind_body[] ="\ +tmpl_eo_retdesc[] =" * @return %s\n"; +#endif + +static const char +tmpl_eo1bind_body[] ="\ \n\ @#ret_type _@#class_@#func(Eo *obj, @#Datatype_Data *pd@#full_params);\n\n\ static void\n\ _eo_obj_@#class_@#func(Eo *obj, void *_pd, va_list *list@#list_unused)\n\ {\n\ @#list_vars\ - @#ret_param_@#class_@#func(obj, _pd@#list_params);\n\ + @#ret_param_@#class_@#func(obj, _pd, @#list_params);\n\ @#return_ret\ }\n\ "; @@ -148,7 +170,12 @@ eo1_fundef_generate(const char *classname, Eolian_Function func, Eolian_Function const char *funcdesc = eolian_function_description_get(func, descname); Eina_Strbuf *str_func = eina_strbuf_new(); - _template_fill(str_func, tmpl_eo_funcdef, classname, funcname, EINA_TRUE); + _template_fill(str_func, tmpl_eo_funcdef_doxygen, classname, funcname, EINA_TRUE); +#ifndef EO2 + _template_fill(str_func, tmpl_eo1_funcdef, classname, funcname, EINA_FALSE); +#else + _template_fill(str_func, tmpl_eo2_funcdef, classname, funcname, EINA_FALSE); +#endif eina_strbuf_replace_all(str_func, "@#EOPREFIX", current_eo_prefix_upper); eina_strbuf_replace_all(str_func, "@#eoprefix", current_eo_prefix_lower); @@ -171,6 +198,7 @@ eo1_fundef_generate(const char *classname, Eolian_Function func, Eolian_Function Eina_Strbuf *str_par = eina_strbuf_new(); Eina_Strbuf *str_pardesc = eina_strbuf_new(); + Eina_Strbuf *str_retdesc = eina_strbuf_new(); Eina_Strbuf *str_typecheck = eina_strbuf_new(); EINA_LIST_FOREACH(eolian_property_keys_list_get(func), l, data) @@ -183,9 +211,13 @@ eo1_fundef_generate(const char *classname, Eolian_Function func, Eolian_Function eina_strbuf_append_printf(str_pardesc, tmpl_eo_pardesc, "in", pname, pdesc?pdesc:"No description supplied."); if (eina_strbuf_length_get(str_par)) eina_strbuf_append(str_par, ", "); +#ifdef EO2 + eina_strbuf_append_printf(str_par, "%s %s", ptype, pname); +#else eina_strbuf_append(str_par, pname); eina_strbuf_append_printf(str_typecheck, ", EO_TYPECHECK(%s, %s)", ptype, pname); +#endif } EINA_LIST_FOREACH(eolian_parameters_list_get(func), l, data) @@ -210,30 +242,48 @@ eo1_fundef_generate(const char *classname, Eolian_Function func, Eolian_Function eina_strbuf_append_printf(str_pardesc, tmpl_eo_pardesc, dir_str, pname, pdesc?pdesc:"No description supplied."); if (eina_strbuf_length_get(str_par)) eina_strbuf_append(str_par, ", "); +#ifdef EO2 + eina_strbuf_append_printf(str_par, "%s%s%s%s%s", + is_const?"const ":"", + ptype, had_star?"":" ", add_star?"*":"", pname); +#else eina_strbuf_append(str_par, pname); eina_strbuf_append_printf(str_typecheck, ", EO_TYPECHECK(%s%s%s%s, %s)", is_const?"const ":"", ptype, had_star?"":" ", add_star?"*":"", pname); +#endif + } const char* rettype = eolian_function_return_type_get(func, ftype); if (rettype && strcmp(rettype, "void")) { +#ifndef EO2 const char *ret_desc = eolian_function_return_comment_get(func, ftype); eina_strbuf_append_printf(str_pardesc, tmpl_eo_pardesc, "out", "ret", ret_desc); if (eina_strbuf_length_get(str_par)) eina_strbuf_append(str_par, ", "); eina_strbuf_append(str_par, "ret"); Eina_Bool had_star = !!strchr(rettype, '*'); eina_strbuf_append_printf(str_typecheck, ", EO_TYPECHECK(%s%s*, ret)", rettype, had_star?"":" "); +#else +/* eina_strbuf_append_printf(str_retdesc, tmpl_eo_retdesc, ret_desc); */ +#endif } +#ifdef EO2 + eina_strbuf_replace_all(str_func, "@#rettype", rettype?rettype:"void"); +#endif eina_strbuf_replace_all(str_func, "@#list_param", eina_strbuf_string_get(str_par)); + if (!eina_strbuf_length_get(str_par)) eina_strbuf_append(str_par, "void"); + eina_strbuf_replace_all(str_func, "@#full_params", eina_strbuf_string_get(str_par)); eina_strbuf_replace_all(str_func, "@#list_desc_param", eina_strbuf_string_get(str_pardesc)); + eina_strbuf_replace_all(str_func, "@#ret_desc", eina_strbuf_string_get(str_retdesc)); eina_strbuf_replace_all(str_func, "@#list_typecheck", eina_strbuf_string_get(str_typecheck)); free(tmpstr); eina_strbuf_free(str_par); + eina_strbuf_free(str_retdesc); eina_strbuf_free(str_pardesc); eina_strbuf_free(str_typecheck); @@ -250,7 +300,7 @@ eo1_header_generate(const char *classname, Eina_Strbuf *buf) const Eina_List *l; void *data; char *tmpstr = malloc(0x1FF); - Eina_Bool no_ids = EINA_TRUE; + Eina_Strbuf * str_hdr = eina_strbuf_new(); if (!eolian_class_exists(classname)) { @@ -259,19 +309,19 @@ eo1_header_generate(const char *classname, Eina_Strbuf *buf) return EINA_FALSE; } +#ifndef EO2 if (eolian_class_functions_list_get(classname, CONSTRUCTOR) || eolian_class_functions_list_get(classname, DESTRUCTOR) || eolian_class_functions_list_get(classname, PROPERTY_FUNC) || eolian_class_functions_list_get(classname, METHOD_FUNC)) { - no_ids = EINA_FALSE; + _template_fill(str_hdr, tmpl_eo_obj_header, classname, "", EINA_TRUE); } - - Eina_Strbuf * str_hdr = eina_strbuf_new(); - if (no_ids) - _template_fill(str_hdr, tmpl_eo_obj_header_no_ids, classname, "", EINA_TRUE); else - _template_fill(str_hdr, tmpl_eo_obj_header, classname, "", EINA_TRUE); +#endif + { + _template_fill(str_hdr, tmpl_eo_obj_header_no_ids, classname, "", EINA_TRUE); + } eina_strbuf_replace_all(str_hdr, "@#EOPREFIX", current_eo_prefix_upper); eina_strbuf_replace_all(str_hdr, "@#eoprefix", current_eo_prefix_lower); @@ -347,6 +397,7 @@ eo1_header_generate(const char *classname, Eina_Strbuf *buf) return EINA_TRUE; } +#ifndef EO2 static const char* _varg_upgr(const char *stype) { @@ -358,6 +409,7 @@ _varg_upgr(const char *stype) return stype; } +#endif static Eina_Bool eo1_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Function_Type ftype, Eina_Strbuf *buf, const char *impl_name) @@ -403,7 +455,11 @@ eo1_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Fun sprintf (tmpstr, "%s%s", eolian_function_name_get(funcid), suffix); char tmpstr2[0xFF]; sprintf (tmpstr2, "%s_%s", classname, impl_name); - _template_fill(fbody, tmpl_eobind_body, impl_name?tmpstr2:classname, tmpstr, EINA_FALSE); +#ifndef EO2 + _template_fill(fbody, tmpl_eo1bind_body, impl_name?tmpstr2:classname, tmpstr, EINA_FALSE); +#else + _class_func_names_fill(impl_name?tmpstr2:classname, tmpstr); +#endif const Eina_List *l; void *data; @@ -414,12 +470,14 @@ eo1_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Fun const char *ptype; eolian_parameter_information_get((Eolian_Function_Parameter)data, NULL, &ptype, &pname, NULL); Eina_Bool is_const = eolian_parameter_const_attribute_get(data, ftype == GET); +#ifndef EO2 eina_strbuf_append_printf(va_args, " %s%s %s = va_arg(*list, %s%s);\n", - ftype == GET && is_const?"const ":"", ptype, pname, - ftype == GET && is_const?"const ":"", _varg_upgr(ptype)); + is_const?"const ":"", ptype, pname, + is_const?"const ":"", _varg_upgr(ptype)); +#endif eina_strbuf_append_printf(params, ", %s", pname); eina_strbuf_append_printf(full_params, ", %s%s %s", - ftype == GET && eolian_parameter_const_attribute_get(data, ftype == GET)?"const ":"", + is_const?"const ":"", ptype, pname); } if (!var_as_ret) @@ -433,16 +491,20 @@ eo1_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Fun Eina_Bool is_const = eolian_parameter_const_attribute_get(data, ftype == GET); Eina_Bool had_star = !!strchr(ptype, '*'); if (ftype == UNRESOLVED || ftype == METHOD_FUNC) add_star = (pdir == EOLIAN_OUT_PARAM); +#ifndef EO2 eina_strbuf_append_printf(va_args, " %s%s%s%s%s = va_arg(*list, %s%s%s%s);\n", is_const?"const ":"", ptype, had_star?"":" ", add_star?"*":"", pname, is_const?"const ":"", add_star ? ptype : _varg_upgr(ptype), !had_star && add_star?" ":"", add_star?"*":""); - eina_strbuf_append_printf(params, ", %s", pname); +#endif + if (eina_strbuf_length_get(params)) eina_strbuf_append(params, ", "); + eina_strbuf_append_printf(params, "%s", pname); eina_strbuf_append_printf(full_params, ", %s%s%s%s%s", is_const?"const ":"", ptype, had_star?"":" ", add_star?"*":"", pname); } } +#ifndef EO2 if (rettype && strcmp(rettype, "void")) { Eina_Bool had_star = !!strchr(rettype, '*'); @@ -476,9 +538,51 @@ eo1_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Fun { eina_strbuf_replace_all(fbody, "@#list_unused", ""); } + if (!eina_strbuf_length_get(params)) eina_strbuf_replace_all(fbody, ", @#list_params", ""); eina_strbuf_replace_all(fbody, "@#list_vars", eina_strbuf_string_get(va_args)); - eina_strbuf_replace_all(fbody, "@#full_params", eina_strbuf_string_get(full_params)); eina_strbuf_replace_all(fbody, "@#list_params", eina_strbuf_string_get(params)); +#else + eina_strbuf_append_printf(fbody, "\n"); + eina_strbuf_append_printf(fbody, "%s%s _%s_%s%s(Eo *obj, @#Datatype_Data *pd@#full_params);\n\n", + ret_const?"const ":"", rettype?rettype:"void", + lowclass, + eolian_function_name_get(funcid), suffix?suffix:""); + + Eina_Strbuf *ret_param = eina_strbuf_new(); + eina_strbuf_replace_all(fbody, "@#return_ret", tmpstr); + eina_strbuf_free(ret_param); + if (!impl_name) + { + Eina_Strbuf *eo_func_decl = eina_strbuf_new(); + Eina_Bool has_params = + eina_list_count(eolian_parameters_list_get(funcid)) != 0 || + eina_list_count(eolian_property_keys_list_get(funcid)); + Eina_Bool ret_is_void = (!rettype || !strcmp(rettype, "void")); + eina_strbuf_append_printf(eo_func_decl, + "EAPI EO2_%sFUNC_BODY%s(%s_%s%s", + ret_is_void?"VOID_":"", has_params?"V":"", + current_eo_prefix_lower, eolian_function_name_get(funcid), + suffix?suffix:""); + if (!ret_is_void) + { + const char *dflt_ret_val = + eolian_function_return_dflt_value_get(funcid, ftype); + eina_strbuf_append_printf(eo_func_decl, ", %s, %s", + rettype, dflt_ret_val?dflt_ret_val:"0"); + + } + if (has_params) + { + eina_strbuf_append_printf(eo_func_decl, ", EO2_FUNC_CALL(%s)%s", + eina_strbuf_string_get(params), + eina_strbuf_string_get(full_params)); + } + eina_strbuf_append_printf(eo_func_decl, ");"); + eina_strbuf_append_printf(fbody, "%s\n", eina_strbuf_string_get(eo_func_decl)); + eina_strbuf_free(eo_func_decl); + } +#endif + eina_strbuf_replace_all(fbody, "@#full_params", eina_strbuf_string_get(full_params)); const char *data_type = eolian_class_data_type_get(classname); if (data_type && !strcmp(data_type, "null")) eina_strbuf_replace_all(fbody, "@#Datatype_Data", "void"); @@ -518,12 +622,29 @@ eo1_eo_func_desc_generate(const char *class_name, const char *impl_name, const c } static Eina_Bool -eo1_eo_op_desc_generate(const char *classname, const char *funcname, +eo_op_desc_generate(const char *classname, Eolian_Function fid, Eolian_Function_Type ftype, const char *desc, Eina_Strbuf *buf) { - _template_fill(buf, tmpl_eo_op_desc, classname, funcname, EINA_TRUE); - eina_strbuf_replace_all(buf, "@#EOPREFIX", current_eo_prefix_upper); - eina_strbuf_replace_all(buf, "@#desc", desc); + const char *funcname = eolian_function_name_get(fid); + const char *suffix = ""; + + eina_strbuf_reset(buf); + _class_func_names_fill(classname, funcname); +#ifndef EO2 + if (ftype == GET) suffix = "_GET"; + if (ftype == SET) suffix = "_SET"; + eina_strbuf_append_printf(buf, "\n EO_OP_DESCRIPTION(%s_SUB_ID_%s%s, \"%s\"),", + current_eo_prefix_upper, capfunc, suffix, desc); +#else + if (ftype == GET) suffix = "_get"; + if (ftype == SET) suffix = "_set"; + Eina_Bool is_virtual_pure = eolian_function_is_virtual_pure(fid, ftype); + eina_strbuf_append_printf(buf, "\n EO2_OP_FUNC(%s_%s%s, ", current_eo_prefix_lower, funcname, suffix); + if (!is_virtual_pure) + eina_strbuf_append_printf(buf, "_%s_%s%s, \"%s\"),", current_eo_prefix_lower, funcname, suffix, desc); + else + eina_strbuf_append_printf(buf, "NULL, \"%s\"),", desc); +#endif return EINA_TRUE; } @@ -536,6 +657,7 @@ eo1_source_beginning_generate(const char *classname, Eina_Strbuf *buf) Eina_Strbuf *tmpbuf = eina_strbuf_new(); Eina_Strbuf *str_ev = eina_strbuf_new(); +#ifndef EO2 if (eolian_class_functions_list_get(classname, CONSTRUCTOR) || eolian_class_functions_list_get(classname, DESTRUCTOR) || eolian_class_functions_list_get(classname, PROPERTY_FUNC) || @@ -545,6 +667,7 @@ eo1_source_beginning_generate(const char *classname, Eina_Strbuf *buf) eina_strbuf_append_printf(buf, "EAPI Eo_Op @#EOPREFIX_BASE_ID = EO_NOOP;\n"); eina_strbuf_replace_all(buf, "@#EOPREFIX", current_eo_prefix_upper); } +#endif Eolian_Event event; EINA_LIST_FOREACH(eolian_class_events_list_get(classname), itr, event) @@ -613,16 +736,40 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) _template_fill(str_end, tmpl_eo_src, classname, NULL, EINA_TRUE); + eina_strbuf_replace_all(str_end, "@#EO_VERSION", +#ifdef EO2 + "EO2_VERSION" +#else + "EO_VERSION" +#endif + ); + + eina_strbuf_replace_all(str_end, "@#type_class", str_classtype); eina_strbuf_replace_all(str_end, "@#EOPREFIX", current_eo_prefix_upper); eina_strbuf_replace_all(str_end, "@#eoprefix", current_eo_prefix_lower); + eina_strbuf_reset(tmpbuf); +#ifndef EO2 _template_fill(tmpbuf, tmpl_eo1_class_ctor, classname, "", EINA_TRUE); +#endif eina_strbuf_replace_all(str_end, "@#ctor_func", eina_strbuf_string_get(tmpbuf)); + + eina_strbuf_reset(tmpbuf); +#ifndef EO2 + _template_fill(tmpbuf, "_gen_@#class_class_constructor", classname, "", EINA_TRUE); + eina_strbuf_replace_all(str_end, "@#ctor_name", eina_strbuf_string_get(tmpbuf)); eina_strbuf_reset(tmpbuf); if (eolian_class_ctor_enable_get(classname)) _template_fill(tmpbuf, " _@#class_class_constructor(klass);\n", classname, "", EINA_TRUE); eina_strbuf_replace_all(str_end, "@#user_ctor_func", eina_strbuf_string_get(tmpbuf)); +#else + if (eolian_class_ctor_enable_get(classname)) + _template_fill(tmpbuf, "_gen_@#class_class_constructor", classname, "", EINA_TRUE); + else + eina_strbuf_append_printf(tmpbuf, "NULL"); + eina_strbuf_replace_all(str_end, "@#ctor_name", eina_strbuf_string_get(tmpbuf)); +#endif if (eolian_class_dtor_enable_get(classname)) { @@ -643,14 +790,14 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) Eolian_Function ctor_fn = eolian_class_default_constructor_get(classname); if (ctor_fn) { - _template_fill(str_func, tmpl_eobase_func_desc, classname, "constructor", EINA_FALSE); + _template_fill(str_func, tmpl_eo1base_func_desc, classname, "constructor", EINA_FALSE); eo1_bind_func_generate(classname, ctor_fn, UNRESOLVED, str_bodyf, NULL); } // default destructor Eolian_Function dtor_fn = eolian_class_default_destructor_get(classname); if (dtor_fn) { - _template_fill(str_func, tmpl_eobase_func_desc, classname, "destructor", EINA_FALSE); + _template_fill(str_func, tmpl_eo1base_func_desc, classname, "destructor", EINA_FALSE); eo1_bind_func_generate(classname, dtor_fn, UNRESOLVED, str_bodyf, NULL); } @@ -666,8 +813,13 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) eina_strbuf_reset(tmpl_impl); _template_fill(str_func, NULL, impl_class, NULL, EINA_FALSE); /* Invoked to set the variables */ - eina_strbuf_append(tmpl_impl, tmpl_eo_func_desc); +#ifndef EO2 + eina_strbuf_append(tmpl_impl, tmpl_eo1_func_desc); +#else + eina_strbuf_append(tmpl_impl, tmpl_eo2_func_desc); +#endif eina_strbuf_replace_all(tmpl_impl, "@#EOPREFIX", current_eo_prefix_upper); + eina_strbuf_replace_all(tmpl_impl, "@#eoprefix", current_eo_prefix_lower); char implname[0xFF]; char *tp = implname; @@ -696,7 +848,11 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) if (in_meth) { +#ifndef EO2 _template_fill(str_func, tmpl_impl_str, impl_class, funcname, EINA_FALSE); +#else + _template_fill(str_op, tmpl_impl_str, impl_class, funcname, EINA_FALSE); +#endif eo1_bind_func_generate(classname, in_meth, UNRESOLVED, str_bodyf, impl_class); } @@ -712,17 +868,26 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) if (prop_write) { sprintf(tmpstr, "%s_set", funcname); +#ifndef EO2 _template_fill(str_func, tmpl_impl_str, impl_class, tmpstr, EINA_FALSE); +#else + _template_fill(str_op, tmpl_impl_str, impl_class, tmpstr, EINA_FALSE); +#endif eo1_bind_func_generate(classname, in_prop, SET, str_bodyf, impl_class); } if (prop_read) { sprintf(tmpstr, "%s_get", funcname); +#ifndef EO2 _template_fill(str_func, tmpl_impl_str, impl_class, tmpstr, EINA_FALSE); +#else + _template_fill(str_op, tmpl_impl_str, impl_class, tmpstr, EINA_FALSE); +#endif eo1_bind_func_generate(classname, in_prop, GET, str_bodyf, impl_class); } } + eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf)); } //Constructors @@ -730,7 +895,7 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) { const char *funcname = eolian_function_name_get(fn); char *desc = _source_desc_get(eolian_function_description_get(fn, "comment")); - eo1_eo_op_desc_generate(classname, funcname, desc, tmpbuf); + eo_op_desc_generate(classname, fn, CONSTRUCTOR, desc, tmpbuf); eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf)); free(desc); @@ -755,7 +920,7 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) char *desc = _source_desc_get(eolian_function_description_get(fn, "comment_set")); sprintf(tmpstr, "%s_set", funcname); - eo1_eo_op_desc_generate(classname, tmpstr, desc, tmpbuf); + eo_op_desc_generate(classname, fn, SET, desc, tmpbuf); eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf)); free(desc); @@ -770,7 +935,7 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) char *desc = _source_desc_get(eolian_function_description_get(fn, "comment_get")); sprintf(tmpstr, "%s_get", funcname); - eo1_eo_op_desc_generate(classname, tmpstr, desc, tmpbuf); + eo_op_desc_generate(classname, fn, GET, desc, tmpbuf); free(desc); eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf)); @@ -788,7 +953,7 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) const char *funcname = eolian_function_name_get(fn); char *desc = _source_desc_get(eolian_function_description_get(fn, "comment")); - eo1_eo_op_desc_generate(classname, funcname, desc, tmpbuf); + eo_op_desc_generate(classname, fn, METHOD_FUNC, desc, tmpbuf); free(desc); eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf)); @@ -846,19 +1011,33 @@ eo1_source_end_generate(const char *classname, Eina_Strbuf *buf) if (eina_strbuf_length_get(str_op)) { Eina_Strbuf *ops_desc = eina_strbuf_new(); +#ifndef EO2 _template_fill(ops_desc, tmpl_eo1_ops_desc, classname, "", EINA_TRUE); +#else + _template_fill(ops_desc, tmpl_eo2_ops_desc, classname, "", EINA_TRUE); +#endif eina_strbuf_replace_all(ops_desc, "@#list_op", eina_strbuf_string_get(str_op)); eina_strbuf_replace_all(str_end, "@#ops_desc", eina_strbuf_string_get(ops_desc)); eina_strbuf_free(ops_desc); +#ifndef EO2 _template_fill(tmpbuf, "EO_CLASS_DESCRIPTION_OPS(&@#EOPREFIX_BASE_ID, _@#class_op_desc, @#EOPREFIX_SUB_ID_LAST)", classname, NULL, EINA_TRUE); eina_strbuf_replace_all(tmpbuf, "@#EOPREFIX", current_eo_prefix_upper); +#else + _template_fill(tmpbuf, + "EO2_CLASS_DESCRIPTION_OPS(_@#class_op_desc)", + classname, NULL, EINA_TRUE); +#endif } else { eina_strbuf_replace_all(str_end, "@#ops_desc", ""); +#ifndef EO2 eina_strbuf_append_printf(tmpbuf, "EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0)"); +#else + eina_strbuf_append_printf(tmpbuf, "EO2_CLASS_DESCRIPTION_OPS(NULL)"); +#endif } eina_strbuf_replace_all(str_end, "@#functions_body", eina_strbuf_string_get(str_bodyf)); diff --git a/src/bin/eolian/legacy_generator.c b/src/bin/eolian/legacy_generator.c index 2a3ca705e9..feb53189f8 100644 --- a/src/bin/eolian/legacy_generator.c +++ b/src/bin/eolian/legacy_generator.c @@ -26,7 +26,7 @@ EAPI @#ret_type\n\ @#eapi_prefix_@#func(@#is_constEo *obj@#full_params)\n\ {\n\ @#ret_init_val\ - eo_do((Eo *) obj, @#eoprefix_@#func(@#eo_params));\n\ + eo_do((Eo *) obj, @#eo2_ret_assign@#eoprefix_@#func(@#eo_params));\n\ return @#ret_val;\n\ }\n\ "; @@ -297,20 +297,27 @@ _eapi_func_generate(const char *classname, Eolian_Function funcid, Eolian_Functi sprintf (tmp_ret_str, "%s%s", ret_const?"const ":"", rettype?rettype:"void"); if (rettype && !ret_is_void) { +#ifndef EO2 if (eina_strbuf_length_get(eoparam)) eina_strbuf_append(eoparam, ", "); - Eina_Bool had_star = !!strchr(rettype, '*'); + eina_strbuf_append_printf(eoparam, "&%s", retname); +#endif const char *dflt_ret_val = eolian_function_return_dflt_value_get(funcid, ftype); + Eina_Bool had_star = !!strchr(rettype, '*'); sprintf (tmpstr, " %s%s%s%s = %s;\n", ret_const?"const ":"", rettype, had_star?"":" ", retname, dflt_ret_val?dflt_ret_val:"0"); - eina_strbuf_append_printf(eoparam, "&%s", retname); } eina_strbuf_replace_all(fbody, "@#full_params", eina_strbuf_string_get(fparam)); eina_strbuf_replace_all(fbody, "@#eo_params", eina_strbuf_string_get(eoparam)); eina_strbuf_replace_all(fbody, "@#ret_type", tmp_ret_str); eina_strbuf_replace_all(fbody, "@#ret_init_val", tmpstr); + tmp_ret_str[0] = '\0'; +#ifdef EO2 + if (rettype && !ret_is_void) sprintf(tmp_ret_str, "%s = ", retname); +#endif + eina_strbuf_replace_all(fbody, "@#eo2_ret_assign", tmp_ret_str); eina_strbuf_replace_all(fbody, "@#ret_val", (rettype && !ret_is_void) ? retname : ""); eina_strbuf_replace_all(fbody, "@#is_const", (ftype == GET || eolian_function_object_is_const(funcid)) ? "const " : ""); -- cgit v1.2.1