Use G_ADD_PRIVATE et al. when available.

As of GLib 2.58, using g_type_class_add_private has been deprecated;
it seems that type implementations are expected to use the G_ADD_PRIVATE
or G_ADD_PRIVATE_DYNAMIC macros.

Now that we use G_DEFINE_TYPE_xxx, it is reasonably straightforward
to do this.  Fall back to the old method for older GLib where these
macros are not available.

diff --git a/src/main.c b/src/main.c
index 783e46e870e349a89e9c587ad4692433dcd43471..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,6 +1268,7 @@ add_get_type(void)
        Class *c = (Class *)class;
 
        define_add_interfaces(c);
+       define_add_privates(c);
 
        out_printf(out, "#ifdef G_DEFINE_TYPE_EXTENDED\n\n"
                        "G_DEFINE_TYPE_EXTENDED(%s, %s, %s,\n"
@@ -1258,6 +1276,9 @@ add_get_type(void)
                        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");
 
@@ -1296,6 +1317,7 @@ 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
@@ -1312,6 +1334,9 @@ add_dynamic_get_type(void)
                        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);
@@ -2544,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)
 {
@@ -2572,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;
@@ -2643,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;