X-Git-Url: http://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/7231d76fbf4ae0b501af648e1216b88714aa7353..69c350c69e70bddb040dfc5d90b0368376a6389e:/src/main.c

diff --git a/src/main.c b/src/main.c
index fe74942..3909cb0 100644
--- a/src/main.c
+++ b/src/main.c
@@ -46,6 +46,7 @@ extern int yydebug;
 extern FILE * yyin;
 extern Node *class;
 extern GList *nodes;
+extern GList *enums;
 
 extern GList *include_files;
 
@@ -105,6 +106,14 @@ 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
@@ -424,29 +433,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 +508,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)
@@ -511,16 +593,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 +610,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 +646,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 +662,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);
@@ -873,6 +959,118 @@ 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)
 {
@@ -894,10 +1092,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 +1119,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 (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"
@@ -1693,6 +1913,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 +1928,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
@@ -1891,7 +2110,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 +2122,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 +2131,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);
 		}
 	}
@@ -2032,8 +2251,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;
@@ -2116,7 +2335,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"
@@ -2328,11 +2547,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,9 +2570,20 @@ 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);
+
+		set_func = g_strdup_printf ("g_value_set%s_%s",
+					    do_static ? "_static" : "",
+					    (char *)ali->data);
+		g_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);
 	}
 }
@@ -2403,39 +2643,88 @@ 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);
-			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");
+		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);
+
+				set_func = g_strdup_printf ("g_value_set%s_%s",
+							    do_static ? "_static" : "",
+							    (char *)m->gtktypes->data);
+				g_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);
+		g_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);
+
+		if (strcmp (m->gtktypes->data, "NONE") != 0) {
+			char *cast = g_strdup (get_cast (m->gtktypes->data, FALSE));
+			char *getfunc = g_strdup_printf ("g_value_get_%s",
+							 (char *)m->gtktypes->data);
+			g_strdown (getfunc);
+
+			if (cast == NULL)
+				cast = get_type (m->mtype, TRUE);
+
+			out_printf (out, "\n\treturn (%s) %s (&___return_val);\n",
+				    cast, getfunc);
+
+			g_free (cast);
+			g_free (getfunc);
+		}
+		out_printf(out, "}\n");
+
 		if(!m->cbuf)
 			break;
 		if(m->line_no > 0)
@@ -2932,11 +3221,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) {
@@ -2992,10 +3281,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 +3318,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 +3330,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",
@@ -3226,24 +3524,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, '_');
+	g_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 = g_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 (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, '_');
+	g_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 = g_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 (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, '_');
+	g_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 = g_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 (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, '-');
+	g_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 +3766,24 @@ generate_outfiles(void)
 
 	print_includes();
 
-	for(li=nodes;li;li=g_list_next(li)) {
+	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 +3818,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 +3838,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 +3918,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 +3964,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,14 +4015,23 @@ 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 */
@@ -3454,6 +4039,11 @@ main(int argc, char *argv[])
 	if(yyparse() != 0)
 		g_error("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");