Eolian: generation of Eo2.devs/jackdanielz/eolian_for_eo2

The generation of Eo2 can be enabled by defining EO2 flag in
common_funcs.h.

It is still in progress.

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 <Eina.h>
 
+//#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
@@ -34,6 +34,12 @@ static const Eo_Op_Description _@#class_op_desc[] = {@#list_op\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\
      NULL\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 " : "");