Use G_ADD_PRIVATE et al. when available.

[gob-dx.git] / src / main.c

diff --git a/src/main.c b/src/main.c
index 61125d8727b83100307f729ff384f630c9e8cdcf..3bdc4f4356f7d1a5782cc36ba95297938302341e 100644 (file)
--- a/src/main.c
+++ b/src/main.c
@@ -1228,6 +1228,23 @@ define_dynamic_add_interfaces(Class *c)
        out_printf(out, "}\n\n");
 }
 
+static void define_add_privates(Class *c)
+{
+       const char *addprivate = c->dynamic
+               ? "G_ADD_PRIVATE_DYNAMIC"
+               : "G_ADD_PRIVATE";
+
+       if (!privates)
+               return;
+
+       out_printf(out, "#ifdef %s\n"
+                       "#define ___add_privates() %s(%s)\n"
+                       "#else\n"
+                       "#define ___add_privates()\n"
+                       "#endif\n\n",
+                       addprivate, addprivate, typebase);
+}
+
 static void add_type_info(void)
 {
        out_printf(out, "\tstatic const GTypeInfo info = {\n"
@@ -1251,8 +1268,24 @@ add_get_type(void)
        Class *c = (Class *)class;
 
        define_add_interfaces(c);
+       define_add_privates(c);
 
-       out_printf(out, "GType %s_get_type(void)\n"
+       out_printf(out, "#ifdef G_DEFINE_TYPE_EXTENDED\n\n"
+                       "G_DEFINE_TYPE_EXTENDED(%s, %s, %s,\n"
+                       "\t(GTypeFlags)%s,\n",
+                       typebase, funcbase, pmacrotype,
+                       c->abstract ? "G_TYPE_FLAG_ABSTRACT" : "0");
+
+       if (privates)
+               out_printf(out, "\t___add_privates();\n");
+
+       if (c->interfaces)
+               out_printf(out, "\t___add_interfaces(g_define_type_id);\n");
+
+       /* Fallback for GLib < 2.4 */
+       out_printf(out, ");\n\n"
+                       "#else\n\n"
+                       "GType %s_get_type(void)\n"
                        "{\n"
                        "\tstatic GType type = 0;\n",
                        funcbase);
@@ -1274,7 +1307,8 @@ add_get_type(void)
 
        out_printf(out, "\t}\n\n"
                        "\treturn type;\n"
-                       "}\n\n");
+                       "}\n\n"
+                       "#endif\n\n");
 }
 
 static void
@@ -1283,8 +1317,42 @@ add_dynamic_get_type(void)
        Class *c = (Class *)class;
 
        define_dynamic_add_interfaces(c);
+       define_add_privates(c);
+
+       /*
+        * G_DEFINE_DYNAMIC_TYPE_EXTENDED is usable if available, except for
+        * some reason it defines an xxx_register_type function with internal
+        * linkage.  This is kind of weird so we have to work around that.
+        */
+       out_printf(out, "#ifdef G_DEFINE_DYNAMIC_TYPE_EXTENDED\n\n"
+                       "static void %s_class_finalize(%sClass *c) { }\n\n"
+                       "#define %s_register_type ___register_type\n",
+                       funcbase, typebase, funcbase);
+
+       out_printf(out, "G_DEFINE_DYNAMIC_TYPE_EXTENDED(%s, %s, %s,\n"
+                       "\t(GTypeFlags)%s,\n",
+                       typebase, funcbase, pmacrotype,
+                       c->abstract ? "G_TYPE_FLAG_ABSTRACT" : "0");
+
+       if (privates)
+               out_printf(out, "\t___add_privates();\n");
+
+       if (c->interfaces) {
+               out_printf(out, "\t___add_interfaces"
+                                   "(type_module, %s_type_id);\n", funcbase);
+       }
+
+       out_printf(out, ");\n"
+                       "#undef %s_register_type\n\n"
+                       "void %s_register_type(GTypeModule *type_module)\n"
+                       "{\n"
+                       "\t___register_type(type_module);\n"
+                       "}\n\n",
+                       funcbase, funcbase);
 
-       out_printf(out, "static GType %s_type_id;\n\n"
+       /* Fallback for GLib < 2.14 */
+       out_printf(out, "#else\n\n"
+                       "static GType %s_type_id;\n\n"
                        "GType %s_get_type(void)\n"
                        "{\n"
                        "\treturn %s_type_id;\n"
@@ -1313,7 +1381,8 @@ add_dynamic_get_type(void)
                                funcbase);
        }
 
-       out_printf(out, "}\n\n");
+       out_printf(out, "}\n\n"
+                       "#endif\n\n");
 }
 
 static void
@@ -2500,6 +2569,51 @@ make_bonobo_object_epv (Class *c, const char *classname)
                out_addline_outfile(out);
 }
 
+static void add_class_private(Class *c, Method *m)
+{
+       const char *dynamic = c->dynamic ? "_DYNAMIC" : "";
+
+       if (!privates)
+               return;
+
+       out_printf(out, "\n#if !defined(G_DEFINE%s_TYPE_EXTENDED)"
+                           " || !defined(G_ADD_PRIVATE%s)\n"
+                       "\tg_type_class_add_private(%s, sizeof(%sPrivate));\n"
+                       "#endif\n",
+                       dynamic, dynamic,
+                       ((FuncArg *)m->args->data)->name, typebase);
+}
+
+static void get_instance_private(Class *c, Method *m)
+{
+       const char *self = ((FuncArg *)m->args->data)->name;
+       const char *dynamic = c->dynamic ? "_DYNAMIC" : "";
+
+       if (!privates) {
+               if (always_private_struct) {
+                       out_printf(out, "\t%s->_priv = NULL;\n", self);
+               }
+
+               return;
+       }
+
+       out_printf(out, "\t%s->_priv = (%sPrivate *)\n"
+                       "#if defined(G_DEFINE%s_TYPE_EXTENDED)"
+                           " && defined(G_ADD_PRIVATE%s)\n"
+                       "\t\t%s_get_instance_private(%s);\n"
+                       "#else\n"
+                       "\t\tG_TYPE_INSTANCE_GET_PRIVATE\n"
+                       "\t\t\t( %s\n"
+                       "\t\t\t, %s\n"
+                       "\t\t\t, %sPrivate\n"
+                       "\t\t\t);\n"
+                       "#endif\n",
+                       self, typebase,
+                       dynamic, dynamic,
+                       funcbase, self,
+                       self, macrotype, typebase);
+}
+
 static void
 add_inits(Class *c)
 {
@@ -2528,17 +2642,9 @@ add_inits(Class *c)
                        out_printf(out,
                                   "#define __GOB_FUNCTION__ \"%s::init\"\n",
                                   c->otype);
-                       if (privates > 0) {
-                               out_printf(out, "\t%s->_priv = "
-                                               "G_TYPE_INSTANCE_GET_PRIVATE(%s,%s,%sPrivate);\n",
-                                               ((FuncArg *)m->args->data)->name,
-                                               ((FuncArg *)m->args->data)->name,
-                                               macrotype,
-                                               typebase);
-                       } else if(always_private_struct) {
-                               out_printf(out, "\t%s->_priv = NULL;\n",
-                                          ((FuncArg *)m->args->data)->name);
-                       }
+
+                       get_instance_private(c, m);
+
                        if(initializers > 0) {
                                GList *li;
                                for(li = ((Class *)class)->nodes;
@@ -2599,11 +2705,7 @@ add_inits(Class *c)
                                               ((FuncArg *)m->args->data)->name,
                                               did_base_obj);
 
-                       if (privates > 0)
-                               out_printf (out,
-                                           "\n\tg_type_class_add_private(%s,sizeof(%sPrivate));\n",
-                                           ((FuncArg *)m->args->data)->name,
-                                           typebase);
+                       add_class_private(c, m);
 
                        if (initializers > 0) {
                                GList *li;