X-Git-Url: https://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/7231d76fbf4ae0b501af648e1216b88714aa7353..308dc7bdfb924370cfd205f656eb0e83191d01a9:/src/main.c

diff --git a/src/main.c b/src/main.c
index fe74942..296cf0d 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,7 +1,7 @@
 /* GOB C Preprocessor
  * Copyright (C) 1999,2000 the Free Software Foundation.
  * Copyright (C) 2000 Eazel, Inc.
- * Copyright (C) 2001 George Lebl
+ * Copyright (C) 2001-2004 George Lebl
  *
  * Author: George Lebl
  *
@@ -46,6 +46,7 @@ extern int yydebug;
 extern FILE * yyin;
 extern Node *class;
 extern GList *nodes;
+extern GList *enums;
 
 extern GList *include_files;
 
@@ -81,8 +82,8 @@ static gboolean made_aliases = FALSE;  /* if we made any shorthand aliases
 static gboolean special_array[SPECIAL_LAST] = {0};
 static gboolean any_special = FALSE;
 
-static gboolean need_shutdown = FALSE;
-static Method * shutdown_handler = NULL;
+static gboolean need_dispose = FALSE;
+static Method * dispose_handler = NULL;
 
 static gboolean need_finalize = FALSE;
 static Method * finalize_handler = NULL;
@@ -105,22 +106,30 @@ gboolean no_lines = FALSE;
 gboolean no_self_alias = FALSE;
 gboolean always_private_struct = FALSE;
 
+gboolean use_m4 = FALSE; /* preprocess sources with m4 */
+gboolean use_m4_clean = FALSE; /* preprocess sources with m4, no m4 flags */
+char *m4_commandline = NULL;
+#define M4_INCLUDE_DIR  PKGDATADIR "/m4"
+#define M4_BASE_FILENAME "gobm4.m4"
+#define M4_FLAGS "-P -s -I" M4_INCLUDE_DIR  " -DGOBM4_GOB_VERSION=" VERSION " " M4_BASE_FILENAME
+#define M4_COMMANDLINE "m4"
+
 int method_unique_id = 1;
 
 static void
 make_bases (void)
 {
 	filebase = replace_sep (((Class *)class)->otype, '-');
-	g_strdown (filebase);
+	gob_strdown (filebase);
 
 	funcbase = replace_sep (((Class *)class)->otype, '_');
-	g_strdown (funcbase);
+	gob_strdown (funcbase);
 
 	pfuncbase = replace_sep (((Class *)class)->ptype, '_');
-	g_strdown (pfuncbase);
+	gob_strdown (pfuncbase);
 
 	macrobase = replace_sep (((Class *)class)->otype, '_');
-	g_strup (macrobase);
+	gob_strup (macrobase);
 	
 	macrois = make_pre_macro (((Class *)class)->otype, "IS");
 	pmacrois = make_pre_macro (((Class *)class)->ptype, "IS");
@@ -133,42 +142,6 @@ make_bases (void)
 	ptypebase = remove_sep (((Class *)class)->ptype);
 }
 
-static char *
-get_type (const Type *t, gboolean postfix_to_stars)
-{
-	char *s;
-	int i;
-	int extra;
-	GString *gs;
-
-	s = remove_sep(t->name);
-	gs = g_string_new(s);
-	g_free(s);
-
-	extra = 0;
-	if (postfix_to_stars) {
-		const char *p;
-		/*XXX: this is ugly perhaps we can do this whole postfix thing
-		  in a nicer way, we just count the number of '[' s and from
-		  that we deduce the number of dimensions, so that we can print
-		  that many stars */
-		for (p = t->postfix; p && *p; p++)
-			if(*p == '[') extra++;
-	}
-	g_string_append_c(gs, ' ');
-
-	if (t->pointer != NULL) {
-		g_string_append (gs, t->pointer);
-		for (i=0; i < extra; i++)
-			g_string_append_c (gs, '*');
-		g_string_append_c (gs, ' ');
-	}
-	
-	s = gs->str;
-	g_string_free (gs, FALSE);
-	return s;
-}
-
 static char *
 get_gtk_doc (const char *id)
 {
@@ -337,7 +310,7 @@ make_method_nongnu_aliases(Class *c)
 }
 
 static void
-add_bad_hack_to_avoid_unused_warnings(Class *c)
+add_bad_hack_to_avoid_unused_warnings(const Class *c)
 {
 	GList *li;
 
@@ -383,7 +356,7 @@ add_bad_hack_to_avoid_unused_warnings(Class *c)
 }
 
 static void
-put_variable(Variable *v, FILE *fp)
+put_variable(const Variable *v, FILE *fp)
 {
 	out_printf(fp, "\t");
 	print_type(fp, v->vtype, FALSE);
@@ -424,29 +397,64 @@ put_pub_method(const Method *m)
 static void
 put_signal_macro (const Method *m, gboolean gnu)
 {
-	char *id;
-
 	if(m->method != SIGNAL_LAST_METHOD &&
 	   m->method != SIGNAL_FIRST_METHOD)
 		return;
 
-	id = g_strdup (m->id);
-	g_strup (id);
-
 	if ( ! gnu) {
-		out_printf (outh, "#define %s_SIGNAL_%s(func)\t"
-			    "\"%s\",(GCallback)(func)\n",
-			    macrobase, id, m->id);
+		/* connect */
+		out_printf (outh, "#define %s_connect__%s(object,func,data)\t"
+			    "g_signal_connect(%s(object),\"%s\","
+			    "(GCallback)(func),(data))\n",
+			    funcbase, m->id, macrobase, m->id);
+
+		/* connect_after */
+		out_printf (outh, "#define %s_connect_after__%s(object,func,data)\t"
+			    "g_signal_connect_after(%s(object),\"%s\","
+			    "(GCallback)(func),(data))\n",
+			    funcbase, m->id, macrobase, m->id);
+
+		/* connect_data */
+		out_printf (outh, "#define %s_connect_data__%s"
+			    "(object,func,data,destroy_data,flags)\t"
+			    "g_signal_connect_data(%s(object),\"%s\","
+			    "(GCallback)(func),(data),(destroy_data),(GConnectFlags)(flags))\n",
+			    funcbase, m->id, macrobase, m->id);
 	} else {
-		out_printf (outh, "#define %s_SIGNAL_%s(func)\t"
-			    "\"%s\",(GCallback)(({",
-			    macrobase, id, m->id);
-		print_method (outh, "", "(* ___", "", ") ", ", gpointer data ",
-			      " = func; ", m, FALSE, TRUE, TRUE);
-		out_printf (outh, "___%s; }))\n", m->id);
-
+		/* connect */
+		out_printf (outh, "#define %s_connect__%s(object,func,data)\t"
+			    "g_signal_connect("
+			    "%s(({%s *___object = (object); ___object; })),"
+			    "\"%s\","
+			    "(GCallback)({",
+			    funcbase, m->id, macrobase, typebase, m->id);
+		print_method (outh, "", "(* ___", "", ") ", ", gpointer ___data ",
+			      " = (func); ", m, FALSE, TRUE, TRUE);
+		out_printf (outh, "___%s; }), (data))\n", m->id);
+
+		/* connect_after */
+		out_printf (outh, "#define %s_connect_after__%s(object,func,data)\t"
+			    "g_signal_connect_after("
+			    "%s(({%s *___object = (object); ___object; })),"
+			    "\"%s\","
+			    "(GCallback)({",
+			    funcbase, m->id, macrobase, typebase, m->id);
+		print_method (outh, "", "(* ___", "", ") ", ", gpointer ___data ",
+			      " = (func); ", m, FALSE, TRUE, TRUE);
+		out_printf (outh, "___%s; }), (data))\n", m->id);
+
+		/* connect_data */
+		out_printf (outh, "#define %s_connect_data__%s"
+			    "(object,func,data,destroy_data,flags)\t"
+			    "g_signal_connect_data("
+			    "%s(({%s *___object = (object); ___object; })),"
+			    "\"%s\","
+			    "(GCallback)({",
+			    funcbase, m->id, macrobase, typebase, m->id);
+		print_method (outh, "", "(* ___", "", ") ", ", gpointer ___data ",
+			      " = (func); ", m, FALSE, TRUE, TRUE);
+		out_printf (outh, "___%s; }), (data), (destroy_data), (GConnectFlags)(flags))\n", m->id);
 	}
-	g_free (id);
 }
 
 static void
@@ -464,6 +472,44 @@ put_signal_macros (const Class *c, gboolean gnu)
 	}
 }
 
+static void
+put_local_signal_macro (const Method *m)
+{
+	if(m->method != SIGNAL_LAST_METHOD &&
+	   m->method != SIGNAL_FIRST_METHOD)
+		return;
+
+	/* connect */
+	out_printf (out, "#define self_connect__%s(object,func,data)\t"
+		    "%s_connect__%s((object),(func),(data))\n",
+		    m->id, funcbase, m->id);
+
+	/* connect_after */
+	out_printf (out, "#define self_connect_after__%s(object,func,data)\t"
+		    "%s_connect_after__%s((object),(func),(data))\n",
+		    m->id, funcbase, m->id);
+
+	/* connect_data */
+	out_printf (out, "#define self_connect_data__%s(object,func,data,destroy_data,flags)\t"
+		    "%s_connect_data__%s((object),(func),(data),(destroy_data),(flags))\n",
+		    m->id, funcbase, m->id);
+}
+
+static void
+put_local_signal_macros (const Class *c)
+{
+	const GList *li;
+
+	if (signals < 0)
+		return;
+
+	for (li = c->nodes; li != NULL; li = li->next) {
+		const Node *n = li->data;
+		if (n->type == METHOD_NODE)
+			put_local_signal_macro ((Method *)n);
+	}
+}
+
 
 static void
 put_prot_method(const Method *m)
@@ -480,7 +526,7 @@ put_prot_method(const Method *m)
 }
 
 static void
-put_priv_method_prot(Method *m)
+put_priv_method_prot(const Method *m)
 {
 	if(m->method == SIGNAL_LAST_METHOD ||
 	   m->method == SIGNAL_FIRST_METHOD ||
@@ -511,16 +557,16 @@ put_priv_method_prot(Method *m)
 }
 
 static GList *
-make_func_arg(char *typename, int is_class, char *name)
+make_func_arg (const char *typename, gboolean is_class, const char *name)
 {
 	Node *node;
 	Node *type;
 	char *tn;
 	
-	if(is_class)
-		tn = g_strconcat(typename, ":Class", NULL);
+	if (is_class)
+		tn = g_strconcat (typename, ":Class", NULL);
 	else
-		tn = g_strdup(typename);
+		tn = g_strdup (typename);
 
 	type = node_new (TYPE_NODE,
 			 "name:steal", tn,
@@ -528,9 +574,9 @@ make_func_arg(char *typename, int is_class, char *name)
 			 NULL);
 	node = node_new (FUNCARG_NODE,
 			 "atype:steal", (Type *)type,
-			 "name:steal", name,
+			 "name", name,
 			 NULL);
-	return g_list_prepend(NULL, node);
+	return g_list_prepend (NULL, node);
 }
 
 static void
@@ -564,7 +610,9 @@ make_inits(Class *cl)
 				 "method", CLASS_INIT_METHOD,
 				 "mtype:steal", type,
 				 "id", "class_init",
-				 "args:steal", make_func_arg (cl->otype, TRUE, g_strdup("c")),
+				 "args:steal", make_func_arg (cl->otype,
+							      TRUE /* is_class */,
+							      "c" /* name */),
 				 "unique_id", method_unique_id++,
 				 NULL);
 		cl->nodes = g_list_prepend(cl->nodes, node);
@@ -578,7 +626,9 @@ make_inits(Class *cl)
 				 "method", INIT_METHOD,
 				 "mtype:steal", type,
 				 "id", "init",
-				 "args:steal", make_func_arg (cl->otype, TRUE, g_strdup("o")),
+				 "args:steal", make_func_arg (cl->otype,
+							      FALSE /* is_class */,
+							      "o" /* name */),
 				 "unique_id", method_unique_id++,
 				 NULL);
 		cl->nodes = g_list_prepend(cl->nodes, node);
@@ -586,30 +636,30 @@ make_inits(Class *cl)
 }
 
 static void
-find_shutdown(Class *cl)
+find_dispose(const Class *cl)
 {
 	GList *li;
 
-	shutdown_handler = NULL;
+	dispose_handler = NULL;
 	for(li=cl->nodes;li;li=g_list_next(li)) {
 		Node *n = li->data;
 		if(n->type == METHOD_NODE) {
 			Method *m = (Method *)n;
 			if(m->method == OVERRIDE_METHOD &&
-			   strcmp(m->id, "shutdown")==0) {
+			   strcmp(m->id, "dispose")==0) {
 				if(strcmp(m->otype, "G:Object") != 0) {
 					error_print(GOB_ERROR, m->line_no,
-						    "shutdown method override "
+						    "dispose method override "
 						    "of class other then "
 						    "G:Object");
 				}
 				if(g_list_length(m->args) != 1) {
 					error_print(GOB_ERROR, m->line_no,
-						    "shutdown method override "
+						    "dispose method override "
 						    "with more then one "
 						    "parameter");
 				}
-				shutdown_handler = m;
+				dispose_handler = m;
 				break;
 			}
 		}
@@ -617,7 +667,7 @@ find_shutdown(Class *cl)
 }
 
 static void
-find_finalize(Class *cl)
+find_finalize(const Class *cl)
 {
 	GList *li;
 
@@ -658,7 +708,7 @@ static GList *eq_signal_methods = NULL;
 
 /* compare a list of strings */
 static gboolean
-is_list_equal(GList *a, GList *b)
+is_list_equal(const GList *a, const GList *b)
 {
 	for(;a && b; a=a->next, b=b->next) {
 		if(strcmp(a->data, b->data)!=0) {
@@ -672,7 +722,7 @@ is_list_equal(GList *a, GList *b)
 }
 
 static Method *
-find_same_type_signal(Method *m)
+find_same_type_signal(const Method *m)
 {
 	GList *li;
 	for(li=eq_signal_methods;li;li=li->next) {
@@ -684,7 +734,7 @@ find_same_type_signal(Method *m)
 }
 
 static void
-print_signal_marsal_args (Method *m)
+print_signal_marsal_args (const Method *m)
 {
 	if (strcmp (m->gtktypes->next->data, "NONE") != 0) {
 		GList *li;
@@ -692,9 +742,16 @@ print_signal_marsal_args (Method *m)
 		for (i = 0, li = m->gtktypes->next;
 		     li != NULL;
 		     i++, li = li->next) {
-			char *get_func = g_strdup_printf
-				("g_value_get_%s", (char *)li->data);
-			g_strdown (get_func);
+			char *get_func;
+
+			if (strcmp (li->data, "UNICHAR") == 0)
+				/* hack because glib is braindamaged */
+				get_func = g_strdup ("g_value_get_uint");
+			else
+				get_func = g_strdup_printf
+					("g_value_get_%s", (char *)li->data);
+
+			gob_strdown (get_func);
 			out_printf (out, ",\n\t\t(%s) "
 				    "%s (param_values + %d)",
 				    get_cast (li->data, FALSE),
@@ -807,11 +864,18 @@ add_signal_prots(Method *m)
 		gboolean take_ownership = 
 			(strcmp ((char *)m->gtktypes->data, "STRING") == 0 ||
 			 strcmp ((char *)m->gtktypes->data, "BOXED") == 0);
-		char *set_func = g_strdup_printf ("g_value_set_%s%s",
-						  (char *)m->gtktypes->data,
-						  take_ownership ?
+		char *set_func;
+
+
+		if (strcmp (m->gtktypes->data, "UNICHAR") == 0)
+			/* hack because glib is braindamaged */
+			set_func = g_strdup ("g_value_set_uint");
+		else
+			set_func = g_strdup_printf ("g_value_set_%s%s",
+						    (char *)m->gtktypes->data,
+						    take_ownership ?
 						    "_take_ownership" : ""); 
-		g_strdown (set_func);
+		gob_strdown (set_func);
 
 		out_printf (out, "\n\t%s (return_value, v_return);\n",
 			    set_func);
@@ -835,7 +899,7 @@ add_enums(Class *c)
 				if(m->method == SIGNAL_LAST_METHOD ||
 				   m->method == SIGNAL_FIRST_METHOD) {
 					char *s = g_strdup(m->id);
-					g_strup(s);
+					gob_strup(s);
 					out_printf(out, "\t%s_SIGNAL,\n", s);
 					g_free(s);
 				}
@@ -851,13 +915,13 @@ add_enums(Class *c)
 			if (n->type == PROPERTY_NODE) {
 				Property *p = (Property *)n;
 				char *s = g_strdup (p->name);
-				g_strup (s);
+				gob_strup (s);
 				out_printf (out, ",\n\tPROP_%s", s);
 				g_free(s);
 			} else if (n->type == ARGUMENT_NODE) {
 				Argument *a = (Argument *)n;
 				char *s = g_strdup(a->name);
-				g_strup(s);
+				gob_strup (s);
 				out_printf(out, ",\n\tPROP_%s", s);
 				g_free(s);
 			}
@@ -873,17 +937,129 @@ add_enums(Class *c)
 	out_printf(out, "static %sClass *parent_class = NULL;\n\n", ptypebase);
 }
 
+static void
+add_interface_methods (Class *c, const char *interface)
+{
+	GList *li;
+	gboolean added_line = FALSE;
+
+	for (li = c->nodes; li != NULL; li = li->next) {
+		Node *n = li->data;
+		Method *m = (Method *)n;
+		if (n->type != METHOD_NODE ||
+		    m->method == OVERRIDE_METHOD ||
+		    m->interface == NULL ||
+		    strcmp (m->interface, interface) != 0)
+			continue;
+
+		if (m->line_no > 0) {
+			out_addline_infile (out, m->line_no);
+			added_line = TRUE;
+		} else if (m->line_no == 0 &&
+			   added_line) {
+			out_addline_outfile (out);
+			added_line = FALSE;
+		}
+		out_printf (out, "\tiface->%s = self_%s;\n",
+			    m->id, m->id);
+	}
+	if (added_line)
+		out_addline_outfile (out);
+}
+
+static void
+add_interface_inits (Class *c)
+{
+	GList *li;
+
+	if (c->interfaces == NULL)
+		return;
+
+	out_printf(out, "\n");
+
+	for (li = c->interfaces; li != NULL; li = li->next) {
+		const char *interface = li->data;
+		const char *end;
+		char *name = replace_sep (interface, '_');
+		char *type = remove_sep (interface);
+
+		/* EEEK! evil, we should have some sort of option
+		 * to force this for arbitrary interfaces, since
+		 * some are Class and some are Iface.  Glib is shite
+		 * in consistency. */
+		if (strcmp (type, "GtkEditable") == 0 ||
+		    strcmp (type, "GTypePlugin") == 0)
+			end = "Class";
+		else
+			/* We'll assume Iface is the standard ending */
+			end = "Iface";
+
+		out_printf (out, "\nstatic void\n"
+			    "___%s_init (%s%s *iface)\n"
+			    "{\n",
+			    name, type, end);
+
+		add_interface_methods (c, interface);
+
+		out_printf (out, "}\n\n");
+
+		g_free (name);
+		g_free (type);
+	}
+}
+
+static void
+add_interface_infos (void)
+{
+	GList *li;
+	for (li = ((Class *)class)->interfaces;
+	     li != NULL;
+	     li = li->next) {
+		char *name = replace_sep (li->data, '_');
+		out_printf (out,
+			    "\t\tstatic const GInterfaceInfo %s_info = {\n"
+			    "\t\t\t(GInterfaceInitFunc) ___%s_init,\n"
+			    "\t\t\tNULL,\n"
+			    "\t\t\tNULL\n"
+			    "\t\t};\n\n",
+			    name, name);
+		g_free (name);
+	}
+}
+
+static void
+add_interfaces (void)
+{
+	GList *li;
+	for (li = ((Class *)class)->interfaces;
+	     li != NULL;
+	     li = li->next) {
+		char *name = replace_sep (li->data, '_');
+		char *type = make_pre_macro (li->data, "TYPE");
+
+		out_printf (out,
+			    "\t\tg_type_add_interface_static (type,\n"
+			    "\t\t\t%s,\n"
+			    "\t\t\t&%s_info);\n",
+			    type,
+			    name);
+
+		g_free (type);
+		g_free (name);
+	}
+}
+
 static void
 add_get_type(void)
 {
 	/*char *chunk_size = ((Class*)class)->chunk_size;*/
-	
+
 	out_printf(out,
 		   "GType\n"
 		   "%s_get_type (void)\n"
 		   "{\n"
 		   "\tstatic GType type = 0;\n\n"
-		   "\tif (type == 0) {\n"
+		   "\tif ___GOB_UNLIKELY(type == 0) {\n"
 		   "\t\tstatic const GTypeInfo info = {\n"
 		   "\t\t\tsizeof (%sClass),\n"
 		   "\t\t\t(GBaseInitFunc) NULL,\n"
@@ -894,10 +1070,17 @@ add_get_type(void)
 		   "\t\t\tsizeof (%s),\n"
 		   "\t\t\t0 /* n_preallocs */,\n"
 		   "\t\t\t(GInstanceInitFunc) %s_init,\n"
-		   "\t\t};\n\n"
-		   "\t\ttype = g_type_register_static (%s, \"%s\", &info, (GTypeFlags)0);\n",
-		   funcbase, typebase, funcbase, typebase, funcbase,
-		   pmacrotype, typebase);
+		   "\t\t};\n\n",
+		   funcbase, typebase, funcbase, typebase, funcbase);
+
+	add_interface_infos ();
+
+	out_printf (out,
+		    "\t\ttype = g_type_register_static (%s, \"%s\", &info, (GTypeFlags)0);\n",
+		    pmacrotype, typebase);
+
+	add_interfaces ();
+
 	/*
 	if(chunk_size)  {
 		out_printf(out,
@@ -914,39 +1097,54 @@ add_get_type(void)
 }
 
 static void
-add_bonobo_x_get_type (void)
+add_bonobo_object_get_type (void)
 {
 	/* char *chunk_size = ((Class*)class)->chunk_size; */
+	/* _vicious_ spanks seth with a rusty nail
+        out_printf(out,
+		   "\n#warning \"Bonobo isn't fully ported to glib 2.0 and "
+		   "gob2 doesn't officially support it yet. It'd be safer "
+                   "and a lot more fun to blow goats.\"\n");
+		   */
+
+	out_printf (out,
+		    "GType\n"
+		    "%s_get_type (void)\n" /* 1 */
+		    "{\n"
+		    "\tstatic GType type = 0;\n\n"
+		    "\tif ___GOB_UNLIKELY(type == 0) {\n"
+		    "\t\tstatic const GTypeInfo info = {\n"
+		    "\t\t\tsizeof (%sClass),\n" /* 2 */
+		    "\t\t\t(GBaseInitFunc) NULL,\n"
+		    "\t\t\t(GBaseFinalizeFunc) NULL,\n"
+		    "\t\t\t(GClassInitFunc) %s_class_init,\n" /* 3 */
+		    "\t\t\tNULL, /* class_finalize */\n"
+		    "\t\t\tNULL, /* class_data */\n"
+		    "\t\t\tsizeof (%s),\n" /* 4 */
+		    "\t\t\t0, /* n_preallocs */\n"
+		    "\t\t\t(GInstanceInitFunc)  %s_init,\n" /* 5 */
+		    "\t\t\tNULL\n"
+		    "\t\t};\n\n",
+		    funcbase /* 1 */,
+		    typebase /* 2 */,
+		    funcbase /* 3 */,
+		    typebase /* 4 */,
+		    funcbase /* 5 */);
+
+	add_interface_infos ();
+
+	out_printf (out,
+		   "\t\ttype = bonobo_type_unique (\n"
+		   "\t\t\tBONOBO_OBJECT_TYPE,\n"
+		   "\t\t\tPOA_%s__init, NULL,\n" /* 1 */
+		   "\t\t\tG_STRUCT_OFFSET (%sClass, _epv),\n" /* 2 */
+		   "\t\t\t&info, \"%s\");\n", /* 3 */
+		   ((Class*)class)->bonobo_object_class /* 1 */,
+		   typebase /* 2 */,
+		   typebase /* 3 */);
+
+	add_interfaces ();
 
-	out_printf(out,
-		   "\n#error \"BonoboX isn't ported to glib 2.0 and "
-		   "gob2 doesn't support it yet\"");
-	
-	out_printf(out,
-		   "GtkType\n"
-		   "%s_get_type (void)\n"
-		   "{\n"
-		   "\tstatic GtkType type = 0;\n\n"
-		   "\tif (type == 0) {\n"
-		   "\t\tstatic const GtkTypeInfo info = {\n"
-		   "\t\t\t\"%s\",\n"
-		   "\t\t\tsizeof (%s),\n"
-		   "\t\t\tsizeof (%sClass),\n"
-		   "\t\t\t(GtkClassInitFunc) %s_class_init,\n"
-		   "\t\t\t(GtkObjectInitFunc) %s_init,\n"
-		   "\t\t\t/* reserved_1 */ NULL,\n"
-		   "\t\t\t/* reserved_2 */ NULL,\n"
-		   "\t\t\t(GtkClassInitFunc) NULL\n"
-		   "\t\t};\n\n"
-		   "\t\ttype = bonobo_x_type_unique\n"
-		   "\t\t\t(%s_get_type (),\n"
-		   "\t\t\tPOA_%s__init, NULL,\n"
-		   "\t\t\tGTK_STRUCT_OFFSET (%sClass, _epv),\n"
-		   "\t\t\t&info);\n",
-		   funcbase, typebase, typebase, typebase,
-		   funcbase, funcbase, pfuncbase,
-		   ((Class*)class)->bonobo_x_class,
-		   typebase);
 	/*if(chunk_size)  {
 		out_printf(out,
 			   "#if %s > 0\n"
@@ -990,7 +1188,7 @@ add_overrides(Class *c, const char *oname,
 		g_hash_table_insert(done, s, s);
 
 		f = replace_sep(m->otype, '_');
-		g_strdown(f);
+		gob_strdown(f);
 
 		out_printf(out, "\t%sClass *%s_class = (%sClass *)%s;\n",
 			   s, f, s, oname);
@@ -1084,7 +1282,7 @@ add_signals(Class *c)
 		is_none = (strcmp(m->gtktypes->next->data, "NONE")==0);
 
 		sig = g_strdup (m->id);
-		g_strup (sig);
+		gob_strup (sig);
 		flags = make_run_signal_flags (m, last);
 		out_printf (out, "\tobject_signals[%s_SIGNAL] =\n"
 			    "\t\tg_signal_new (\"%s\",\n"
@@ -1115,8 +1313,8 @@ add_signals(Class *c)
 		if(strcmp(m->gtktypes->data, "NONE") != 0 ||
 		   ! is_none) {
 			GList *gl, *al;
-			char *sep = "";
-			out_printf(out, "\tif(");
+			const char *sep = "";
+			out_printf(out, "\tif ___GOB_UNLIKELY(");
 			if(strcmp(m->gtktypes->data, "NONE") != 0) {
 				out_printf(out, "%s sizeof(", sep);
 				print_type(out, m->mtype, FALSE);
@@ -1185,13 +1383,13 @@ set_def_handlers(Class *c, const char *oname)
 		if (m->method == OVERRIDE_METHOD) {
 			char *s;
 			s = replace_sep (m->otype, '_');
-			g_strdown (s);
+			gob_strdown (s);
 
-			if (need_shutdown &&
-			    shutdown_handler != NULL &&
-			    strcmp (m->id, "shutdown") == 0)
-				out_printf (out, "\tg_object_class->shutdown "
-					    "= ___shutdown;\n");
+			if (need_dispose &&
+			    dispose_handler != NULL &&
+			    strcmp (m->id, "dispose") == 0)
+				out_printf (out, "\tg_object_class->dispose "
+					    "= ___dispose;\n");
 			else if (need_finalize &&
 				finalize_handler &&
 				strcmp(m->id, "finalize") == 0)
@@ -1271,7 +1469,7 @@ make_argument (Argument *a)
 	g_string_append (flags, ")");
 
 	s = g_strdup(a->name);
-	g_strup(s);
+	gob_strup (s);
 	if (!strcmp (a->gtktype, "ENUM"))
 		out_printf(out, "\tparam_spec = g_param_spec_enum (\"%s\", NULL, NULL,\n"
 			   "\t\tG_TYPE_ENUM, 0,\n"
@@ -1340,6 +1538,18 @@ make_argument (Argument *a)
 			   "\t\t0,\n"
 			   "\t\t%s);\n",
 			   a->name, flags->str);
+	else if (!strcmp (a->gtktype, "INT64"))
+		out_printf(out, "\tparam_spec = g_param_spec_int64 (\"%s\", NULL, NULL,\n"
+			   "\t\tG_MININT64, G_MAXINT64,\n"
+			   "\t\t0,\n"
+			   "\t\t%s);\n",
+			   a->name, flags->str);
+	else if (!strcmp (a->gtktype, "UINT64"))
+		out_printf(out, "\tparam_spec = g_param_spec_uint64 (\"%s\", NULL, NULL,\n"
+			   "\t\t0, G_MAXUINT64,\n"
+			   "\t\t0,\n"
+			   "\t\t%s);\n",
+			   a->name, flags->str);
 	else if (!strcmp (a->gtktype, "FLOAT"))
 		out_printf(out, "\tparam_spec = g_param_spec_float (\"%s\", NULL, NULL,\n"
 			   "\t\tG_MINFLOAT, G_MAXFLOAT,\n"
@@ -1371,6 +1581,21 @@ make_argument (Argument *a)
 
 #define value_for_print(str, alt) (str != NULL ? str : alt)
 
+static char *
+make_me_type (const char *type, const char *alt)
+{
+	if (type == NULL)
+		return g_strdup (alt);
+	/* HACK!  just in case someone made this
+	 * work with 2.0.0 by using the TYPE
+	 * macro directly */
+	if ((strstr (type, "_TYPE_") != NULL ||
+	     strstr (type, "TYPE_") == type) &&
+	    strchr (type, ':') == NULL)
+		return g_strdup (type);
+	return make_pre_macro (type, "TYPE");
+}
+
 static void
 make_property (Property *p)
 {
@@ -1425,7 +1650,7 @@ make_property (Property *p)
 
 	g_string_append (flags, ")");
 
-	if (strcmp (p->gtktype, "CHAR") == 0)
+	if (strcmp (p->gtktype, "CHAR") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_char\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1441,7 +1666,7 @@ make_property (Property *p)
 			    value_for_print (p->maximum, "127"),
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "UCHAR") == 0)
+	} else if (strcmp (p->gtktype, "UCHAR") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_uchar\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1457,7 +1682,7 @@ make_property (Property *p)
 			    value_for_print (p->maximum, "0xFF"),
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "BOOLEAN") == 0)
+	} else if (strcmp (p->gtktype, "BOOLEAN") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_boolean\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1469,7 +1694,7 @@ make_property (Property *p)
 			    value_for_print (p->blurb, "NULL"),
 			    value_for_print (p->default_value, "FALSE"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "INT") == 0)
+	} else if (strcmp (p->gtktype, "INT") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_int\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1485,7 +1710,7 @@ make_property (Property *p)
 			    value_for_print (p->maximum, "G_MAXINT"),
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "UINT") == 0)
+	} else if (strcmp (p->gtktype, "UINT") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_uint\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1501,7 +1726,7 @@ make_property (Property *p)
 			    value_for_print (p->maximum, "G_MAXUINT"),
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "LONG") == 0)
+	} else if (strcmp (p->gtktype, "LONG") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_long\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1517,7 +1742,7 @@ make_property (Property *p)
 			    value_for_print (p->maximum, "G_MAXLONG"),
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "ULONG") == 0)
+	} else if (strcmp (p->gtktype, "ULONG") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_ulong\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1533,7 +1758,39 @@ make_property (Property *p)
 			    value_for_print (p->maximum, "G_MAXULONG"),
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "UNICHAR") == 0)
+	} else if (strcmp (p->gtktype, "INT64") == 0) {
+		out_printf (out, "\tparam_spec = g_param_spec_int64\n"
+			    "\t\t(\"%s\" /* name */,\n"
+			    "\t\t %s /* nick */,\n"
+			    "\t\t %s /* blurb */,\n"
+			    "\t\t %s /* minimum */,\n"
+			    "\t\t %s /* maximum */,\n"
+			    "\t\t %s /* default_value */,\n"
+			    "\t\t %s);\n",
+			    p->name,
+			    value_for_print (p->nick, "NULL"),
+			    value_for_print (p->blurb, "NULL"),
+			    value_for_print (p->minimum, "G_MININT64"),
+			    value_for_print (p->maximum, "G_MAXINT64"),
+			    value_for_print (p->default_value, "0"),
+			    flags->str);
+	} else if (strcmp (p->gtktype, "UINT64") == 0) {
+		out_printf (out, "\tparam_spec = g_param_spec_uint64\n"
+			    "\t\t(\"%s\" /* name */,\n"
+			    "\t\t %s /* nick */,\n"
+			    "\t\t %s /* blurb */,\n"
+			    "\t\t %s /* minimum */,\n"
+			    "\t\t %s /* maximum */,\n"
+			    "\t\t %s /* default_value */,\n"
+			    "\t\t %s);\n",
+			    p->name,
+			    value_for_print (p->nick, "NULL"),
+			    value_for_print (p->blurb, "NULL"),
+			    value_for_print (p->minimum, "0"),
+			    value_for_print (p->maximum, "G_MAXUINT64"),
+			    value_for_print (p->default_value, "0"),
+			    flags->str);
+	} else if (strcmp (p->gtktype, "UNICHAR") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_unichar\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1545,7 +1802,9 @@ make_property (Property *p)
 			    value_for_print (p->blurb, "NULL"),
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "ENUM") == 0)
+	} else if (strcmp (p->gtktype, "ENUM") == 0) {
+		char *type = make_me_type (p->extra_gtktype,
+					   "G_TYPE_ENUM");
 		out_printf (out, "\tparam_spec = g_param_spec_enum\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1556,10 +1815,13 @@ make_property (Property *p)
 			    p->name,
 			    value_for_print (p->nick, "NULL"),
 			    value_for_print (p->blurb, "NULL"),
-			    value_for_print (p->extra_gtktype, "G_TYPE_ENUM"),
+			    type,
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "FLAGS") == 0)
+		g_free (type);
+	} else if (strcmp (p->gtktype, "FLAGS") == 0) {
+		char *type = make_me_type (p->extra_gtktype,
+					   "G_TYPE_FLAGS");
 		out_printf (out, "\tparam_spec = g_param_spec_flags\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1570,10 +1832,11 @@ make_property (Property *p)
 			    p->name,
 			    value_for_print (p->nick, "NULL"),
 			    value_for_print (p->blurb, "NULL"),
-			    value_for_print (p->extra_gtktype, "G_TYPE_FLAGS"),
+			    type,
 			    value_for_print (p->default_value, "0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "FLOAT") == 0)
+		g_free (type);
+	} else if (strcmp (p->gtktype, "FLOAT") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_float\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1589,7 +1852,7 @@ make_property (Property *p)
 			    value_for_print (p->maximum, "G_MAXFLOAT"),
 			    value_for_print (p->default_value, "0.0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "DOUBLE") == 0)
+	} else if (strcmp (p->gtktype, "DOUBLE") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_double\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1605,7 +1868,7 @@ make_property (Property *p)
 			    value_for_print (p->maximum, "G_MAXDOUBLE"),
 			    value_for_print (p->default_value, "0.0"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "STRING") == 0)
+	} else if (strcmp (p->gtktype, "STRING") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_string\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1617,7 +1880,9 @@ make_property (Property *p)
 			    value_for_print (p->blurb, "NULL"),
 			    value_for_print (p->default_value, "NULL"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "PARAM") == 0)
+	} else if (strcmp (p->gtktype, "PARAM") == 0) {
+		char *type = make_me_type (p->extra_gtktype,
+					   "G_TYPE_PARAM");
 		out_printf (out, "\tparam_spec = g_param_spec_param\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1627,9 +1892,12 @@ make_property (Property *p)
 			    p->name,
 			    value_for_print (p->nick, "NULL"),
 			    value_for_print (p->blurb, "NULL"),
-			    value_for_print (p->extra_gtktype, "G_TYPE_PARAM"),
+			    type,
 			    flags->str);
-	else if (strcmp (p->gtktype, "BOXED") == 0)
+		g_free (type);
+	} else if (strcmp (p->gtktype, "BOXED") == 0) {
+		char *type = make_me_type (p->extra_gtktype,
+					   "G_TYPE_BOXED");
 		out_printf (out, "\tparam_spec = g_param_spec_boxed\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1639,9 +1907,10 @@ make_property (Property *p)
 			    p->name,
 			    value_for_print (p->nick, "NULL"),
 			    value_for_print (p->blurb, "NULL"),
-			    value_for_print (p->extra_gtktype, "G_TYPE_BOXED"),
+			    type,
 			    flags->str);
-	else if (strcmp (p->gtktype, "POINTER") == 0)
+		g_free (type);
+	} else if (strcmp (p->gtktype, "POINTER") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_pointer\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1652,7 +1921,7 @@ make_property (Property *p)
 			    value_for_print (p->blurb, "NULL"),
 			    flags->str);
 	/* FIXME: VALUE_ARRAY */
-	else if (strcmp (p->gtktype, "CLOSURE") == 0)
+	} else if (strcmp (p->gtktype, "CLOSURE") == 0) {
 		out_printf (out, "\tparam_spec = g_param_spec_pointer\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1662,7 +1931,9 @@ make_property (Property *p)
 			    value_for_print (p->nick, "NULL"),
 			    value_for_print (p->blurb, "NULL"),
 			    flags->str);
-	else if (strcmp (p->gtktype, "OBJECT") == 0)
+	} else if (strcmp (p->gtktype, "OBJECT") == 0) {
+		char *type = make_me_type (p->extra_gtktype,
+					   "G_TYPE_BOXED");
 		out_printf (out, "\tparam_spec = g_param_spec_object\n"
 			    "\t\t(\"%s\" /* name */,\n"
 			    "\t\t %s /* nick */,\n"
@@ -1672,15 +1943,17 @@ make_property (Property *p)
 			    p->name,
 			    value_for_print (p->nick, "NULL"),
 			    value_for_print (p->blurb, "NULL"),
-			    value_for_print (p->extra_gtktype, "G_TYPE_OBJECT"),
+			    type,
 			    flags->str);
-	else
+		g_free (type);
+	} else {
 		error_printf (GOB_ERROR, p->line_no,
 			      "%s type is not supported by properties",
 			      p->gtktype);
+	}
 
 	s = g_strdup (p->name);
-	g_strup (s);
+	gob_strup (s);
 	out_printf (out, "\tg_object_class_install_property (g_object_class,\n"
 		    "\t\tPROP_%s,\n"
 		    "\t\tparam_spec);\n", s);
@@ -1693,6 +1966,10 @@ static void
 make_arguments(Class *c)
 {
 	GList *li;
+	if (get_properties > 0)
+		out_printf(out, "\tg_object_class->get_property = ___object_get_property;\n");
+	if (set_properties > 0)
+		out_printf(out, "\tg_object_class->set_property = ___object_set_property;\n");
 	out_printf (out, "    {\n"
 		    "\tGParamSpec   *param_spec;\n\n");
 
@@ -1704,11 +1981,6 @@ make_arguments(Class *c)
 			make_argument ((Argument *)n);
 	}
 	out_printf(out, "    }\n");
-	
-	if (get_properties > 0)
-		out_printf(out, "\tg_object_class->get_property = ___object_get_property;\n");
-	if (set_properties > 0)
-		out_printf(out, "\tg_object_class->set_property = ___object_set_property;\n");
 }
 
 static void
@@ -1740,7 +2012,7 @@ print_initializer(Method *m, Variable *v)
 static void
 print_destructor (Variable *v)
 {
-	char *root;
+	const char *root;
 
 	if(v->destructor == NULL)
 		return;
@@ -1781,13 +2053,13 @@ print_destructor (Variable *v)
 }
 
 static void
-add_shutdown (Class *c)
+add_dispose (Class *c)
 {
 	out_printf(out, "\nstatic void\n"
-		   "___shutdown (GObject *obj_self)\n"
+		   "___dispose (GObject *obj_self)\n"
 		   "{\n");
 	out_printf(out,
-		   "#define __GOB_FUNCTION__ \"%s::shutdown\"\n",
+		   "#define __GOB_FUNCTION__ \"%s::dispose\"\n",
 		   c->otype);
 
 	if (unreftors > 0) {
@@ -1795,18 +2067,18 @@ add_shutdown (Class *c)
 			    typebase, macrobase);
 	}
 
-	if (shutdown_handler != NULL) {
+	if (dispose_handler != NULL) {
 		/* so we get possible bad argument warning */
-		if (shutdown_handler->line_no > 0)
-			out_addline_infile (out, shutdown_handler->line_no);
-		out_printf (out, "\t___%x_%s_shutdown(obj_self);\n",
-			    (guint)shutdown_handler->unique_id, funcbase);
-		if (shutdown_handler->line_no > 0)
+		if (dispose_handler->line_no > 0)
+			out_addline_infile (out, dispose_handler->line_no);
+		out_printf (out, "\t___%x_%s_dispose(obj_self);\n",
+			    (guint)dispose_handler->unique_id, funcbase);
+		if (dispose_handler->line_no > 0)
 			out_addline_outfile (out);
 	} else {
 		out_printf (out,
-			    "\tif (G_OBJECT_CLASS (parent_class)->shutdown) \\\n"
-			    "\t\t(* G_OBJECT_CLASS (parent_class)->shutdown) (obj_self);\n");
+			    "\tif (G_OBJECT_CLASS (parent_class)->dispose) \\\n"
+			    "\t\t(* G_OBJECT_CLASS (parent_class)->dispose) (obj_self);\n");
 	}
 
 	if (unreftors > 0) {
@@ -1891,7 +2163,7 @@ add_finalize (Class *c)
 }
 
 static void
-make_bonobo_x_epv (Class *c, const char *classname)
+make_bonobo_object_epv (Class *c, const char *classname)
 {
 	GList *li;
 	gboolean added_line = FALSE;
@@ -1903,7 +2175,7 @@ make_bonobo_x_epv (Class *c, const char *classname)
 		   m->method == OVERRIDE_METHOD)
 			continue;
 
-		if (m->bonobo_x_func) {
+		if (m->bonobo_object_func) {
 			if(m->line_no > 0) {
 				out_addline_infile(out, m->line_no);
 				added_line = TRUE;
@@ -1912,7 +2184,7 @@ make_bonobo_x_epv (Class *c, const char *classname)
 				out_addline_outfile(out);
 				added_line = FALSE;
 			}
-			out_printf (out, "\t%s->_epv.%s = %s;\n",
+			out_printf (out, "\t%s->_epv.%s = self_%s;\n",
 				    classname, m->id, m->id);
 		}
 	}
@@ -1980,7 +2252,7 @@ add_inits(Class *c)
 			if (set_properties > 0 ||
 			    get_properties > 0 ||
 			    signals > 0 ||
-			    need_shutdown ||
+			    need_dispose ||
 			    need_finalize) {
 				out_printf(out,
 					   "\tGObjectClass *"
@@ -2022,9 +2294,9 @@ add_inits(Class *c)
 
 			/* if there are no handlers for these things, we
 			 * need to set them up here */
-			if(need_shutdown && !shutdown_handler)
-				out_printf(out, "\tg_object_class->shutdown "
-					   "= ___shutdown;\n");
+			if(need_dispose && !dispose_handler)
+				out_printf(out, "\tg_object_class->dispose "
+					   "= ___dispose;\n");
 			if(need_finalize && !finalize_handler)
 				out_printf(out, "\tg_object_class->finalize = "
 					   "___finalize;\n");
@@ -2032,8 +2304,8 @@ add_inits(Class *c)
 			if(get_properties > 0 || set_properties > 0)
 				make_arguments(c);
 
-			if (c->bonobo_x_class != NULL) {
-				make_bonobo_x_epv (c, ((FuncArg *)m->args->data)->name);
+			if (c->bonobo_object_class != NULL) {
+				make_bonobo_object_epv (c, ((FuncArg *)m->args->data)->name);
 			}
 		} else
 			continue;
@@ -2075,11 +2347,17 @@ add_argument (Argument *a, gboolean is_set)
 	if (cbuf == NULL)
 		return;
 	s = g_strdup(a->name);
-	g_strup(s);
+	gob_strup (s);
 	out_printf(out, "\tcase PROP_%s:\n\t{", s);
 
 	the_type_lower = g_strdup (a->gtktype);
-	g_strdown (the_type_lower);
+	gob_strdown (the_type_lower);
+
+	/* HACK because there is no g_value_set/get for unichar */
+	if (strcmp (the_type_lower, "unichar") == 0) {
+		g_free (the_type_lower);
+		the_type_lower = g_strdup ("uint");
+	}
 
 	if (is_set) {
 		char *cast;
@@ -2116,7 +2394,7 @@ add_argument (Argument *a, gboolean is_set)
 	out_printf (out, "\t\t}\n");
 	if ( ! is_set) {
 		if (strcmp (a->gtktype, "OBJECT") == 0)
-			out_printf (out, "\t\tg_value_set_%s (VAL, G_OBJECT (ARG))\n",
+			out_printf (out, "\t\tg_value_set_%s (VAL, G_OBJECT (ARG));\n",
 				    the_type_lower);
 		else
 			out_printf (out, "\t\t"
@@ -2153,9 +2431,9 @@ add_property (Property *p, gboolean is_set)
 		return;
 
 	name_upper = g_strdup (p->name);
-	g_strup (name_upper);
+	gob_strup (name_upper);
 	the_type_lower = g_strdup (p->gtktype);
-	g_strdown (the_type_lower);
+	gob_strdown (the_type_lower);
 
 	out_printf (out, "\tcase PROP_%s:\n", name_upper);
 
@@ -2328,11 +2606,21 @@ put_signal_args (Method *m)
 {
 	GList *li;
 	GList *ali;
-	for (ali = m->gtktypes->next, li=m->args->next;
+	int i;
+
+	if (m->args->next == NULL)
+		return;
+
+	for (ali = m->gtktypes->next, li = m->args->next, i = 1;
 	     li != NULL && ali != NULL;
-	     li = li->next, ali = ali->next) {
+	     li = li->next, ali = ali->next, i++) {
 		FuncArg *fa = li->data;
 		char *cast = g_strdup (get_cast (ali->data, FALSE));
+		/* FIXME: This code is so fucking ugly it hurts */
+		gboolean do_static = 
+			(strcmp ((char *)ali->data, "STRING") == 0 ||
+			 strcmp ((char *)ali->data, "BOXED") == 0);
+		char *set_func;
 
 		if (cast == NULL) {
 			cast = get_type (fa->atype, TRUE);
@@ -2341,28 +2629,60 @@ put_signal_args (Method *m)
 		   the we know all the types */
 		g_assert (cast != NULL);
 
-		out_printf (out, ",\n\t\t(%s)%s", cast,
-			    fa->name);
+		out_printf (out,
+			    "\t___param_values[%d].g_type = 0;\n"
+			    "\tg_value_init (&___param_values[%d], G_TYPE_%s);\n",
+			    i, i, (char *)ali->data);
+
+		if (strcmp (ali->data, "UNICHAR") == 0)
+			/* hack because glib is braindamaged */
+			set_func = g_strdup ("g_value_set_uint");
+		else
+			set_func = g_strdup_printf ("g_value_set%s_%s",
+						    do_static ? "_static" : "",
+						    (char *)ali->data);
+		gob_strdown (set_func);
 
+		out_printf (out, "\t%s (&___param_values[%d], (%s) %s);\n\n",
+			    set_func, i, cast, fa->name);
+
+		g_free (set_func);
 		g_free (cast);
 	}
 }
 
+static void
+clear_signal_args (Method *m)
+{
+	GList *li;
+	int i;
+
+	out_printf (out, "\n\tg_value_unset (&___param_values[0]);\n");
+
+	if (m->args->next == NULL)
+		return;
+
+	for (li = m->args->next, i = 1;
+	     li != NULL;
+	     li = li->next, i++) {
+		out_printf (out,
+			    "\tg_value_unset (&___param_values[%d]);\n", i);
+	}
+}
+
 static char *
-get_arg_names_for_macro(Method *m)
+get_arg_names_for_macro (Method *m)
 {
-	char *p;
+	const char *sep;
 	GList *li;
 	GString *gs = g_string_new(NULL);
-	p = "";
+	sep = "";
 	for(li=m->args;li;li=g_list_next(li)) {
 		FuncArg *arg = li->data;
-		g_string_sprintfa(gs, "%s___%s", p, arg->name);
-		p = ",";
+		g_string_sprintfa (gs, "%s___%s", sep, arg->name);
+		sep = ",";
 	}
-	p = gs->str;
-	g_string_free(gs, FALSE);
-	return p;
+	return g_string_free (gs, FALSE);
 }
 
 static void
@@ -2403,38 +2723,114 @@ put_method(Method *m)
 		else /* PUBLIC, PROTECTED */
 			print_method(out, "", "\n", "", " ", "", "\n",
 				     m, FALSE, FALSE, TRUE);
-		out_addline_outfile(out);
-		out_printf(out, "{\n");
-		s = g_strdup(m->id);
-		g_strup(s);
-		if(strcmp(m->mtype->name, "void") == 0 &&
-		   m->mtype->pointer == NULL) {
-			print_preconditions(m);
-			if(((FuncArg *)m->args->data)->name)
-			out_printf(out, "\tg_signal_emit (G_OBJECT (%s),\n"
-				"\t\tobject_signals[%s_SIGNAL], 0",
-				((FuncArg *)m->args->data)->name, s);
-			put_signal_args (m);
-			out_printf(out, ");\n}\n");
-		} else {
-			out_printf(out, "\t");
-			print_type(out, m->mtype, TRUE);
-			out_printf(out, "return_val = (");
-			print_type(out, m->mtype, TRUE);
-			if(m->defreturn)
-				out_printf(out, ")(%s);\n", m->defreturn);
-			else if(m->onerror)
-				out_printf(out, ")(%s);\n", m->onerror);
+		out_addline_outfile (out);
+
+		out_printf (out, "{\n");
+
+		out_printf (out,
+			    "\tGValue ___param_values[%d];\n"
+			    "\tGValue ___return_val = {0};\n\n",
+			    g_list_length (m->args));
+
+		print_preconditions (m);
+
+		out_printf (out,
+			    "\n\t___param_values[0].g_type = 0;\n"
+			    "\tg_value_init (&___param_values[0], G_TYPE_FROM_INSTANCE (%s));\n"
+			    "\tg_value_set_instance (&___param_values[0], (gpointer) %s);\n\n",
+			    ((FuncArg *)m->args->data)->name,
+			    ((FuncArg *)m->args->data)->name);
+
+		put_signal_args (m);
+
+		if (strcmp (m->gtktypes->data, "NONE") != 0) {
+			const char *defret = NULL;
+
+			out_printf (out, "\tg_value_init (&___return_val, G_TYPE_%s);\n",
+				    (char *)m->gtktypes->data);
+
+			if (m->defreturn != NULL)
+				defret = m->defreturn;
+			else if (m->onerror != NULL)
+				defret = m->onerror;
+
+			if (defret != NULL) {
+				char *set_func;
+				/* FIXME: This code is so fucking ugly it hurts */
+				gboolean do_static = 
+					(strcmp ((char *)m->gtktypes->data, "STRING") == 0 ||
+					 strcmp ((char *)m->gtktypes->data, "BOXED") == 0);
+				char *cast = g_strdup (get_cast (m->gtktypes->data, FALSE));
+				if (cast == NULL)
+					cast = get_type (m->mtype, TRUE);
+
+				if (strcmp (m->gtktypes->data, "UNICHAR") == 0)
+					/* hack because glib is braindamaged */
+					set_func = g_strdup ("g_value_set_uint");
+				else
+					set_func = g_strdup_printf ("g_value_set%s_%s",
+								    do_static ? "_static" : "",
+								    (char *)m->gtktypes->data);
+				gob_strdown (set_func);
+
+				out_printf (out, "\t%s (&___return_val, (%s) (%s));\n",
+					    set_func, cast, defret);
+
+				g_free (set_func);
+				g_free (cast);
+			}
+			out_printf (out, "\n");
+		}
+
+		s = g_strdup (m->id);
+		gob_strup (s);
+
+		out_printf(out, "\tg_signal_emitv (___param_values,\n"
+			   "\t\tobject_signals[%s_SIGNAL],\n"
+			   "\t\t0 /* detail */,\n"
+			   "\t\t&___return_val);\n", s);
+
+		g_free (s);
+
+		clear_signal_args (m);
+
+		if (strcmp (m->gtktypes->data, "NONE") != 0) {
+			char *cast = g_strdup (get_cast (m->gtktypes->data, FALSE));
+			char *getfunc;
+			/* Hack because glib is very very braindead */
+			gboolean do_dup = 
+				(strcmp ((char *)m->gtktypes->data, "STRING") == 0 ||
+				 strcmp ((char *)m->gtktypes->data, "BOXED") == 0 ||
+				 strcmp ((char *)m->gtktypes->data, "OBJECT") == 0 ||
+				 strcmp ((char *)m->gtktypes->data, "PARAM") == 0);
+
+			if (strcmp (m->gtktypes->data, "UNICHAR") == 0)
+				/* hack because glib is braindamaged */
+				getfunc = g_strdup ("g_value_get_uint");
 			else
-				out_printf(out, ")(0);\n");
-			print_preconditions(m);
-			out_printf(out, "\tg_signal_emit (G_OBJECT (%s),\n"
-				"\t\tobject_signals[%s_SIGNAL], 0",
-				((FuncArg *)m->args->data)->name, s);
-			put_signal_args(m);
-			out_printf(out, ",\n\t\t&return_val);\n"
-				"\treturn return_val;\n}\n");
+				getfunc = g_strdup_printf ("g_value_%s_%s",
+							   do_dup ? "dup" : "get",
+							   (char *)m->gtktypes->data);
+			gob_strdown (getfunc);
+
+			if (cast == NULL)
+				cast = get_type (m->mtype, TRUE);
+
+			out_printf (out,
+				    "\n\t{\n"
+				    "\t\t");
+			print_type (out, m->mtype, TRUE);
+			out_printf (out,
+				    " ___ret = (%s) %s (&___return_val);\n"
+				    "\t\tg_value_unset (&___return_val);\n"
+				    "\t\treturn ___ret;\n"
+				    "\t}\n",
+				    cast, getfunc);
+
+			g_free (cast);
+			g_free (getfunc);
 		}
+		out_printf(out, "}\n");
 
 		if(!m->cbuf)
 			break;
@@ -2514,7 +2910,7 @@ put_method(Method *m)
 		g_free(s);
 		out_addline_outfile(out);
 		s = replace_sep(m->otype, '_');
-		g_strup(s);
+		gob_strup (s);
 		args = get_arg_names_for_macro(m);
 		if(is_void) {
 			out_printf(out, "#define PARENT_HANDLER(%s) \\\n"
@@ -2568,7 +2964,7 @@ open_files(void)
 	if (no_write) {
 		devnull = fopen ("/dev/null", "w");
 		if (devnull == NULL)
-			g_error ("Cannot open null device");
+			error_print (GOB_ERROR, 0, "Cannot open null device");
 		out = devnull;
 		outh = devnull;
 		if (outfileph != NULL)
@@ -2576,15 +2972,21 @@ open_files(void)
 	} else {
 		out = fopen (outfile, "w");
 		if (out == NULL) {
-			g_error ("Cannot open outfile: %s", outfile);
+			error_printf (GOB_ERROR, 0,
+				      "Cannot open outfile: %s", outfile);
 		}
 		outh = fopen (outfileh, "w");
-		if (outh == NULL)
-			g_error ("Cannot open outfile: %s", outfileh);
+		if (outh == NULL) {
+			error_printf (GOB_ERROR, 0,
+				      "Cannot open outfile: %s", outfileh);
+		}
 		if (outfileph != NULL) {
 			outph = fopen (outfileph, "w");
-			if (outph == NULL)
-				g_error ("Cannot open outfile: %s", outfileh);
+			if (outph == NULL) {
+				error_printf (GOB_ERROR, 0,
+					      "Cannot open outfile: %s",
+					      outfileph);
+			}
 		}
 	}
 }
@@ -2624,7 +3026,7 @@ put_argument_nongnu_wrappers (Class *c)
 		}
 
 		aname = g_strdup (name);
-		g_strup (aname);
+		gob_strup (aname);
 
 		if (atype != NULL)
 			cast = get_type (atype, TRUE);
@@ -2690,7 +3092,7 @@ put_argument_gnu_wrappers(Class *c)
 		}
 
 		aname = g_strdup (name);
-		g_strup (aname);
+		gob_strup (aname);
 
 		if (atype != NULL)
 			cast = get_type (atype, TRUE);
@@ -2850,7 +3252,7 @@ print_class_block(Class *c)
 		    " * Main object structure\n"
 		    " */\n");
 	s = replace_sep (c->otype, '_');
-	g_strup (s);
+	gob_strup (s);
 	out_printf (outh, "#ifndef __TYPEDEF_%s__\n"
 		    "#define __TYPEDEF_%s__\n", s, s);
 	g_free (s);
@@ -2932,11 +3334,11 @@ print_class_block(Class *c)
 			put_vs_method((Method *)n);
 	}
 	/* If BonoboX type class put down the epv */
-	if (c->bonobo_x_class != NULL) {
+	if (c->bonobo_object_class != NULL) {
 		out_printf (outh,
 			    "\t/* Bonobo object epv */\n"
 			    "\tPOA_%s__epv _epv;\n",
-			    c->bonobo_x_class);
+			    c->bonobo_object_class);
 	}
 	/* put class scope variables */
 	for (li = c->nodes; li != NULL; li = li->next) {
@@ -2965,12 +3367,7 @@ print_class_block(Class *c)
 		    " */\n");
 
 	if ( ! overrode_get_type) {
-		out_printf (outh, "GType\t%s_get_type\t(void)", funcbase);
-		if ( ! no_gnu) {
-			out_printf (outh, " G_GNUC_CONST;\n");
-		} else {
-			out_printf (outh, ";\n");
-		}
+		out_printf (outh, "GType\t%s_get_type\t(void);\n", funcbase);
 	}
 
 	for(li = c->nodes; li != NULL; li = li->next) {
@@ -2992,10 +3389,17 @@ print_class_block(Class *c)
 			put_signal_macros (c, TRUE);
 			out_printf(outh, "#else /* __GNUC__ && !__STRICT_ANSI__ */\n");
 			put_signal_macros (c, FALSE);
-			out_printf(outh, "#endif /* __GNUC__ && !__STRICT_ANSI__ */\n\n");
+			out_printf(outh, "#endif /* __GNUC__ && !__STRICT_ANSI__ */\n");
 		} else {
 			put_signal_macros (c, FALSE);
+			out_printf(outh, "\n");
 		}
+
+		out_printf (out, "\n/*\n"
+			    " * Signal connection wrapper macro shortcuts\n"
+			    " */\n");
+		put_local_signal_macros (c);
+		out_printf(outh, "\n");
 	}
 
 	/* argument wrapping macros */
@@ -3022,14 +3426,7 @@ print_class_block(Class *c)
 		}
 	}
 
-	add_enums(c);
-
-	if ( ! overrode_get_type) {
-		if (c->bonobo_x_class != NULL)
-			add_bonobo_x_get_type ();
-		else
-			add_get_type ();
-	}
+	add_enums (c);
 
 	if(any_method_to_alias(c)) {
 		if( ! no_gnu) {
@@ -3041,6 +3438,15 @@ print_class_block(Class *c)
 		make_method_nongnu_aliases(c);
 	}
 
+	add_interface_inits (c);
+
+	if ( ! overrode_get_type) {
+		if (c->bonobo_object_class != NULL)
+			add_bonobo_object_get_type ();
+		else
+			add_get_type ();
+	}
+
 	out_printf (out, "/* a macro for creating a new object of our type */\n");
 	out_printf (out,
 		    "#define GET_NEW ((%s *)g_object_new(%s_get_type(), NULL))\n\n",
@@ -3061,8 +3467,8 @@ print_class_block(Class *c)
 		    no_gnu ? "" : " G_GNUC_UNUSED",
 		    typebase, typebase, typebase, funcbase);
 
-	if (need_shutdown)
-		add_shutdown (c);
+	if (need_dispose)
+		add_dispose (c);
 
 	if (need_finalize)
 		add_finalize (c);
@@ -3103,6 +3509,23 @@ print_useful_macros(void)
 	out_printf (out, "#define selfp (self->_priv)\n\n");
 }
 
+static void
+print_more_useful_macros (void)
+{
+	if (no_gnu) {
+		out_printf (out, "#define ___GOB_LIKELY(expr) (expr)\n");
+		out_printf (out, "#define ___GOB_UNLIKELY(expr) (expr)\n");
+	} else {
+		out_printf (out, "#ifdef G_LIKELY\n");
+		out_printf (out, "#define ___GOB_LIKELY(expr) G_LIKELY(expr)\n");
+		out_printf (out, "#define ___GOB_UNLIKELY(expr) G_UNLIKELY(expr)\n");
+		out_printf (out, "#else /* ! G_LIKELY */\n");
+		out_printf (out, "#define ___GOB_LIKELY(expr) (expr)\n");
+		out_printf (out, "#define ___GOB_UNLIKELY(expr) (expr)\n");
+		out_printf (out, "#endif /* G_LIKELY */\n");
+	}
+}
+
 static void
 print_file_comments(void)
 {
@@ -3168,7 +3591,7 @@ print_header_prefixes(void)
 	char *p;
 
 	p = replace_sep(((Class *)class)->otype, '_');
-	g_strup(p);
+	gob_strup (p);
 	out_printf(outh, "#ifndef __%s_H__\n#define __%s_H__\n\n", p, p);
 	if(outph)
 		out_printf(outph, "#ifndef __%s_PRIVATE_H__\n"
@@ -3226,24 +3649,231 @@ print_header_top(void)
 	GList *li;
 
 	/* mandatory includes */
-	out_printf(outh, "#include <glib.h>\n");
-	out_printf(outh, "#include <gobject/gobject.h>\n");
-	out_printf(outh, "#include <gobject/gvaluetypes.h>\n");
-	out_printf(outh, "#include <gobject/genums.h>\n");
-	out_printf(outh, "#include <gobject/gboxed.h>\n");
-	out_printf(outh, "#include <gobject/gparamspecs.h>\n\n");
+	out_printf (outh, "#include <glib.h>\n");
+	out_printf (outh, "#include <glib-object.h>\n");
 
 	/* print the HT_CCODE blocks */
 	for (li = nodes; li != NULL; li = li->next) {
 		Node *node = li->data;
-		if(node->type == CCODE_NODE) {
+		if (node->type == CCODE_NODE) {
 			CCode *cc = (CCode *)node;
-			if(cc->cctype == HT_CCODE)
-				print_ccode_block((CCode *)node);
+			if (cc->cctype == HT_CCODE)
+				print_ccode_block ((CCode *)node);
 		}
 	}
 }
 
+static void
+print_enum (EnumDef *enode)
+{
+	GList *li;
+	char *funcprefix;
+	char *type;
+	char *str;
+
+	funcprefix = replace_sep (enode->etype, '_');
+	gob_strdown (funcprefix);
+	out_printf (out, "static const GEnumValue _%s_values[] = {\n",
+		    funcprefix);
+	type = remove_sep (enode->etype);
+
+	out_printf (outh, "\ntypedef enum {\n");
+
+	for (li = enode->values; li != NULL; li = li->next) {
+		EnumValue *value = li->data; 
+		char *p;
+		char *sname = gob_strdown (g_strdup (value->name));
+
+		while ((p = strchr (sname, '_')) != NULL)
+			*p = '-';
+
+		out_printf (outh, "\t%s_%s", enode->prefix, value->name);
+		if (value->value != NULL)
+			out_printf (outh, " = %s", value->value);
+		if (li->next != NULL)
+			out_printf (outh, ",\n");
+		else
+			out_printf (outh, "\n");
+
+		out_printf (out, "\t{ %s_%s, \"%s_%s\", \"%s\" },\n",
+			    enode->prefix, value->name,
+			    enode->prefix, value->name,
+			    sname);
+
+		g_free (sname);
+	}
+
+	out_printf (out, "\t{ 0, NULL, NULL }\n};\n\n");
+
+	out_printf (outh, "} %s;\n", type);
+
+	str = make_pre_macro (enode->etype, "TYPE");
+	out_printf (outh, "#define %s ", str);
+	g_free (str);
+
+	out_printf (outh, "%s_get_type()\n", funcprefix);
+	out_printf (outh, "GType %s_get_type (void);\n\n", funcprefix);
+
+	out_printf (out,
+		    "GType\n%s_get_type (void)\n"
+		    "{\n"
+		    "\tstatic GType type = 0;\n"
+		    "\tif ___GOB_UNLIKELY(type == 0)\n"
+		    "\t\ttype = g_enum_register_static (\"%s\", _%s_values);\n"
+		    "\treturn type;\n"
+		    "}\n\n",
+		    funcprefix, type, funcprefix);
+
+	g_free (funcprefix);
+	g_free (type);
+}
+
+static void
+print_flags (Flags *fnode)
+{
+	GList *li;
+	char *funcprefix;
+	char *type;
+	char *str;
+	int i;
+
+	funcprefix = replace_sep (fnode->ftype, '_');
+	gob_strdown (funcprefix);
+	out_printf (out, "static const GFlagsValue _%s_values[] = {\n",
+		    funcprefix);
+	type = remove_sep (fnode->ftype);
+
+	out_printf (outh, "\ntypedef enum {\n");
+
+	for (i = 0, li = fnode->values; li != NULL; i++, li = li->next) {
+		const char *name = li->data; 
+		char *p;
+		char *sname = gob_strdown (g_strdup (name));
+
+		while ((p = strchr (sname, '_')) != NULL)
+			*p = '-';
+
+		out_printf (outh, "\t%s_%s = 1<<%d",
+			    fnode->prefix, name, i);
+		if (li->next != NULL)
+			out_printf (outh, ",\n");
+		else
+			out_printf (outh, "\n");
+
+		out_printf (out, "\t{ %s_%s, \"%s_%s\", \"%s\" },\n",
+			    fnode->prefix, name,
+			    fnode->prefix, name,
+			    sname);
+
+		g_free (sname);
+	}
+
+	out_printf (out, "\t{ 0, NULL, NULL }\n};\n\n");
+
+	out_printf (outh, "} %s;\n", type);
+
+	str = make_pre_macro (fnode->ftype, "TYPE");
+	out_printf (outh, "#define %s ", str);
+	g_free (str);
+
+	out_printf (outh, "%s_get_type()\n", funcprefix);
+	out_printf (outh, "GType %s_get_type (void);\n\n", funcprefix);
+
+	out_printf (out,
+		    "GType\n%s_get_type (void)\n"
+		    "{\n"
+		    "\tstatic GType type = 0;\n"
+		    "\tif ___GOB_UNLIKELY(type == 0)\n"
+		    "\t\ttype = g_flags_register_static (\"%s\", _%s_values);\n"
+		    "\treturn type;\n"
+		    "}\n\n",
+		    funcprefix, type, funcprefix);
+
+	g_free (funcprefix);
+	g_free (type);
+}
+
+static void
+print_error (Error *enode)
+{
+	GList *li;
+	char *funcprefix;
+	char *type;
+	char *str;
+
+	funcprefix = replace_sep (enode->etype, '_');
+	gob_strdown (funcprefix);
+	out_printf (out, "static const GEnumValue _%s_values[] = {\n",
+		    funcprefix);
+	type = remove_sep (enode->etype);
+
+	out_printf (outh, "\ntypedef enum {\n");
+
+	for (li = enode->values; li != NULL; li = li->next) {
+		const char *name = li->data;
+		char *p;
+		char *sname = gob_strdown (g_strdup (name));
+
+		while ((p = strchr (sname, '_')) != NULL)
+			*p = '-';
+
+		out_printf (outh, "\t%s_%s", enode->prefix, name);
+		if (li->next != NULL)
+			out_printf (outh, ",\n");
+		else
+			out_printf (outh, "\n");
+
+		out_printf (out, "\t{ %s_%s, \"%s_%s\", \"%s\" },\n",
+			    enode->prefix, name,
+			    enode->prefix, name,
+			    sname);
+
+		g_free (sname);
+	}
+
+	out_printf (out, "\t{ 0, NULL, NULL }\n};\n\n");
+
+	out_printf (outh, "} %s;\n", type);
+
+	str = make_pre_macro (enode->etype, "TYPE");
+	out_printf (outh, "#define %s ", str);
+	g_free (str);
+
+	out_printf (outh, "%s_get_type ()\n", funcprefix);
+	out_printf (outh, "GType %s_get_type (void);\n\n", funcprefix);
+
+	out_printf (out,
+		    "GType\n%s_get_type (void)\n"
+		    "{\n"
+		    "\tstatic GType type = 0;\n"
+		    "\tif ___GOB_UNLIKELY(type == 0)\n"
+		    "\t\ttype = g_enum_register_static (\"%s\", _%s_values);\n"
+		    "\treturn type;\n"
+		    "}\n\n",
+		    funcprefix, type, funcprefix);
+
+	out_printf (outh, "#define %s %s_quark ()\n", enode->prefix, funcprefix);
+	out_printf (outh, "GQuark %s_quark (void);\n\n", funcprefix);
+
+	str = replace_sep (enode->etype, '-');
+	gob_strdown (str);
+
+	out_printf (out,
+		    "GQuark\n%s_quark (void)\n"
+		    "{\n"
+		    "\tstatic GQuark q = 0;\n"
+		    "\tif (q == 0)\n"
+		    "\t\tq = g_quark_from_static_string (\"%s\");\n"
+		    "\treturn q;\n"
+		    "}\n\n",
+		    funcprefix, str);
+
+	g_free (str);
+
+	g_free (funcprefix);
+	g_free (type);
+}
+
 static void
 generate_outfiles(void)
 {
@@ -3261,17 +3891,26 @@ generate_outfiles(void)
 
 	print_includes();
 
-	for(li=nodes;li;li=g_list_next(li)) {
+	print_more_useful_macros ();
+
+	for (li = nodes; li != NULL; li = li->next) {
 		Node *node = li->data;
-		if(node->type == CCODE_NODE) {
+		if (node->type == CCODE_NODE) {
 			CCode *cc = (CCode *)node;
-			if(cc->cctype != HT_CCODE &&
-			   cc->cctype != AT_CCODE)
-				print_ccode_block((CCode *)node);
-		} else if(node->type == CLASS_NODE) {
-			print_class_block((Class *)node);
-		} else
+			if (cc->cctype != HT_CCODE &&
+			    cc->cctype != AT_CCODE)
+				print_ccode_block ((CCode *)node);
+		} else if (node->type == CLASS_NODE) {
+			print_class_block ((Class *)node);
+		} else if (node->type == ENUMDEF_NODE) {
+			print_enum ((EnumDef *)node);
+		} else if (node->type == FLAGS_NODE) {
+			print_flags ((Flags *)node);
+		} else if (node->type == ERROR_NODE) {
+			print_error ((Error *)node);
+		} else {
 			g_assert_not_reached();
+		}
 	}
 
 	print_header_postfixes();
@@ -3306,6 +3945,12 @@ print_help(void)
 		"\t--always-private-struct Always create a private pointer "
 					  "in\n"
 		"\t                        the object structure\n"
+		"\t--m4                    Preprocess source with m4. "
+					  "Following args will\n"
+		"\t                        be passed to m4\n"
+		"\t--m4-dir                Print directory that will be "
+					  "searched for m4\n"
+		"\t                        files\n"
 		"\t--no-write,-n           Don't write output files, just "
 					  "check syntax\n"
 		"\t--no-lines              Don't print '#line' to output\n"
@@ -3320,11 +3965,43 @@ parse_options(int argc, char *argv[])
 	int i;
 	int got_file = FALSE;
 	int no_opts = FALSE;
+	int m4_opts = FALSE; /* if we are just passing on args to m4 */
 
 	filename = NULL;
 
 	for(i = 1 ; i < argc; i++) {
-		if(no_opts ||
+		if(m4_opts) {
+			char *new_commandline;
+			g_assert(m4_commandline!=NULL);
+
+			/* check whether this one looks like the filename */
+			if((!strcmp(argv[i],"-") || argv[i][0] != '-') 
+			   && !got_file) {
+			        const gchar *m4_flags=use_m4_clean?"":M4_FLAGS;
+				filename = argv[i];
+				got_file = TRUE;
+				
+				/* insert flags before the filename */
+				new_commandline=g_strconcat(m4_commandline,
+							    " ",
+							    m4_flags, 
+							    " ",
+							    argv[i],
+							    NULL);
+			}
+
+			/* just an ordinary option */
+			else			  
+			  new_commandline=g_strconcat(m4_commandline,
+						      " ",
+						      argv[i],
+						      NULL);
+
+			/* free old commandline */
+			g_free(m4_commandline);
+			m4_commandline=new_commandline;
+
+		} else if(no_opts ||
 		   argv[i][0] != '-') {
 			/*must be a file*/
 			if(got_file) {
@@ -3368,6 +4045,19 @@ parse_options(int argc, char *argv[])
 			/* no op */;
 		} else if(strcmp(argv[i], "--always-private-struct")==0) {
 			always_private_struct = TRUE;
+		} else if(strcmp(argv[i], "--m4-dir")==0) {
+			printf("%s\n",M4_INCLUDE_DIR);
+			exit(0);
+		} else if(strcmp(argv[i], "--m4")==0) {
+			use_m4 = TRUE;
+			use_m4_clean=FALSE;
+			m4_opts = TRUE;
+			m4_commandline=g_strdup(M4_COMMANDLINE);
+		} else if(strcmp(argv[i], "--m4-clean")==0) {
+			use_m4 = TRUE;
+			use_m4_clean=TRUE;
+			m4_opts = TRUE;
+			m4_commandline=g_strdup(M4_COMMANDLINE);
 		} else if(strcmp(argv[i], "--")==0) {
 			/*further arguments are files*/
 			no_opts = TRUE;
@@ -3401,6 +4091,19 @@ parse_options(int argc, char *argv[])
 			}
 		}
 	}
+
+#if 0
+	/* if we are using m4, and got no filename, append m4 flags now */
+	if(!got_file && use_m4 && !use_m4_clean) {
+		char *new_commandline;
+	        new_commandline=g_strconcat(m4_commandline,
+					    " ",
+					    M4_FLAGS,
+					    NULL);
+		g_free(m4_commandline);
+		m4_commandline=new_commandline;
+	}
+#endif
 }
 
 /* this is a somewhat ugly hack, but it appears to work */
@@ -3439,23 +4142,37 @@ main(int argc, char *argv[])
 {
 	parse_options(argc, argv);
 	
-	if(filename) {
+	if(use_m4) {
+		yyin = popen(m4_commandline, "r");
+		if(!yyin) {
+			fprintf(stderr, "Error: can't open pipe from '%s'\n",
+				m4_commandline);
+			exit(1);
+		}
+	} else if(filename) {
 		yyin = fopen(filename, "r");
 		if(!yyin) {
 			fprintf(stderr, "Error: can't open file '%s'\n",
 				filename);
 			exit(1);
 		}
-	} else
+	}
+
+	if(filename==NULL)
 		filename = "stdin";
 
 	/* This is where parsing is done */
 	/*yydebug = 1;*/
 	if(yyparse() != 0)
-		g_error("Parsing errors, quitting");
+		error_print (GOB_ERROR, 0, "Parsing errors, quitting");
+
+	/* close input file */
+	if(use_m4) pclose(yyin);
+	else fclose(yyin);
+	yyin=stdin;
 
 	if( ! class)
-		error_print(GOB_ERROR, 0, " no class defined");
+		error_print (GOB_ERROR, 0, "no class defined");
 	
 
 	exit_on_error = FALSE;
@@ -3476,8 +4193,8 @@ main(int argc, char *argv[])
 	make_bases ();
 	make_inits ((Class *)class);
 	if(unreftors > 0) {
-		need_shutdown = TRUE;
-		find_shutdown ((Class *)class);
+		need_dispose = TRUE;
+		find_dispose ((Class *)class);
 	}
 	if (destructors > 0 ||
 	    privates > 0) {
@@ -3496,6 +4213,7 @@ main(int argc, char *argv[])
 	check_property_types ((Class *)class);
 	check_argument_types ((Class *)class);
 	check_func_arg_checks ((Class *)class);
+	check_for_class_destructors ((Class *)class);
 
 	exit_on_error = TRUE;