X-Git-Url: https://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/b17287deb56775a49030d738d8c8c0e9cd15f9fe..486240dc4c5d57b0afaddba60d87fe375112bed5:/src/main.c

diff --git a/src/main.c b/src/main.c
index dedf432..691d5df 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,5 +1,6 @@
 /* GOB C Preprocessor
- * Copyright (C) 1999 the Free Software Foundation.
+ * Copyright (C) 1999,2000 the Free Software Foundation.
+ * Copyright (C) 2000 Eazel, Inc.
  *
  * Author: George Lebl
  *
@@ -28,7 +29,7 @@
 #include <stdlib.h>
 #include <sys/stat.h>
 
-#include "tree.h"
+#include "treefuncs.h"
 #include "parse.h"
 #include "out.h"
 #include "util.h"
@@ -63,11 +64,23 @@ static int arguments = 0; /* number of named arguments */
 static int overrides = 0; /* number of override methods */
 static int privates = 0; /* number of private data members */
 static int protecteds = 0; /* number of protected methods */
+static int destructors = 0; /* number of variable destructors */
+static int initializers = 0; /* number of variable initializers */
 
 static gboolean made_aliases = FALSE;  /* if we made any shorthand aliases
 					  and need the REALLY UGLY HACK to
 					  avoid warnings */
 
+/* the special variable types we need to define */
+static gboolean special_array[SPECIAL_LAST] = {0};
+static gboolean any_special = FALSE;
+
+static gboolean need_destroy = FALSE;
+static Method * destroy_handler = NULL;
+
+static gboolean need_finalize = FALSE;
+static Method * finalize_handler = NULL;
+
 FILE *out = NULL;
 FILE *outh = NULL;
 FILE *outph = NULL;
@@ -79,10 +92,15 @@ gboolean no_gnu = FALSE;
 gboolean exit_on_warn = FALSE;
 gboolean exit_on_error = TRUE;
 gboolean got_error = FALSE;
-gboolean always_private_header = FALSE;
-gboolean no_private_header = FALSE;
+gint private_header = PRIVATE_HEADER_ALWAYS;
 gboolean no_extern_c = FALSE;
 gboolean no_write = FALSE;
+gboolean no_lines = FALSE;
+gboolean no_self_alias = FALSE;
+gboolean no_kill_underscores = FALSE;
+gboolean always_private_struct = FALSE;
+
+int method_unique_id = 1;
 
 static void
 make_bases(void)
@@ -119,7 +137,6 @@ get_type(Type *t, gboolean postfix_to_stars)
 	gs = g_string_new(s);
 	g_free(s);
 
-
 	extra = 0;
 	if(postfix_to_stars) {
 		char *p;
@@ -130,11 +147,15 @@ get_type(Type *t, gboolean postfix_to_stars)
 		for(p=t->postfix; p && *p; p++)
 			if(*p == '[') extra++;
 	}
-	g_string_append_c(gs,' ');
-	
-	for(i=0; i<(t->stars+extra); i++)
-		g_string_append_c(gs, '*');
+	g_string_append_c(gs, ' ');
 
+	if(t->pointer) {
+		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;
@@ -151,13 +172,13 @@ get_gtk_doc(char *id)
 	val = g_hash_table_lookup(gtk_doc_hash, id);
 	if(val)
 		return g_strdup_printf("/**\n * %s_%s:\n%s **/\n",
-				       funcbase, id, val);
-	s = g_strconcat(funcbase, "_", id, NULL);
+				       funcbase, get_real_id(id), val);
+	s = g_strconcat(funcbase, "_", get_real_id(id), NULL);
 	val = g_hash_table_lookup(gtk_doc_hash, s);
 	g_free(s);
 	if(val)
 		return g_strdup_printf("/**\n * %s_%s:\n%s **/\n",
-				       funcbase, id, val);
+				       funcbase, get_real_id(id), val);
 	return NULL;
 }
 
@@ -177,18 +198,26 @@ print_method(FILE *fp, char *typeprefix, char *nameprefix,
 	     char *subnameprefix,
 	     char *namepostfix, char *postfix, Method *m,
 	     gboolean one_arg_per_line,
-	     gboolean no_funcbase)
+	     gboolean no_funcbase,
+	     gboolean kill_underscore)
 {
 	GList *li;
+	char *id;
 
 	out_printf(fp, "%s", typeprefix); 
 	print_type(fp, m->mtype, TRUE);
+
+	if(kill_underscore)
+		id = get_real_id(m->id);
+	else
+		id = m->id;
+
 	if(no_funcbase)
 		out_printf(fp, "%s%s%s%s(",
-			   nameprefix, subnameprefix, m->id, namepostfix); 
+			   nameprefix, subnameprefix, id, namepostfix); 
 	else
-		out_printf(fp,"%s%s_%s%s%s(",
-			   nameprefix, funcbase, subnameprefix, m->id,
+		out_printf(fp, "%s%s_%s%s%s(",
+			   nameprefix, funcbase, subnameprefix, id,
 			   namepostfix); 
 	
 	if(m->args) {
@@ -214,6 +243,27 @@ print_method(FILE *fp, char *typeprefix, char *nameprefix,
 	out_printf(fp, ")%s", postfix); 
 }
 
+static gboolean
+any_method_to_alias(Class *c)
+{
+	GList *li;
+	
+	for(li=c->nodes;li;li=g_list_next(li)) {
+		Node *node = li->data;
+		if(node->type == METHOD_NODE) {
+			Method *m = (Method *)node;
+			
+			if(m->method == INIT_METHOD ||
+			   m->method == CLASS_INIT_METHOD ||
+			   m->method == OVERRIDE_METHOD)
+				continue;
+
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
 
 static void
 make_method_gnu_aliases(Class *c)
@@ -236,10 +286,11 @@ make_method_gnu_aliases(Class *c)
 
 			out_printf(out, "static const typeof(&%s_%s) %s "
 				   "__attribute__ ((__unused__)) "
-				   "= %s_%s;\n", funcbase, m->id, m->id,
-				   funcbase, m->id);
+				   "= %s_%s;\n", funcbase, get_real_id(m->id),
+				   m->id, funcbase, get_real_id(m->id));
 			out_printf(out, "#define %s(args...) "
-				   "%s_%s(##args)\n", m->id, funcbase, m->id);
+				   "%s_%s(##args)\n", m->id,
+				   funcbase, get_real_id(m->id));
 		}
 	}
 }
@@ -264,8 +315,9 @@ make_method_nongnu_aliases(Class *c)
 				continue;
 
 			print_method(out, "static ", "(* ", "", ") ", "",
-				     m, FALSE, TRUE);
-			out_printf(out, " = %s_%s;\n", funcbase, m->id);
+				     m, FALSE, TRUE, FALSE);
+			out_printf(out, " = %s_%s;\n", funcbase,
+				   get_real_id(m->id));
 
 			made_aliases = TRUE;
 		}
@@ -282,7 +334,7 @@ add_bad_hack_to_avoid_unused_warnings(Class *c)
 		return;
 	
 	if(!no_gnu)
-		out_printf(out,"\n\n#ifndef __GNUC__\n");
+		out_printf(out, "\n\n#ifndef __GNUC__\n");
 	out_printf(out,
 		   "/*REALLY BAD HACK\n"
 		   "  This is to avoid unused warnings if you don't call\n"
@@ -291,7 +343,7 @@ add_bad_hack_to_avoid_unused_warnings(Class *c)
 		   "  extentions to make saner, faster code */\n"
 		   "static void\n"
 		   "___%s_really_bad_hack_to_avoid_warnings(void)\n"
-		   "{\n",funcbase);
+		   "{\n", funcbase);
 	for(li=c->nodes;li;li=g_list_next(li)) {
 		Node *node = li->data;
 		if(node->type == METHOD_NODE) {
@@ -303,31 +355,31 @@ add_bad_hack_to_avoid_unused_warnings(Class *c)
 				continue;
 
 			/* in C++ mode we don't alias new */
-			if(for_cpp && strcmp(m->id,"new")==0)
+			if(for_cpp && strcmp(m->id, "new")==0)
 				continue;
 
-			out_printf(out,"\t((void (*)(void))%s)();\n",m->id);
+			out_printf(out, "\t((void (*)(void))%s)();\n", m->id);
 		}
 	}
 	out_printf(out, "\t___%s_really_bad_hack_to_avoid_warnings();\n",
 		   funcbase);
 	if(!no_gnu)
-		out_printf(out,"}\n#endif /* __GNUC__ */\n\n");
+		out_printf(out, "}\n#endif /* __GNUC__ */\n\n");
 	else
-		out_printf(out,"}\n\n");
+		out_printf(out, "}\n\n");
 }
 
 static void
 put_variable(Variable *v, FILE *fp)
 {
-	out_printf(fp,"\t");
-	print_type(fp,v->vtype,FALSE);
-	out_printf(fp,"%s%s;",v->id,
+	out_printf(fp, "\t");
+	print_type(fp, v->vtype, FALSE);
+	out_printf(fp, "%s%s;", v->id,
 		   v->vtype->postfix?
 		   v->vtype->postfix:""); 
 	if(v->scope == PROTECTED_SCOPE)
-		out_printf(fp," /* protected */");
-	out_printf(fp,"\n");
+		out_printf(fp, " /* protected */");
+	out_printf(fp, "\n");
 }
 
 static void
@@ -340,10 +392,11 @@ put_vs_method(Method *m)
 
 	/* if a signal mark it as such */
 	if(m->method != VIRTUAL_METHOD)
-		print_method(outh,"\t/*signal*/","(* ","",") ",";\n",m,
-			     FALSE,TRUE);
+		print_method(outh, "\t/*signal*/", "(* ", "", ") ", ";\n",
+			     m, FALSE, TRUE, TRUE);
 	else
-		print_method(outh,"\t","(* ","",") ",";\n",m,FALSE,TRUE);
+		print_method(outh, "\t", "(* ", "", ") ", ";\n",
+			     m, FALSE, TRUE, TRUE);
 }
 
 static void
@@ -352,7 +405,7 @@ put_pub_method(Method *m)
 	if(m->scope != PUBLIC_SCOPE)
 		return;
 
-	print_method(outh,"","\t","","\t",";\n",m,TRUE,FALSE);
+	print_method(outh, "", "\t", "", "\t", ";\n", m, TRUE, FALSE, TRUE);
 }
 
 /* I'm starting not to like this idea */
@@ -400,9 +453,11 @@ put_prot_method(Method *m)
 		return;
 
 	if(outph)
-		print_method(outph,"","\t","","\t",";\n",m,FALSE,FALSE);
+		print_method(outph, "", "\t", "", "\t", ";\n",
+			     m, FALSE, FALSE, TRUE);
 	else
-		print_method(out,"","\t","","\t",";\n",m,FALSE,FALSE);
+		print_method(out, "", "\t", "", "\t", ";\n",
+			     m, FALSE, FALSE, TRUE);
 }
 
 static void
@@ -414,17 +469,25 @@ put_priv_method_prot(Method *m)
 		if(m->cbuf)
 			print_method(out,
 				     "static ", "___real_", "", " ", ";\n",
-				     m, FALSE, FALSE);
+				     m, FALSE, FALSE, TRUE);
 	}
-
-	if(m->scope == PRIVATE_SCOPE ||
+	/* no else, here, it might still have a private prototype, it's not
+	 * exclusive */
+
+	if((m->method == OVERRIDE_METHOD &&
+	    m->cbuf)) {
+		/* add unique ID */
+		char *s = g_strdup_printf("___%x_", (guint)m->unique_id);
+		print_method(out, "static ", s, "", " ",
+			     no_gnu?";\n":" G_GNUC_UNUSED;\n",
+			     m, FALSE, FALSE, FALSE);
+		g_free(s);
+	} else if(m->scope == PRIVATE_SCOPE ||
 	   m->method == INIT_METHOD ||
-	   m->method == CLASS_INIT_METHOD ||
-	   (m->method == OVERRIDE_METHOD &&
-	    m->cbuf))
+	   m->method == CLASS_INIT_METHOD)
 		print_method(out, "static ", "", "", " ",
 			     no_gnu?";\n":" G_GNUC_UNUSED;\n",
-			     m, FALSE, FALSE);
+			     m, FALSE, FALSE, TRUE);
 }
 
 static GList *
@@ -435,12 +498,12 @@ make_func_arg(char *typename, int is_class, char *name)
 	char *tn;
 	
 	if(is_class)
-		tn = g_strconcat(typename,":Class",NULL);
+		tn = g_strconcat(typename, ":Class", NULL);
 	else
 		tn = g_strdup(typename);
 
-	type = new_type(1,tn,NULL);
-	node = new_funcarg((Type *)type,name,NULL);
+	type = new_type(tn, g_strdup("*"), NULL);
+	node = new_funcarg((Type *)type, name, NULL);
 	return g_list_prepend(NULL, node);
 }
 
@@ -457,66 +520,100 @@ make_inits(Class *cl)
 			Method *m = (Method *)n;
 			if(m->method == INIT_METHOD) {
 				if(got_init)
-					print_error(FALSE,"init defined more then once",m->line_no);
+					print_error(FALSE, "init defined more then once", m->line_no);
 				got_init = TRUE;
 			} else if(m->method == CLASS_INIT_METHOD) {
 				if(got_class_init)
-					print_error(FALSE,"class_init defined more then once",m->line_no);
+					print_error(FALSE, "class_init defined more then once", m->line_no);
 				got_class_init = TRUE;
 			}
 		}
 	}
 	if(!got_class_init) {
 		node = new_method(NO_SCOPE, CLASS_INIT_METHOD,
-				  (Type *)new_type(0, g_strdup("void"),NULL),
+				  (Type *)new_type(g_strdup("void"),
+						   NULL, NULL),
 				  NULL, NULL, NULL, g_strdup("class_init"),
 				  make_func_arg(cl->otype, TRUE, g_strdup("c")),
-				  NULL, NULL, 0, 0, FALSE);
-		cl->nodes = g_list_prepend(cl->nodes,node);
+				  NULL, NULL, NULL, 0, 0, FALSE,
+				  method_unique_id++);
+		cl->nodes = g_list_prepend(cl->nodes, node);
 	}
 	if(!got_init) {
 		node = new_method(NO_SCOPE, INIT_METHOD,
-				  (Type *)new_type(0, g_strdup("void"),NULL),
+				  (Type *)new_type(g_strdup("void"),
+						   NULL, NULL),
 				  NULL, NULL, NULL, g_strdup("init"),
 				  make_func_arg(cl->otype, FALSE, g_strdup("o")),
-				  NULL, NULL, 0, 0, FALSE);
-		cl->nodes = g_list_prepend(cl->nodes,node);
+				  NULL, NULL, NULL, 0, 0, FALSE,
+				  method_unique_id++);
+		cl->nodes = g_list_prepend(cl->nodes, node);
 	}
 }
 
 static void
-make_finalize(Class *cl)
+find_destroy(Class *cl)
 {
-	int got_finalize = FALSE;
 	GList *li;
-	Node *node;
+
+	destroy_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, "finalize")==0) {
-				if(strcmp(m->otype, "Gtk:Object")==0) {
-					got_finalize = TRUE;
-					break;
+			   strcmp(m->id, "destroy")==0) {
+				if(strcmp(m->otype, "Gtk:Object") != 0) {
+					print_error(FALSE,
+						    "destroy method override "
+						    "of class other then "
+						    "Gtk:Object",
+						    m->line_no);
+				}
+				if(g_list_length(m->args) != 1) {
+					print_error(FALSE,
+						    "destroy method override "
+						    "with more then one "
+						    "parameter",
+						    m->line_no);
 				}
-				print_error(FALSE,"finalize method override "
-					    "of class other then Gtk:Object",
-					    m->line_no);
+				destroy_handler = m;
+				break;
 			}
 		}
 	}
-	if(!got_finalize) {
-		node = new_method(NO_SCOPE, OVERRIDE_METHOD,
-				  (Type *)new_type(0,g_strdup("void"),NULL),
-				  g_strdup("Gtk:Object"),
-				  NULL, NULL, g_strdup("finalize"),
-				  make_func_arg("Gtk:Object",FALSE,g_strdup("o")),
-				  NULL,
-				  g_strdup("PARENT_HANDLER (o);\n"),
-				  0,0,FALSE);
-		cl->nodes = g_list_append(cl->nodes,node);
-		overrides++;
+}
+
+static void
+find_finalize(Class *cl)
+{
+	GList *li;
+
+	finalize_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, "finalize")==0) {
+				if(strcmp(m->otype, "Gtk:Object") != 0) {
+					print_error(FALSE,
+						    "finalize method override "
+						    "of class other then "
+						    "Gtk:Object",
+						    m->line_no);
+				}
+				if(g_list_length(m->args) != 1) {
+					print_error(FALSE,
+						    "finalize method override "
+						    "with more then one "
+						    "parameter",
+						    m->line_no);
+				}
+				finalize_handler = m;
+				break;
+			}
+		}
 	}
 }
 
@@ -534,7 +631,7 @@ static gboolean
 is_list_equal(GList *a, GList *b)
 {
 	for(;a && b; a=a->next, b=b->next) {
-		if(strcmp(a->data,b->data)!=0) {
+		if(strcmp(a->data, b->data)!=0) {
 			return FALSE;
 		}
 	}
@@ -550,7 +647,7 @@ find_same_type_signal(Method *m)
 	GList *li;
 	for(li=eq_signal_methods;li;li=li->next) {
 		Method *mm = li->data;
-		if(is_list_equal(mm->gtktypes,m->gtktypes))
+		if(is_list_equal(mm->gtktypes, m->gtktypes))
 			return mm;
 	}
 	return NULL;
@@ -559,19 +656,19 @@ find_same_type_signal(Method *m)
 static void
 print_signal_marsal_args(Method *m)
 {
-	if(strcmp(m->gtktypes->next->data,"NONE")!=0) {
+	if(strcmp(m->gtktypes->next->data, "NONE")!=0) {
 		GList *li;
 		int i;
-		for(i=0,li=m->gtktypes->next;li;
-		    i++,li=g_list_next(li)) {
+		for(i=0, li=m->gtktypes->next;li;
+		    i++, li=g_list_next(li)) {
 			if(!for_cpp)
 				out_printf(out, ",\n\t\tGTK_VALUE_%s(args[%d])",
-					   (char *)li->data,i);
+					   (char *)li->data, i);
 			else {
 				out_printf(out, ",\n\t\t(%s)"
 					   "GTK_VALUE_%s(args[%d])",
-					   get_cast(li->data,FALSE),
-					   (char *)li->data,i);
+					   get_cast(li->data, FALSE),
+					   (char *)li->data, i);
 			}
 		}
 	}
@@ -592,53 +689,56 @@ add_signal_prots(Method *m)
 		return;
 
 	if(!marsh)
-		marsh = g_hash_table_new(NULL,NULL);
+		marsh = g_hash_table_new(NULL, NULL);
 	
-	if(strcmp(m->gtktypes->data,"NONE")==0 &&
-	   strcmp(m->gtktypes->next->data,"NONE")==0)
+	if(strcmp(m->gtktypes->data, "NONE")==0 &&
+	   strcmp(m->gtktypes->next->data, "NONE")==0)
 		return;
 
 	/* if we already did a signal prototype just use that */
 	mm = find_same_type_signal(m);
 	if(mm) {
-		s = g_hash_table_lookup(marsh,mm);
-		g_hash_table_insert(marsh,m,s);
+		s = g_hash_table_lookup(marsh, mm);
+		g_hash_table_insert(marsh, m, s);
 		return;
 	}
 	
-	s = g_strdup_printf("Sig%d",sig++);
+	s = g_strdup_printf("Sig%d", sig++);
 	
-	g_hash_table_insert(marsh,m,s);
-	eq_signal_methods = g_list_prepend(eq_signal_methods,m);
+	g_hash_table_insert(marsh, m, s);
+	eq_signal_methods = g_list_prepend(eq_signal_methods, m);
 	
 	/* we know that we'll know all the gtktypes (so get_cast can't fail) */
-	out_printf(out,"\ntypedef %s (*___%s) (%s *, ",
-		   get_cast(m->gtktypes->data,FALSE),s, typebase);
+	out_printf(out, "\ntypedef %s (*___%s) (%s *, ",
+		   get_cast(m->gtktypes->data, FALSE), s, typebase);
 	
-	for(li=m->gtktypes->next;li;li=g_list_next(li))
-		out_printf(out,"%s, ",get_cast(li->data,FALSE));
-	out_printf(out,"gpointer);\n"); 
+	if(strcmp(m->gtktypes->next->data, "NONE")!=0) {
+		for(li=m->gtktypes->next; li; li=g_list_next(li))
+			out_printf(out, "%s, ", get_cast(li->data, FALSE));
+	}
+	out_printf(out, "gpointer);\n"); 
 	
-	out_printf(out,"\nstatic void\n"
+	out_printf(out, "\nstatic void\n"
 		"___marshal_%s (GtkObject * object,\n"
 		"\tGtkSignalFunc func,\n"
 		"\tgpointer func_data,\n"
 		"\tGtkArg * args)\n"
-		"{\n",s);
+		"{\n", s);
 	
-	if(strcmp(m->gtktypes->data,"NONE")==0) {
+	if(strcmp(m->gtktypes->data, "NONE")==0) {
 		out_printf(out, "\t___%s rfunc;\n\n"
 			"\trfunc = (___%s)func;\n\n"
-			"\t(*rfunc)((%s *)object",s,s,typebase);
+			"\t(*rfunc)((%s *)object", s, s, typebase);
 	} else {
-		out_printf(out, "\t___%s rfunc;\n\t",s);
-		print_type(out,m->mtype,TRUE);
-		out_printf(out, " *retval;\n\n"
-			"\trfunc = (___%s)func;\n\n"
-			"\tretval = GTK_RETLOC_%s(args[%d]);\n\n"
-			"\t*retval = (*rfunc)((%s *)object",
-			s,(char *)m->gtktypes->data,
-			g_list_length(m->gtktypes)-1,typebase);
+		const char *retcast = get_cast(m->gtktypes->data, FALSE);
+		out_printf(out,
+			   "\t___%s rfunc;\n\t"
+			   "%s *retval;\n\n"
+			   "\trfunc = (___%s)func;\n\n"
+			   "\tretval = GTK_RETLOC_%s(args[%d]);\n\n"
+			   "\t*retval = (*rfunc)((%s *)object",
+			   s, retcast, s, (char *)m->gtktypes->data,
+			   g_list_length(m->gtktypes)-1, typebase);
 	}
 	print_signal_marsal_args(m);
 
@@ -648,33 +748,33 @@ static void
 add_enums(Class *c)
 {
 	GList *li;
-	out_printf(out,"\n");
+	out_printf(out, "\n");
 	if(signals>0) {
-		out_printf(out,"enum {\n");
+		out_printf(out, "enum {\n");
 		for(li=c->nodes;li;li=g_list_next(li)) {
 			Node *n = li->data;
 			if(n->type == METHOD_NODE) {
 				Method *m = (Method *)n;
 				if(m->method == SIGNAL_LAST_METHOD ||
 				   m->method == SIGNAL_FIRST_METHOD) {
-					char *s = g_strdup(m->id);
+					char *s = g_strdup(get_real_id(m->id));
 					g_strup(s);
-					out_printf(out,"\t%s_SIGNAL,\n",s);
+					out_printf(out, "\t%s_SIGNAL,\n", s);
 					g_free(s);
 				}
 			}
 		}
-		out_printf(out,"\tLAST_SIGNAL\n};\n\n");
+		out_printf(out, "\tLAST_SIGNAL\n};\n\n");
 	}
 	if(arguments>0) {
-		out_printf(out,"enum {\n\tARG_0");
+		out_printf(out, "enum {\n\tARG_0");
 		for(li=c->nodes;li;li=g_list_next(li)) {
 			Node *n = li->data;
 			if(n->type == ARGUMENT_NODE) {
 				Argument *a = (Argument *)n;
 				char *s = g_strdup(a->name);
 				g_strup(s);
-				out_printf(out,",\n\tARG_%s",s);
+				out_printf(out, ",\n\tARG_%s", s);
 				g_free(s);
 			}
 		}
@@ -685,12 +785,15 @@ add_enums(Class *c)
 		out_printf(out,
 			   "static guint object_signals[LAST_SIGNAL] = {0};\n\n");
 
-	out_printf(out, "static %sClass *parent_class = NULL;\n\n",ptypebase);
+	out_printf(out, "/* pointer to the class of our parent */\n");
+	out_printf(out, "static %sClass *parent_class = NULL;\n\n", ptypebase);
 }
 
 static void
 add_get_type(void)
 {
+	char *chunk_size = ((Class*)class)->chunk_size;
+	
 	out_printf(out, "guint\n"
 		"%s_get_type (void)\n"
 		"{\n"
@@ -706,12 +809,18 @@ add_get_type(void)
 		"\t\t\t/* reserved_2 */ NULL,\n"
 		"\t\t\t(GtkClassInitFunc) NULL,\n"
 		"\t\t};\n\n"
-		"\t\ttype = gtk_type_unique (%s_get_type(), &info);\n"
-		"\t}\n\n"
+		"\t\ttype = gtk_type_unique (%s_get_type(), &info);\n",
+		funcbase, typebase, typebase, typebase,
+		funcbase, funcbase, pfuncbase);
+	if(chunk_size)  {
+		out_printf(out, "#if %s > 0\n"
+				"\t\tgtk_type_set_chunk_alloc(type,%s);\n"
+				"#endif\n", 
+				chunk_size,  chunk_size);
+	}
+	out_printf(out,"\t}\n\n"
 		"\treturn type;\n"
-		"}\n\n",
-		funcbase,typebase,typebase,typebase,
-		funcbase,funcbase,pfuncbase);
+		"}\n\n");
 }
 
 static void
@@ -733,24 +842,24 @@ add_overrides(Class *c, char *oname, gboolean did_gtk_obj)
 		if(n->type != METHOD_NODE ||
 		   m->method != OVERRIDE_METHOD)
 			continue;
-		
+
 		s = remove_sep(m->otype);
 		
-		if(g_hash_table_lookup(done,s)) {
+		if(g_hash_table_lookup(done, s)) {
 			g_free(s);
 			continue;
 		}
-		g_hash_table_insert(done,s,s);
+		g_hash_table_insert(done, s, s);
 
-		f = replace_sep(m->otype,'_');
+		f = replace_sep(m->otype, '_');
 		g_strdown(f);
 
-		out_printf(out,"\t%sClass *%s_class = (%sClass *)%s;\n",
-			s,f,s,oname);
+		out_printf(out, "\t%sClass *%s_class = (%sClass *)%s;\n",
+			   s, f, s, oname);
 		
 		g_free(f);
 	}
-	g_hash_table_foreach(done,(GHFunc)g_free,NULL);
+	g_hash_table_foreach(done, (GHFunc)g_free, NULL);
 	g_hash_table_destroy(done);
 }
 
@@ -783,7 +892,7 @@ make_run_signal_flags(Method *m, gboolean last)
 		char *flag = li->data;
 		int i;
 		for(i=0;flags[i];i++) {
-			if(strcmp(flags[i],flag)==0)
+			if(strcmp(flags[i], flag)==0)
 				break;
 		}
 		/* if we haven't found it in our list */
@@ -795,7 +904,7 @@ make_run_signal_flags(Method *m, gboolean last)
 			print_error(TRUE, s, m->line_no);
 			g_free(s);
 		}
-		g_string_sprintfa(gs, " | GTK_RUN_%s",flag);
+		g_string_sprintfa(gs, " | GTK_RUN_%s", flag);
 	}
 
 	{
@@ -811,7 +920,7 @@ add_signals(Class *c)
 {
 	GList *li;
 
-	out_printf(out,"\n");
+	out_printf(out, "\n");
 	for(li=c->nodes;li;li=g_list_next(li)) {
 		Node *n = li->data;
 		char *mar, *sig, *flags;
@@ -830,26 +939,27 @@ add_signals(Class *c)
 
 		if(g_hash_table_lookup(marsh, m))
 			mar = g_strconcat("___marshal_",
-					  (char *)g_hash_table_lookup(marsh,m),
+					  (char *)g_hash_table_lookup(marsh, m),
 					  NULL);
 		else
 			mar = g_strdup("gtk_signal_default_marshaller");
 		
 		is_none = (strcmp(m->gtktypes->next->data, "NONE")==0);
-		
-		sig = g_strdup(m->id);
+
+		sig = g_strdup(get_real_id(m->id));
 		g_strup(sig);
 		flags = make_run_signal_flags(m, last);
-		out_printf(out,"\tobject_signals[%s_SIGNAL] =\n"
+		out_printf(out, "\tobject_signals[%s_SIGNAL] =\n"
     			"\t\tgtk_signal_new (\"%s\",\n"
-			"\t\t\%s,\n"
+			"\t\t\t(GtkSignalRunType)(%s),\n"
 			"\t\t\tgtk_object_class->type,\n"
                     	"\t\t\tGTK_SIGNAL_OFFSET (%sClass, %s),\n"
                     	"\t\t\t%s,\n"
 		    	"\t\t\tGTK_TYPE_%s, %d",
-			sig,m->id,
+			sig, get_real_id(m->id),
 			flags,
-			typebase,m->id,mar,(char *)m->gtktypes->data,
+			typebase, get_real_id(m->id), mar,
+			(char *)m->gtktypes->data,
 			is_none?0:g_list_length(m->gtktypes->next));
 		g_free(mar);
 		g_free(sig);
@@ -858,13 +968,13 @@ add_signals(Class *c)
 		if(!is_none) {
 			GList *l;
 			for(l=m->gtktypes->next;l;l=g_list_next(l))
-				out_printf(out,",\n\t\t\tGTK_TYPE_%s",
+				out_printf(out, ",\n\t\t\tGTK_TYPE_%s",
 					(char *)l->data);
 		}
 
-		out_printf(out,");\n");
+		out_printf(out, ");\n");
 	}
-	out_printf(out,"\tgtk_object_class_add_signals (gtk_object_class,\n"
+	out_printf(out, "\tgtk_object_class_add_signals (gtk_object_class,\n"
 		"\t\tobject_signals, LAST_SIGNAL);\n\n");
 }
 
@@ -872,11 +982,13 @@ static void
 set_def_handlers(Class *c, char *oname)
 {
 	GList *li;
+	gboolean set_line = FALSE;
 
-	out_printf(out,"\n");
-	for(li=c->nodes;li;li=g_list_next(li)) {
+	out_printf(out, "\n");
+	for(li = c->nodes; li; li = g_list_next(li)) {
 		Node *n = li->data;
 		Method *m = (Method *)n;
+
 		if(n->type != METHOD_NODE ||
 		   (m->method != SIGNAL_FIRST_METHOD &&
 		    m->method != SIGNAL_LAST_METHOD &&
@@ -884,26 +996,50 @@ set_def_handlers(Class *c, char *oname)
 		    m->method != OVERRIDE_METHOD))
 			continue;
 
+		if(m->line_no > 0 && m->cbuf) {
+			out_addline_infile(out, m->line_no);
+			set_line = TRUE;
+		} else if(set_line) {
+			out_addline_outfile(out);
+			set_line = FALSE;
+		}
+
 
 		if(m->method == OVERRIDE_METHOD) {
 			char *s;
-			s = replace_sep(m->otype,'_');
+			s = replace_sep(m->otype, '_');
 			g_strdown(s);
-			if(m->cbuf)
-				out_printf(out,"\t%s_class->%s = %s_%s;\n",
-					   s,m->id,funcbase,m->id);
+
+			if(need_destroy &&
+			   destroy_handler &&
+			   strcmp(m->id, "destroy") == 0)
+				out_printf(out, "\tgtk_object_class->destroy "
+					   "= ___destroy;\n");
+			else if(need_finalize &&
+				finalize_handler &&
+				strcmp(m->id, "finalize") == 0)
+				out_printf(out, "\tgtk_object_class->finalize "
+					   "= ___finalize;\n");
+			else if(m->cbuf)
+				out_printf(out,
+					   "\t%s_class->%s = ___%x_%s_%s;\n",
+					   s, m->id, (guint)m->unique_id,
+					   funcbase, m->id);
 			else
-				out_printf(out,"\t%s_class->%s = NULL;\n",
-					   s,m->id);
+				out_printf(out, "\t%s_class->%s = NULL;\n",
+					   s, m->id);
 		} else {
 			if(m->cbuf)
-				out_printf(out,"\t%s->%s = ___real_%s_%s;\n",
-					oname,m->id,funcbase,m->id);
+				out_printf(out, "\t%s->%s = ___real_%s_%s;\n",
+					oname, get_real_id(m->id),
+					funcbase, get_real_id(m->id));
 			else
-				out_printf(out,"\t%s->%s = NULL;\n",
-					oname,m->id);
+				out_printf(out, "\t%s->%s = NULL;\n",
+					oname, get_real_id(m->id));
 		}
 	}
+	if(set_line)
+		out_addline_outfile(out);
 }
 
 static void
@@ -918,7 +1054,7 @@ make_arguments(Class *c)
 		NULL
 	};
 
-	out_printf(out,"\n");
+	out_printf(out, "\n");
 	for(li=c->nodes;li;li=g_list_next(li)) {
 		Node *n = li->data;
 		Argument *a;
@@ -940,16 +1076,16 @@ make_arguments(Class *c)
 		for(l=a->flags;l;l=g_list_next(l)) {
 			char *flag = l->data;
 			int i;
-			if(strcmp(flag,"READWRITE")==0 ||
-			   strcmp(flag,"READABLE")==0 ||
-			   strcmp(flag,"WRITABLE")==0) {
-				print_error(TRUE,"READWRITE, READABLE and "
+			if(strcmp(flag, "READWRITE")==0 ||
+			   strcmp(flag, "READABLE")==0 ||
+			   strcmp(flag, "WRITABLE")==0) {
+				print_error(TRUE, "READWRITE, READABLE and "
 					    "WRITABLE argument flags are "
-					    "set automatically",a->line_no);
+					    "set automatically", a->line_no);
 				continue;
 			}
 			for(i=0;argflags[i];i++) {
-				if(strcmp(argflags[i],flag)==0)
+				if(strcmp(argflags[i], flag)==0)
 					break;
 			}
 			/* if we haven't found it in our list */
@@ -958,21 +1094,21 @@ make_arguments(Class *c)
 				s = g_strdup_printf("Unknown flag '%s' used, "
 						    "perhaps it was misspelled",
 						    flag);
-				print_error(TRUE,s,a->line_no);
+				print_error(TRUE, s, a->line_no);
 				g_free(s);
 			}
-			g_string_sprintfa(flags, " | GTK_ARG_%s",flag);
+			g_string_sprintfa(flags, " | GTK_ARG_%s", flag);
 		}
 
 		s = g_strdup(a->name);
 		g_strup(s);
-		out_printf(out,"\tgtk_object_add_arg_type(\"%s::%s\",\n"
+		out_printf(out, "\tgtk_object_add_arg_type(\"%s::%s\",\n"
 			"\t\tGTK_TYPE_%s,\n"
 			"\t\t%s,\n"
 			"\t\tARG_%s);\n",
-			typebase,a->name,a->gtktype,flags->str,s);
+			typebase, a->name, a->gtktype, flags->str, s);
 		g_free(s);
-		g_string_free(flags,TRUE);
+		g_string_free(flags, TRUE);
 	}
 	
 	out_printf(out,
@@ -980,6 +1116,140 @@ make_arguments(Class *c)
 		   "\tgtk_object_class->get_arg = ___object_get_arg;\n");
 }
 
+static void
+print_initializer(Method *m, Variable *v)
+{
+	char *root;
+
+	if(v->initializer == NULL)
+		return;
+
+	if(v->scope == PRIVATE_SCOPE)
+		root = g_strconcat(((FuncArg *)m->args->data)->name,
+				   "->_priv", NULL);
+	else
+		root = g_strdup(((FuncArg *)m->args->data)->name);
+
+	if(v->initializer_line > 0)
+		out_addline_infile(out, v->initializer_line);
+
+	out_printf(out, "\t%s->%s = %s;\n",
+		   root, v->id, v->initializer);
+
+	if(v->initializer_line > 0)
+		out_addline_outfile(out);
+
+	g_free(root);
+}
+
+static void
+print_destructor(Variable *v)
+{
+	char *root;
+
+	if(v->destructor == NULL)
+		return;
+
+	if(v->scope == PRIVATE_SCOPE)
+		root = "self->_priv";
+	else
+		root = "self";
+
+	if(v->destructor_simple) {
+		if(v->destructor_line > 0)
+			out_addline_infile(out, v->destructor_line);
+
+		out_printf(out, "\tif(%s->%s) { "
+			   "((*(void (*)(void *))%s)) (%s->%s); "
+			   "%s->%s = NULL; }\n",
+			   root, v->id, v->destructor, root, v->id,
+			   root, v->id);
+
+		if(v->destructor_line > 0)
+			out_addline_outfile(out);
+	} else {
+		out_printf(out, "#define VAR (%s->%s)\n", root, v->id);
+		out_printf(out, "\t{\n");
+		if(v->destructor_line > 0)
+			out_addline_infile(out, v->destructor_line);
+
+		out_printf(out, "\t%s}\n", v->destructor);
+
+		if(v->destructor_line > 0)
+			out_addline_outfile(out);
+		out_printf(out, "\tmemset(&VAR, 0, sizeof(VAR));\n");
+		out_printf(out, "#undef VAR\n");
+	}
+}
+
+static void
+add_destroy(Class *c)
+{
+	out_printf(out, "\nstatic void\n"
+		   "___destroy(GtkObject *obj_self)\n"
+		   "{\n");
+
+	if(destructors > 0) {
+		out_printf(out, "\t%s *self G_GNUC_UNUSED = %s (obj_self);\n",
+			   typebase, macrobase);
+	}
+
+	if(destroy_handler) {
+		/* so we get possible bad argument warning */
+		if(destroy_handler->line_no > 0)
+			out_addline_infile(out, destroy_handler->line_no);
+		out_printf(out, "\t___%x_%s_destroy(obj_self);\n",
+			   (guint)destroy_handler->unique_id, funcbase);
+		if(destroy_handler->line_no > 0)
+			out_addline_outfile(out);
+	}
+
+	if(destructors > 0) {
+		GList *li;
+		for(li = ((Class *)class)->nodes;
+		    li != NULL;
+		    li = li->next) {
+			Node *n = li->data;
+			Variable *v = (Variable *)n;
+			if(n->type == VARIABLE_NODE &&
+			   v->scope != CLASS_SCOPE)
+				print_destructor(v);
+		}
+	}
+
+	out_printf(out, "}\n\n");
+}
+
+static void
+add_finalize(Class *c)
+{
+	out_printf(out, "\nstatic void\n"
+		   "___finalize(GtkObject *obj_self)\n"
+		   "{\n");
+
+	if(privates > 0) {
+		out_printf(out, "\t%s *self = %s (obj_self);\n",
+			   typebase, macrobase);
+	}
+
+	if(finalize_handler) {
+		/* so we get possible bad argument warning */
+		if(finalize_handler->line_no > 0)
+			out_addline_infile(out, finalize_handler->line_no);
+		out_printf(out, "\t___%x_%s_finalize(obj_self);\n",
+			   (guint)finalize_handler->unique_id, funcbase);
+		if(finalize_handler->line_no > 0)
+			out_addline_outfile(out);
+	}
+
+	if(privates > 0) {
+		out_printf(out, "\tg_free (self->_priv);\n"
+			   "\tself->_priv = NULL;\n");
+	}
+
+	out_printf(out, "}\n\n");
+}
+
 static void
 add_inits(Class *c)
 {
@@ -991,83 +1261,136 @@ add_inits(Class *c)
 			continue;
 		m = (Method *)n;
 		if(m->method == INIT_METHOD) {
-			if(m->line_no>0)
-				out_addline_infile(out,m->line_no);
+			if(m->line_no > 0)
+				out_addline_infile(out, m->line_no);
 			print_method(out, "static ", "\n", "", " ", "\n",
-				     m, FALSE, FALSE);
-			if(m->line_no>0)
+				     m, FALSE, FALSE, TRUE);
+			if(m->line_no > 0)
 				out_addline_outfile(out);
-			out_printf(out,"{\n");
-			if(privates>0) {
-				out_printf(out,"\t%s->_priv = "
-					   "g_new0 (%sPrivate,1);\n",
+			out_printf(out, "{\n"
+				   "#define __GOB_FUNCTION__ \"%s::init\"\n",
+				   c->otype);
+			if(privates > 0) {
+				out_printf(out, "\t%s->_priv = "
+					   "g_new0 (%sPrivate, 1);\n",
 					   ((FuncArg *)m->args->data)->name,
 					   typebase);
+			} else if(always_private_struct) {
+				out_printf(out, "\t%s->_priv = NULL;\n",
+					   ((FuncArg *)m->args->data)->name);
+			}
+			if(initializers > 0) {
+				GList *li;
+				for(li = ((Class *)class)->nodes;
+				    li != NULL;
+				    li = li->next) {
+					Node *n = li->data;
+					Variable *v = (Variable *)n;
+					if(n->type != VARIABLE_NODE ||
+					   v->scope == CLASS_SCOPE)
+						continue;
+					print_initializer(m, v);
+				}
 			}
 		} else if(m->method == CLASS_INIT_METHOD) {
-			if(m->line_no>0)
+			gboolean did_gtk_obj = FALSE;
+
+			if(m->line_no > 0)
 				out_addline_infile(out, m->line_no);
 			print_method(out, "static ", "\n", "", " ", "\n",
-				     m, FALSE, FALSE);
-			if(m->line_no>0)
+				     m, FALSE, FALSE, TRUE);
+			if(m->line_no > 0)
 				out_addline_outfile(out);
-			out_printf(out,"{\n");
-			if(signals>0 ||
-			   arguments>0)
+			out_printf(out, "{\n"
+				   "#define __GOB_FUNCTION__ \"%s::class_init\"\n",
+				   c->otype);
+			if(signals > 0 ||
+			   arguments > 0 ||
+			   need_destroy ||
+			   need_finalize) {
 				out_printf(out,
 					   "\tGtkObjectClass *"
 					   "gtk_object_class = "
 					   "(GtkObjectClass*) %s;\n",
 					   ((FuncArg *)m->args->data)->name);
+				did_gtk_obj = TRUE;
+			}
 
-			if(overrides>0)
+			if(overrides > 0)
 				add_overrides(c,
 					      ((FuncArg *)m->args->data)->name,
-					      (signals>0 || arguments>0));
+					      did_gtk_obj);
+
+			if(initializers > 0) {
+				GList *li;
+				for(li = ((Class *)class)->nodes;
+				    li != NULL;
+				    li = li->next) {
+					Node *n = li->data;
+					Variable *v = (Variable *)n;
+					if(n->type != VARIABLE_NODE ||
+					   v->scope != CLASS_SCOPE)
+						continue;
+					print_initializer(m, v);
+				}
+			}
 			
-			out_printf(out,"\n\tparent_class = ");
+			out_printf(out, "\n\tparent_class = ");
 			if(for_cpp)
-				out_printf(out,"(%sClass *)",ptypebase);
-			out_printf(out,"gtk_type_class (%s_get_type ());\n",
+				out_printf(out, "(%sClass *)", ptypebase);
+			out_printf(out, "gtk_type_class (%s_get_type ());\n",
 				   pfuncbase);
 
-			if(signals>0)
+			if(signals > 0)
 				add_signals(c);
 
 			set_def_handlers(c, ((FuncArg *)m->args->data)->name);
+
+			/* if there are no handlers for these things, we
+			 * need to set them up here */
+			if(need_destroy && !destroy_handler)
+				out_printf(out, "\tgtk_object_class->destroy "
+					   "= ___destroy;\n");
+			if(need_finalize && !finalize_handler)
+				out_printf(out, "\tgtk_object_class->finalize "
+					   "= ___finalize;\n");
 			
-			if(arguments>0)
+			if(arguments > 0)
 				make_arguments(c);
 
 		} else
 			continue;
 
 		if(m->cbuf) {
-			out_printf(out," {\n");
-			out_addline_infile(out,m->ccode_line);
-			out_printf(out,"%s\n",m->cbuf);
+			out_printf(out, " {\n");
+			out_addline_infile(out, m->ccode_line);
+			out_printf(out, "%s\n", m->cbuf);
 			out_addline_outfile(out);
-			out_printf(out," }\n");
+			out_printf(out, " }\n");
 		} else {
-			out_printf(out,"return;\n");
+			out_printf(out, "return;\n");
 		}
-		out_printf(out,"}\n");
+		out_printf(out, "}\n"
+			   "#undef __GOB_FUNCTION__\n");
 	}
 }
 
 static void
-add_getset_arg(Class *c, int is_set)
+add_getset_arg(Class *c, gboolean is_set)
 {
 	GList *li;
-	out_printf(out,"\nstatic void\n"
-		"___object_%s_arg (GtkObject *object,\n"
-		"\tGtkArg *arg,\n"
-		"\tguint arg_id)\n"
-		"{\n"
-		"\t%s *self;\n\n"
-		"\tself = %s (object);\n\n"
-		"\tswitch (arg_id) {\n",
-		is_set?"set":"get",typebase,macrobase);
+	out_printf(out, "\nstatic void\n"
+		   "___object_%s_arg (GtkObject *object,\n"
+		   "\tGtkArg *arg,\n"
+		   "\tguint arg_id)\n"
+		   "#define __GOB_FUNCTION__ \"%s::%s_arg\"\n"
+		   "{\n"
+		   "\t%s *self;\n\n"
+		   "\tself = %s (object);\n\n"
+		   "\tswitch (arg_id) {\n",
+		   is_set ? "set" : "get",
+		   c->otype, is_set ? "set" : "get",
+		   typebase, macrobase);
 
 	for(li=c->nodes;li;li=g_list_next(li)) {
 		Node *n = li->data;
@@ -1089,18 +1412,57 @@ add_getset_arg(Class *c, int is_set)
 			continue;
 		s = g_strdup(a->name);
 		g_strup(s);
-		out_printf(out,"\tcase ARG_%s:\n"
-			"#define ARG (GTK_VALUE_%s(*arg))\n"
-			"\t\t{\n",
-			s,a->gtktype);
+		out_printf(out, "\tcase ARG_%s:\n", s);
+		if(is_set && a->atype) {
+			char *cast = get_type(a->atype, TRUE);
+			if(no_gnu || for_cpp) {
+				out_printf(out, "#define ARG "
+					   "((%s)GTK_VALUE_%s(*arg))\n",
+					   cast, a->gtktype);
+			} else {
+				out_printf(out, "#ifdef __GNUC__\n");
+				if(strcmp(a->gtktype, "OBJECT")==0) {
+					out_printf(out, "#define ARG "
+						   "({%s foo = "
+						   "GTK_VALUE_POINTER(*arg); "
+						   "foo; })\n",
+						   cast);
+				} else {
+					out_printf(out, "#define ARG "
+						   "({%s foo = "
+						   "GTK_VALUE_%s(*arg); "
+						   "foo; })\n",
+						   cast, a->gtktype);
+				}
+				out_printf(out, "#else /* __GNUC__ */\n");
+				out_printf(out, "#define ARG "
+					   "((%s)GTK_VALUE_%s(*arg))\n",
+					   cast, a->gtktype);
+				out_printf(out, "#endif /* __GNUC__ */\n\n");
+			}
+			out_printf(out, "\t\t{\n");
+			g_free(cast);
+		} else if(!is_set && strcmp(a->gtktype, "OBJECT")==0) {
+			out_printf(out,
+				   "#define ARG (GTK_VALUE_POINTER(*arg))\n"
+				   "\t\t{\n");
+		} else {
+			out_printf(out,
+				   "#define ARG (GTK_VALUE_%s(*arg))\n"
+				   "\t\t{\n",
+				   a->gtktype);
+		}
 		g_free(s);
-		out_addline_infile(out,line_no);
-		out_printf(out,"%s\n",cbuf);
-		out_addline_outfile(out);
-		out_printf(out,"\t\t}\n\t\tbreak;\n"
+		if(line_no > 0)
+			out_addline_infile(out, line_no);
+		out_printf(out, "%s\n", cbuf);
+		if(line_no > 0)
+			out_addline_outfile(out);
+		out_printf(out, "\t\t}\n\t\tbreak;\n"
 			"#undef ARG\n");
 	}
-	out_printf(out,"\tdefault:\n\t\tbreak;\n\t}\n}\n");
+	out_printf(out, "\tdefault:\n\t\tbreak;\n\t}\n}\n"
+		   "#undef __GOB_FUNCTION__\n");
 }
 
 static void
@@ -1109,59 +1471,59 @@ print_checks(Method *m, FuncArg *fa)
 	GList *li;
 	gboolean is_void;
 	gboolean checked_null = FALSE;
-	is_void = (strcmp(m->mtype->name,"void")==0 &&
-		   m->mtype->stars == 0);
+	is_void = (strcmp(m->mtype->name, "void")==0 &&
+		   m->mtype->pointer == NULL);
 	
-	for(li=fa->checks;li;li=g_list_next(li)) {
+	for(li = fa->checks; li; li = g_list_next(li)) {
 		Check *ch = li->data;
 		char *s;
 		/* point to the method prot in .gob for failed checks */
-		if(m->line_no>0)
-			out_addline_infile(out,m->line_no);
+		if(m->line_no > 0)
+			out_addline_infile(out, m->line_no);
 		if(is_void)
-			out_printf(out,"\tg_return_if_fail (");
+			out_printf(out, "\tg_return_if_fail (");
 		else
-			out_printf(out,"\tg_return_val_if_fail (");
+			out_printf(out, "\tg_return_val_if_fail (");
 		switch(ch->chtype) {
 		case NULL_CHECK:
-			out_printf(out,"%s != NULL",fa->name);
+			out_printf(out, "%s != NULL", fa->name);
 			checked_null = TRUE;
 			break;
 		case TYPE_CHECK:
-			s = make_pre_macro(fa->atype->name,"IS");
+			s = make_pre_macro(fa->atype->name, "IS");
 			if(checked_null)
-				out_printf(out,"%s (%s)",s,fa->name);
+				out_printf(out, "%s (%s)", s, fa->name);
 			else
 				/* if not check null, null may be valid */
-				out_printf(out,"!(%s) || %s (%s)",fa->name,s,
-					   fa->name);
+				out_printf(out, "!(%s) || %s (%s)", fa->name,
+					   s, fa->name);
 			g_free(s);
 			break;
 		case LT_CHECK:
-			out_printf(out,"%s < %s",fa->name,ch->number);
+			out_printf(out, "%s < %s", fa->name, ch->number);
 			break;
 		case GT_CHECK:
-			out_printf(out,"%s > %s",fa->name,ch->number);
+			out_printf(out, "%s > %s", fa->name, ch->number);
 			break;
 		case LE_CHECK:
-			out_printf(out,"%s <= %s",fa->name,ch->number);
+			out_printf(out, "%s <= %s", fa->name, ch->number);
 			break;
 		case GE_CHECK:
-			out_printf(out,"%s >= %s",fa->name,ch->number);
+			out_printf(out, "%s >= %s", fa->name, ch->number);
 			break;
 		case EQ_CHECK:
-			out_printf(out,"%s == %s",fa->name,ch->number);
+			out_printf(out, "%s == %s", fa->name, ch->number);
 			break;
 		case NE_CHECK:
-			out_printf(out,"%s != %s",fa->name,ch->number);
+			out_printf(out, "%s != %s", fa->name, ch->number);
 			break;
 		}
 		if(is_void)
-			out_printf(out,");\n");
+			out_printf(out, ");\n");
 		else {
-			out_printf(out,", (");
-			print_type(out,m->mtype,TRUE);
-			out_printf(out,")%s);\n",
+			out_printf(out, ", (");
+			print_type(out, m->mtype, TRUE);
+			out_printf(out, ")%s);\n",
 				m->onerror?m->onerror:"0");
 		}
 	}
@@ -1175,54 +1537,42 @@ print_preconditions(Method *m)
 	for(li=m->args;li;li=g_list_next(li)) {
 		FuncArg *fa = li->data;
 		if(fa->checks)
-			print_checks(m,fa);
+			print_checks(m, fa);
 	}
 	if(m->line_no>0)
 		out_addline_outfile(out);
 }
 
-/* put in code if it's needed */
-static void
-put_in_gen_code(Method *m)
-{
-	/* now we only have the freeing of the private structure */
-	if(privates>0 &&
-	   m->method == OVERRIDE_METHOD &&
-	   strcmp(m->id,"finalize")==0) {
-		out_printf(out,"\tg_free (%s (%s)->_priv);\n"
-			   "\t%s (%s)->_priv = NULL;\n",
-			   macrobase,
-			   ((FuncArg *)m->args->data)->name,
-			   macrobase,
-			   ((FuncArg *)m->args->data)->name);
-	}
-}
-
 static void
 print_method_body(Method *m, int pre)
 {
-	out_printf(out,"{\n");
+	out_printf(out, "{\n"
+		   "#define __GOB_FUNCTION__ \"%s::%s\"\n",
+		   ((Class *)class)->otype,
+		   get_real_id(m->id));
 	if(pre)
 		print_preconditions(m);
 
-	put_in_gen_code(m);
-
 	/* Note: the trailing }'s are on one line, this is so
 	   that we get the no return warning correctly and point to
 	   the correct line in the .gob file, yes this is slightly
 	   ugly in the .c file, but that is not supposed to be
 	   human readable anyway. */
 	if(m->cbuf) {
-		out_printf(out,"{\n");
+		out_printf(out, "{\n");
 		if(m->ccode_line>0)
-			out_addline_infile(out,m->ccode_line);
-		out_printf(out,"\t%s}",m->cbuf);
+			out_addline_infile(out, m->ccode_line);
+		out_printf(out, "\t%s}", m->cbuf);
 	}
 
-	out_printf(out,"}\n");
+	/* Note, there is no \n between the last } and this } so that
+	 * errors/warnings reported on the end of the body get pointed to the
+	 * right line in the .gob source */
+	out_printf(out, "}\n");
 
 	if(m->cbuf)
 		out_addline_outfile(out);
+	out_printf(out, "#undef __GOB_FUNCTION__\n");
 }
 
 static void
@@ -1230,16 +1580,16 @@ put_signal_args(Method *m)
 {
 	GList *li;
 	GList *ali;
-	for(ali = m->gtktypes->next,li=m->args->next;
+	for(ali = m->gtktypes->next, li=m->args->next;
 	    li && ali;
 	    li=li->next, ali=ali->next) {
 		FuncArg *fa = li->data;
-		const char *cast = get_cast(ali->data,FALSE);
+		const char *cast = get_cast(ali->data, FALSE);
 		/* we should have already proved before that
 		   the we know all the types */
 		g_assert(cast);
 
-		out_printf(out,",\n\t\t(%s)%s",cast,
+		out_printf(out, ",\n\t\t(%s)%s", cast,
 			   fa->name);
 	}
 }
@@ -1249,7 +1599,7 @@ get_arg_names_for_macro(Method *m)
 {
 	char *p;
 	GList *li;
-	GString *gs = g_string_new("");
+	GString *gs = g_string_new(NULL);
 	p = "";
 	for(li=m->args;li;li=g_list_next(li)) {
 		FuncArg *arg = li->data;
@@ -1257,157 +1607,182 @@ get_arg_names_for_macro(Method *m)
 		p = ",";
 	}
 	p = gs->str;
-	g_string_free(gs,FALSE);
+	g_string_free(gs, FALSE);
 	return p;
 }
 
 static void
 put_method(Method *m)
 {
-	char *s,*args,*doc;
+	char *s, *args, *doc;
 	gboolean is_void;
-	is_void = (strcmp(m->mtype->name,"void")==0 &&
-		   m->mtype->stars == 0);
-	out_printf(out,"\n");
-	doc = get_gtk_doc(m->id);
-	if(doc) {
-		out_printf(out, "%s", doc);
-		g_free(doc);
+	is_void = (strcmp(m->mtype->name, "void")==0 &&
+		   m->mtype->pointer == NULL);
+	out_printf(out, "\n");
+	if(m->method != OVERRIDE_METHOD) {
+		doc = get_gtk_doc(m->id);
+		if(doc) {
+			out_printf(out, "%s", doc);
+			g_free(doc);
+		}
 	}
 	switch(m->method) {
 	case REGULAR_METHOD:
-		if(m->line_no>0)
-			out_addline_infile(out,m->line_no);
+		if(m->line_no > 0)
+			out_addline_infile(out, m->line_no);
 		if(m->scope == PRIVATE_SCOPE)
-			print_method(out,"static ","\n",""," ","\n",
-				     m,FALSE,FALSE);
+			print_method(out, "static ", "\n", "", " ", "\n",
+				     m, FALSE, FALSE, TRUE);
 		else /* PUBLIC, PROTECTED */
 			print_method(out, "", "\n", "", " ", "\n",
-				     m, FALSE, FALSE);
-		print_method_body(m,TRUE);
+				     m, FALSE, FALSE, TRUE);
+		print_method_body(m, TRUE);
+		/* the outfile line was added above */
 		break;
 	case SIGNAL_FIRST_METHOD:
 	case SIGNAL_LAST_METHOD:
-		if(m->line_no>0)
-			out_addline_infile(out,m->line_no);
+		if(m->line_no > 0)
+			out_addline_infile(out, m->line_no);
 		if(m->scope == PRIVATE_SCOPE)
-			print_method(out,"static ","\n",""," ","\n",
-				     m,FALSE,FALSE);
+			print_method(out, "static ", "\n", "", " ", "\n",
+				     m, FALSE, FALSE, TRUE);
 		else /* PUBLIC, PROTECTED */
-			print_method(out,"","\n",""," ","\n",m,FALSE,FALSE);
+			print_method(out, "", "\n", "", " ", "\n",
+				     m, FALSE, FALSE, TRUE);
 		out_addline_outfile(out);
-		out_printf(out,"{\n");
-		s = g_strdup(m->id);
+		out_printf(out, "{\n");
+		s = g_strdup(get_real_id(m->id));
 		g_strup(s);
-		if(strcmp(m->mtype->name,"void")==0 &&
-		   m->mtype->stars==0) {
+		if(strcmp(m->mtype->name, "void") == 0 &&
+		   m->mtype->pointer == NULL) {
 			print_preconditions(m);
 			if(((FuncArg *)m->args->data)->name)
-			out_printf(out,"\tgtk_signal_emit (GTK_OBJECT (%s),\n"
+			out_printf(out, "\tgtk_signal_emit (GTK_OBJECT (%s),\n"
 				"\t\tobject_signals[%s_SIGNAL]",
-				((FuncArg *)m->args->data)->name,s);
+				((FuncArg *)m->args->data)->name, s);
 			put_signal_args(m);
-			out_printf(out,");\n}\n");
+			out_printf(out, ");\n}\n");
 		} else {
-			out_printf(out,"\t");
-			print_type(out,m->mtype,TRUE);
-			out_printf(out,"return_val;\n");
+			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,"\tgtk_signal_emit (GTK_OBJECT (%s),\n"
+			out_printf(out, "\tgtk_signal_emit (GTK_OBJECT (%s),\n"
 				"\t\tobject_signals[%s_SIGNAL]",
-				((FuncArg *)m->args->data)->name,s);
+				((FuncArg *)m->args->data)->name, s);
 			put_signal_args(m);
-			out_printf(out,",\n\t\t&return_val);\n"
+			out_printf(out, ",\n\t\t&return_val);\n"
 				"\treturn return_val;\n}\n");
 		}
 
 		if(!m->cbuf)
 			break;
-		if(m->line_no>0)
-			out_addline_infile(out,m->line_no);
-		print_method(out,"static ","\n___real_",""," ","\n",
-			     m,FALSE,FALSE);
-		print_method_body(m,FALSE);
+		if(m->line_no > 0)
+			out_addline_infile(out, m->line_no);
+		print_method(out, "static ", "\n___real_", "", " ", "\n",
+			     m, FALSE, FALSE, TRUE);
+		print_method_body(m, FALSE);
+		/* the outfile line was added above */
 		break;
 	case VIRTUAL_METHOD:
-		if(m->line_no>0)
-			out_addline_infile(out,m->line_no);
+		if(m->line_no > 0)
+			out_addline_infile(out, m->line_no);
 		if(m->scope==PRIVATE_SCOPE)
-			print_method(out,"static ","\n",""," ","\n",
-				     m,FALSE,FALSE);
+			print_method(out, "static ", "\n", "", " ", "\n",
+				     m, FALSE, FALSE, TRUE);
 		else /* PUBLIC, PROTECTED */
-			print_method(out,"","\n",""," ","\n",m,FALSE,FALSE);
+			print_method(out, "", "\n", "", " ", "\n",
+				     m, FALSE, FALSE, TRUE);
 		out_addline_outfile(out);
-		out_printf(out,"{\n"
-			"\t%sClass *klass;\n",typebase);
+		out_printf(out, "{\n"
+			"\t%sClass *klass;\n", typebase);
 		print_preconditions(m);
-		out_printf(out,"\tklass = %s_CLASS(GTK_OBJECT(%s)->klass);\n\n"
+		out_printf(out, "\tklass = %s_CLASS(GTK_OBJECT(%s)->klass);\n\n"
 			"\tif(klass->%s)\n",
-			macrobase, ((FuncArg *)m->args->data)->name, m->id);
-		if(strcmp(m->mtype->name,"void")==0 &&
-		   m->mtype->stars==0) {
+			macrobase, ((FuncArg *)m->args->data)->name,
+			get_real_id(m->id));
+		if(strcmp(m->mtype->name, "void") == 0 &&
+		   m->mtype->pointer == NULL) {
 			GList *li;
-			out_printf(out,"\t\t(*klass->%s)(%s",m->id,
+			out_printf(out, "\t\t(*klass->%s)(%s",
+				   get_real_id(m->id),
 				   ((FuncArg *)m->args->data)->name);
 			for(li=m->args->next;li;li=g_list_next(li)) {
 				FuncArg *fa = li->data;
-				out_printf(out,",%s",fa->name);
+				out_printf(out, ",%s", fa->name);
 			}
-			out_printf(out,");\n}\n");
+			out_printf(out, ");\n}\n");
 		} else {
 			GList *li;
-			out_printf(out,"\t\treturn (*klass->%s)(%s",m->id,
+			out_printf(out, "\t\treturn (*klass->%s)(%s",
+				   get_real_id(m->id),
 				   ((FuncArg *)m->args->data)->name);
 			for(li=m->args->next;li;li=g_list_next(li)) {
 				FuncArg *fa = li->data;
-				out_printf(out,",%s",fa->name);
+				out_printf(out, ",%s", fa->name);
 			}
-			out_printf(out,");\n"
+			out_printf(out, ");\n"
 				"\telse\n"
 				"\t\treturn (");
-			print_type(out,m->mtype,TRUE);
-			out_printf(out,")(%s);\n}\n",
-				m->onerror?m->onerror:"0");
+			print_type(out, m->mtype, TRUE);
+			if(m->defreturn)
+				out_printf(out, ")(%s);\n}\n", m->defreturn);
+			else if(m->onerror)
+				out_printf(out, ")(%s);\n}\n", m->onerror);
+			else
+				out_printf(out, ")(0);\n}\n");
 		}
 
 		if(!m->cbuf)
 			break;
-		if(m->line_no>0)
-			out_addline_infile(out,m->line_no);
-		print_method(out,"static ","\n___real_",""," ","\n",
-			     m,FALSE,FALSE);
-		print_method_body(m,FALSE);
+		if(m->line_no > 0)
+			out_addline_infile(out, m->line_no);
+		print_method(out, "static ", "\n___real_", "", " ", "\n",
+			     m, FALSE, FALSE, TRUE);
+		print_method_body(m, FALSE);
+		/* the outfile line was added above */
 		break;
 	case OVERRIDE_METHOD:
 		if(!m->cbuf)
 			break;
-		if(m->line_no>0)
-			out_addline_infile(out,m->line_no);
-		print_method(out,"static ","\n",""," ","\n",
-			     m,FALSE,FALSE);
-		s = replace_sep(m->otype,'_');
+		if(m->line_no > 0)
+			out_addline_infile(out, m->line_no);
+		s = g_strdup_printf("\n___%x_", (guint)m->unique_id);
+		print_method(out, "static ", s, "", " ", "\n",
+			     m, FALSE, FALSE, FALSE);
+		g_free(s);
+		out_addline_outfile(out);
+		s = replace_sep(m->otype, '_');
 		g_strup(s);
 		args = get_arg_names_for_macro(m);
 		if(is_void) {
-			out_printf(out,"#define PARENT_HANDLER(%s) \\\n"
+			out_printf(out, "#define PARENT_HANDLER(%s) \\\n"
 				   "\t{ if(%s_CLASS(parent_class)->%s) \\\n"
 				   "\t\t(* %s_CLASS(parent_class)->%s)(%s); }\n",
-				   args,s,m->id,s,m->id,args);
+				   args, s, m->id, s, m->id, args);
 		} else {
-			out_printf(out,"#define PARENT_HANDLER(%s) \\\n"
+			out_printf(out, "#define PARENT_HANDLER(%s) \\\n"
 				   "\t((%s_CLASS(parent_class)->%s)? \\\n"
 				   "\t\t(* %s_CLASS(parent_class)->%s)(%s): \\\n"
 				   "\t\t(",
-				   args,s,m->id,s,m->id,args);
-			out_printf(out,"(");
-			print_type(out,m->mtype,TRUE);
-			out_printf(out,")%s))\n",
+				   args, s, m->id, s, m->id, args);
+			out_printf(out, "(");
+			print_type(out, m->mtype, TRUE);
+			out_printf(out, ")%s))\n",
 				   m->onerror?m->onerror:"0");
 		}
 		g_free(args);
 		g_free(s);
-		print_method_body(m,TRUE);
-		out_printf(out,"#undef PARENT_HANDLER\n");
+		print_method_body(m, TRUE);
+		/* the outfile line was added above */
+		out_printf(out, "#undef PARENT_HANDLER\n");
 		break;
 	default:
 		break;
@@ -1417,47 +1792,45 @@ put_method(Method *m)
 static void
 open_files(void)
 {
-	char *outfile,*outfileh,*outfileph;
+	char *outfile, *outfileh, *outfileph;
 
 	if(!for_cpp)
-		outfile = g_strconcat(filebase,".c",NULL);
+		outfile = g_strconcat(filebase, ".c", NULL);
 	else
-		outfile = g_strconcat(filebase,".cc",NULL);
+		outfile = g_strconcat(filebase, ".cc", NULL);
 	if(no_touch_headers)
-		outfileh = g_strconcat("#gob#",filebase,".h#gob#",NULL);
+		outfileh = g_strconcat("#gob#", filebase, ".h#gob#", NULL);
 	else
-		outfileh = g_strconcat(filebase,".h",NULL);
+		outfileh = g_strconcat(filebase, ".h", NULL);
 
-	if((privates>0 || protecteds>0 || always_private_header) &&
-	   !no_private_header)
-		outfileph = g_strconcat(filebase,"-private.h",NULL);
+	if((privates > 0 || protecteds > 0 ||
+	    private_header == PRIVATE_HEADER_ALWAYS) &&
+	   private_header != PRIVATE_HEADER_NEVER)
+		outfileph = g_strconcat(filebase, "-private.h", NULL);
 	else
 		outfileph = NULL;
 
 	
 	if(no_write) {
-		devnull = fopen("/dev/null","w");
-		if(!devnull) {
-			g_error("Cannot open null device",NULL);
-		}
+		devnull = fopen("/dev/null", "w");
+		if(!devnull)
+			g_error("Cannot open null device");
 		out = devnull;
 		outh = devnull;
 		if(outfileph)
 			outph = devnull;
 	} else {
-		out = fopen(outfile,"w");
+		out = fopen(outfile, "w");
 		if(!out) {
-			g_error("Cannot open outfile: %s",outfile);
-		}
-		outh = fopen(outfileh,"w");
-		if(!outh) {
-			g_error("Cannot open outfile: %s",outfileh);
+			g_error("Cannot open outfile: %s", outfile);
 		}
+		outh = fopen(outfileh, "w");
+		if(!outh)
+			g_error("Cannot open outfile: %s", outfileh);
 		if(outfileph) {
-			outph = fopen(outfileph,"w");
-			if(!outph) {
-				g_error("Cannot open outfile: %s",outfileh);
-			}
+			outph = fopen(outfileph, "w");
+			if(!outph)
+				g_error("Cannot open outfile: %s", outfileh);
 		}
 	}
 }
@@ -1473,38 +1846,41 @@ put_argument_nongnu_wrappers(Class *c)
 	for(li=c->nodes;li;li=g_list_next(li)) {
 		Node *n = li->data;
 		Argument *a = (Argument *)n;
-		char *s;
+		char *aname;
 		char *cast;
+
 		if(n->type != ARGUMENT_NODE)
 			continue;
-		s = g_strdup(a->name);
-		g_strup(s);
+
+		aname = g_strdup(a->name);
+		g_strup(aname);
+
 		if(a->atype)
-			cast = get_type(a->atype,TRUE);
+			cast = get_type(a->atype, TRUE);
 		else
-			cast = g_strdup(get_cast(a->gtktype,TRUE));
+			cast = g_strdup(get_cast(a->gtktype, TRUE));
 
 		if(cast) {
 			if(a->set)
 				out_printf(outh, "#define %s_ARG_%s(arg)    \t"
 					   "\"%s\",(%s)(arg)\n",
-					   macrobase, s, a->name, cast);
+					   macrobase, aname, a->name, cast);
 			if(a->get)
 				out_printf(outh, "#define %s_GET_ARG_%s(arg)\t"
 					   "\"%s\",(%s*)(arg)\n",
-					   macrobase, s, a->name, cast);
+					   macrobase, aname, a->name, cast);
 		} else {
 			if(a->set)
 				out_printf(outh, "#define %s_ARG_%s(arg)    \t"
 					   "\"%s\",(arg)\n",
-					   macrobase, s, a->name);
+					   macrobase, aname, a->name);
 			if(a->get)
 				out_printf(outh, "#define %s_GET_ARG_%s(arg)\t"
 					   "\"%s\",(arg)\n",
-					   macrobase, s, a->name);
+					   macrobase, aname, a->name);
 		}
 		g_free(cast);
-		g_free(s);
+		g_free(aname);
 	}
 }
 
@@ -1526,9 +1902,9 @@ put_argument_gnu_wrappers(Class *c)
 		s = g_strdup(a->name);
 		g_strup(s);
 		if(a->atype)
-			cast = get_type(a->atype,TRUE);
+			cast = get_type(a->atype, TRUE);
 		else
-			cast = g_strdup(get_cast(a->gtktype,TRUE));
+			cast = g_strdup(get_cast(a->gtktype, TRUE));
 		if(cast) {
 			if(a->set)
 				out_printf(outh, "#define %s_ARG_%s(arg)    \t"
@@ -1563,40 +1939,40 @@ print_ccode_block(CCode *cc)
 		   code but is printed before */
 	case H_CCODE:
 		fp = outh;
-		out_printf(fp,"\n");
+		out_printf(fp, "\n");
 		break;
 	case AT_CCODE:
 		/* AT code is printed exactly like normal 'all'
 		   code but is printed before */
 	case A_CCODE:
 		if(outph) {
-			out_printf(outph,"\n");
-			out_printf(outph,"%s\n",cc->cbuf);
-			out_addline_infile(outph,cc->line_no);
+			out_printf(outph, "\n");
+			out_printf(outph, "%s\n", cc->cbuf);
+			out_addline_infile(outph, cc->line_no);
 			out_addline_outfile(outph);
 		}
-		out_printf(outh,"\n");
-		out_printf(outh,"%s\n",cc->cbuf);
+		out_printf(outh, "\n");
+		out_printf(outh, "%s\n", cc->cbuf);
 		fp = out;
-		out_printf(fp,"\n");
-		out_addline_infile(fp,cc->line_no);
+		out_printf(fp, "\n");
+		out_addline_infile(fp, cc->line_no);
 		break;
 	default:
 	case C_CCODE:
 		fp = out;
-		out_printf(fp,"\n");
-		out_addline_infile(fp,cc->line_no);
+		out_printf(fp, "\n");
+		out_addline_infile(fp, cc->line_no);
 		break;
 	case PH_CCODE:
 		if(outph)
 			fp = outph;
 		else
 			fp = out;
-		out_printf(fp,"\n");
-		out_addline_infile(fp,cc->line_no);
+		out_printf(fp, "\n");
+		out_addline_infile(fp, cc->line_no);
 		break;
 	}
-	out_printf(fp,"%s\n",cc->cbuf);
+	out_printf(fp, "%s\n", cc->cbuf);
 	if(cc->cctype == C_CCODE ||
 	   cc->cctype == A_CCODE ||
 	   cc->cctype == AT_CCODE ||
@@ -1611,88 +1987,107 @@ print_class_block(Class *c)
 	char *s;
 	gboolean printed_private = FALSE;
 
-	out_printf(out,"/* utility types we may need */\n");
-	out_printf(out,"typedef struct { "
-		   "gpointer a; gpointer b; "
-		   "} ___twopointertype;\n");
-	out_printf(out,"typedef struct { "
-		   "gpointer a; gpointer b; "
-		   "gpointer c; "
-		   "} ___threepointertype;\n");
+	if(any_special) {
+		out_printf(out, "/* utility types we may need */\n");
+		if(special_array[SPECIAL_2POINTER])
+			out_printf(out, "typedef struct { "
+				   "gpointer a; gpointer b; "
+				   "} ___twopointertype;\n");
+		if(special_array[SPECIAL_3POINTER])
+			out_printf(out, "typedef struct { "
+				   "gpointer a; gpointer b; "
+				   "gpointer c; "
+				   "} ___threepointertype;\n");
+		if(special_array[SPECIAL_INT_POINTER])
+			out_printf(out, "typedef struct { "
+				   "gint a; gpointer b; "
+				   "} ___intpointertype;\n");
+		out_printf(out, "\n");
+	}
 
 	out_printf(outh, "\n/*\n"
 		   " * Type checking and casting macros\n"
 		   " */\n");
-	out_printf(outh,"#define %s\t"
+	out_printf(outh, "#define %s\t"
 		   "(%s_get_type())\n",
-		   macrotype,funcbase);
-	out_printf(outh,"#define %s(obj)\t"
-		   "GTK_CHECK_CAST((obj),%s_get_type(),%s)\n",
-		   macrobase,funcbase,typebase);
-	out_printf(outh,"#define %s_CLASS(klass)\t"
+		   macrotype, funcbase);
+	out_printf(outh, "#define %s(obj)\t"
+		   "GTK_CHECK_CAST((obj), %s_get_type(),%s)\n",
+		   macrobase, funcbase, typebase);
+	out_printf(outh, "#define %s_CLASS(klass)\t"
 		   "GTK_CHECK_CLASS_CAST((klass),%s_get_type(),%sClass)\n",
-		   macrobase,funcbase,typebase);
-	out_printf(outh,"#define %s(obj)\t"
-		   "GTK_CHECK_TYPE((obj), %s_get_type ())\n\n",
-		   macrois,funcbase);
-
-	out_printf(out, "\n/* self casting macros */\n");
-	out_printf(out, "#define SELF(x) %s(x)\n", macrobase);
-	out_printf(out, "#define IS_SELF(x) %s(x)\n", macrois);
-	out_printf(out, "#define SELF_CLASS(x) %s_CLASS(x)\n\n", macrobase);
+		   macrobase, funcbase, typebase);
+	out_printf(outh, "#define %s(obj)\t"
+		   "GTK_CHECK_TYPE((obj),%s_get_type ())\n\n",
+		   macrois, funcbase);
+
+	if( ! no_self_alias) {
+		out_printf(out, "/* self casting macros */\n");
+		out_printf(out, "#define SELF(x) %s(x)\n", macrobase);
+		out_printf(out, "#define IS_SELF(x) %s(x)\n", macrois);
+		out_printf(out, "#define SELF_CLASS(x) %s_CLASS(x)\n\n",
+			   macrobase);
+
+		out_printf(out, "/* self typedefs */\n");
+		out_printf(out, "typedef %s Self;\n", typebase);
+		out_printf(out, "typedef %sClass SelfClass;\n\n", typebase);
+	}
 
-	if(privates>0) {
+	if(privates > 0 || always_private_struct) {
 		out_printf(outh, "\n/* Private structure type */\n");
-		out_printf(outh,"typedef struct _%sPrivate %sPrivate;\n",
-			   typebase,typebase);
+		out_printf(outh, "typedef struct _%sPrivate %sPrivate;\n",
+			   typebase, typebase);
+		if(privates == 0)
+			out_printf(outh, "/* There are no privates, this "
+				   "structure is thus never defined */\n");
 	}
 
 	out_printf(outh, "\n/*\n"
 		   " * Main object structure\n"
 		   " */\n");
-	s = replace_sep(c->otype,'_');
+	s = replace_sep(c->otype, '_');
 	g_strup(s);
-	out_printf(outh,"#ifndef __TYPEDEF_%s__\n"
-		   "#define __TYPEDEF_%s__\n",s,s);
+	out_printf(outh, "#ifndef __TYPEDEF_%s__\n"
+		   "#define __TYPEDEF_%s__\n", s, s);
 	g_free(s);
-	out_printf(outh,"typedef struct _%s %s;\n"
-		   "#endif\n",typebase,typebase);
-	out_printf(outh,"struct _%s {\n\t%s __parent__;\n",
-		   typebase,ptypebase);
-	for(l=c->nodes;l;l=g_list_next(l)) {
+	out_printf(outh, "typedef struct _%s %s;\n"
+		   "#endif\n", typebase, typebase);
+	out_printf(outh, "struct _%s {\n\t%s __parent__;\n",
+		   typebase, ptypebase);
+	for(l=c->nodes; l; l=g_list_next(l)) {
 		static gboolean printed_public = FALSE;
 		Node *n = l->data;
 		Variable *v = (Variable *)n;
 		if(n->type == VARIABLE_NODE &&
 		   v->scope == PUBLIC_SCOPE) {
-			if(!printed_public) {
-				out_printf(outh,"\t/*< public >*/\n");
+			if( ! printed_public) {
+				out_printf(outh, "\t/*< public >*/\n");
 				printed_public = TRUE;
 			}
-			put_variable((Variable *)n,outh);
+			put_variable((Variable *)n, outh);
 		}
 	}
 	/* put protecteds always AFTER publics */
-	for(l=c->nodes;l;l=g_list_next(l)) {
+	for(l=c->nodes; l; l=g_list_next(l)) {
 		Node *n = l->data;
 		Variable *v = (Variable *)n;
 		if(n->type == VARIABLE_NODE &&
 		   v->scope == PROTECTED_SCOPE) {
-			if(!printed_private) {
-				out_printf(outh,"\t/*< private >*/\n");
+			if( ! printed_private) {
+				out_printf(outh, "\t/*< private >*/\n");
 				printed_private = TRUE;
 			}
-			put_variable((Variable *)n,outh);
+			put_variable((Variable *)n, outh);
 		}
 	}
-	if(privates>0) {
-		if(!printed_private)
-			out_printf(outh,"\t/*< private >*/\n");
-		out_printf(outh,"\t%sPrivate *_priv;\n",typebase);
+	if(privates > 0 || always_private_struct) {
+		if( ! printed_private)
+			out_printf(outh, "\t/*< private >*/\n");
+		out_printf(outh, "\t%sPrivate *_priv;\n", typebase);
 	}
-	out_printf(outh,"};\n");
+	out_printf(outh, "};\n");
 
-	if(privates>0) {
+	if(privates > 0) {
 		FILE *outfp;
 
 		/* if we are to stick this into the private
@@ -1703,39 +2098,47 @@ print_class_block(Class *c)
 		else
 			outfp = out;
 
-		out_printf(outfp,"struct _%sPrivate {\n",
+		out_printf(outfp, "struct _%sPrivate {\n",
 			   typebase);
-		for(l=c->nodes;l;l=l->next) {
+		for(l=c->nodes; l; l=l->next) {
 			Node *n = l->data;
 			Variable *v = (Variable *)n;
 			if(n->type == VARIABLE_NODE &&
 			   v->scope == PRIVATE_SCOPE) {
-				out_addline_infile(outfp,v->line_no);
-				put_variable(v,outfp);
+				out_addline_infile(outfp, v->line_no);
+				put_variable(v, outfp);
 			}
 		}
 		out_addline_outfile(outfp);
-		out_printf(outfp,"};\n");
+		out_printf(outfp, "};\n");
 	}
 
 	out_printf(outh, "\n/*\n"
 		   " * Class definition\n"
 		   " */\n");
-	out_printf(outh,"typedef struct _%sClass %sClass;\n",
-		   typebase,typebase);
+	out_printf(outh, "typedef struct _%sClass %sClass;\n",
+		   typebase, typebase);
 	out_printf(outh,
 		   "struct _%sClass {\n\t%sClass __parent__;\n",
-		   typebase,ptypebase);
+		   typebase, ptypebase);
 	for(l=c->nodes;l;l=g_list_next(l)) {
 		Node *n = l->data;
 		if(n->type == METHOD_NODE)
 			put_vs_method((Method *)n);
 	}
-	out_printf(outh,"};\n\n");
+	/* put class scope variables */
+	for(l=c->nodes;l;l=g_list_next(l)) {
+		Node *n = l->data;
+		Variable *v = (Variable *)n;
+		if(n->type == VARIABLE_NODE &&
+		   v->scope == CLASS_SCOPE)
+			put_variable((Variable *)n, outh);
+	}
+	out_printf(outh, "};\n\n");
 
-	out_printf(out,"/* here are local prototypes */\n");
+	out_printf(out, "/* here are local prototypes */\n");
 	if(arguments>0) {
-		out_printf(out,"static void ___object_set_arg "
+		out_printf(out, "static void ___object_set_arg "
 			   "(GtkObject *object, GtkArg *arg, "
 			   "guint arg_id);\n"
 			   "static void ___object_get_arg "
@@ -1747,7 +2150,7 @@ print_class_block(Class *c)
 		   " * Public methods\n"
 		   " */\n");
 
-	out_printf(outh,"guint\t%s_get_type\t(void);\n",funcbase);
+	out_printf(outh, "guint\t%s_get_type\t(void);\n", funcbase);
 	for(l=c->nodes;l;l=g_list_next(l)) {
 		Node *n = l->data;
 		if(n->type == METHOD_NODE) {
@@ -1780,11 +2183,11 @@ print_class_block(Class *c)
 		out_printf(outh, "\n/*\n"
 			   " * Argument wrapping macros\n"
 			   " */\n");
-		out_printf(outh,"#ifdef __GNUC__\n");
+		out_printf(outh, "#ifdef __GNUC__\n");
 		put_argument_gnu_wrappers(c);
-		out_printf(outh,"#else /* __GNUC__ */\n");
+		out_printf(outh, "#else /* __GNUC__ */\n");
 		put_argument_nongnu_wrappers(c);
-		out_printf(outh,"#endif /* __GNUC__ */\n\n");
+		out_printf(outh, "#endif /* __GNUC__ */\n\n");
 	} else if(arguments>0 && no_gnu) {
 		out_printf(outh, "\n/*\n"
 			   " * Argument wrapping macros\n"
@@ -1804,18 +2207,28 @@ print_class_block(Class *c)
 
 	add_get_type();
 
-	if(no_gnu)
-		make_method_nongnu_aliases(c);
-	else {
-		out_printf(out,"\n#ifdef __GNUC__\n");
-		make_method_gnu_aliases(c);
-		out_printf(out,"#else /* __GNUC__ */\n");
-		make_method_nongnu_aliases(c);
-		out_printf(out,"#endif /* __GNUC__ */\n\n");
+	if(any_method_to_alias(c)) {
+		if(no_gnu)
+			make_method_nongnu_aliases(c);
+		else {
+			out_printf(out, "\n#ifdef __GNUC__\n");
+			make_method_gnu_aliases(c);
+			out_printf(out, "#else /* __GNUC__ */\n");
+			make_method_nongnu_aliases(c);
+			out_printf(out, "#endif /* __GNUC__ */\n\n");
+		}
 	}
 
-	out_printf(out,"#define GET_NEW (gtk_type_new(%s_get_type()))\n",
-		   funcbase);
+	out_printf(out, "/* a macro for creating a new object of our type */\n");
+	out_printf(out,
+		   "#define GET_NEW ((%s *)gtk_type_new(%s_get_type()))\n\n",
+		   typebase, funcbase);
+
+	if(need_destroy)
+		add_destroy(c);
+
+	if(need_finalize)
+		add_finalize(c);
 
 	add_inits(c);
 
@@ -1826,21 +2239,18 @@ print_class_block(Class *c)
 
 	for(l=c->nodes;l;l=g_list_next(l)) {
 		Node *n = l->data;
-		if(n->type == METHOD_NODE) {
+		if(n->type == METHOD_NODE)
 			put_method((Method *)n);
-		}
 	}
 
-	out_printf(out,"#undef GET_NEW\n");
-
 	add_bad_hack_to_avoid_unused_warnings(c);
 }
 
 static void
 print_version_macros(void)
 {
-	int major=0,minor=0,pl=0;
-	sscanf(VERSION,"%d.%d.%d",&major,&minor,&pl);
+	int major=0, minor=0, pl=0;
+	sscanf(VERSION, "%d.%d.%d", &major, &minor, &pl);
 
 	out_printf(out, "#define GOB_VERSION_MAJOR %d\n", major);
 	out_printf(out, "#define GOB_VERSION_MINOR %d\n", minor);
@@ -1852,13 +2262,14 @@ print_file_comments(void)
 {
 	time_t curtime;
 	time(&curtime);
-	out_printf(outh,"/* Generated by GOB (v%s)"
-	       "   (do not edit directly) */\n\n",VERSION);
+	out_printf(outh, "/* Generated by GOB (v%s)"
+		   "   (do not edit directly) */\n\n", VERSION);
 	if(outph)
-		out_printf(outph,"/* Generated by GOB (v%s)"
-			   "   (do not edit directly) */\n\n",VERSION);
-	out_printf(out,"/* Generated by GOB (v%s) on %s"
-	       "   (do not edit directly) */\n\n",VERSION,ctime(&curtime));
+		out_printf(outph, "/* Generated by GOB (v%s)"
+			   "   (do not edit directly) */\n\n", VERSION);
+	out_printf(out, "/* Generated by GOB (v%s) on %s"
+		   "   (do not edit directly) */\n\n",
+		   VERSION, ctime(&curtime));
 }
 
 static void
@@ -1867,19 +2278,23 @@ print_includes(void)
 	gboolean found_header;
 	char *p;
 
-	p = g_strconcat(filebase,".h",NULL);
+	/* We may need string.h for memset */
+	if(destructors > 0)
+		out_printf(out, "#include <string.h> /* memset() */\n\n");
+
+	p = g_strconcat(filebase, ".h", NULL);
 	found_header = TRUE;
-	if(!g_list_find_custom(include_files,p,(GCompareFunc)strcmp)) {
-		out_printf(out,"#include \"%s.h\"\n\n",filebase);
+	if(!g_list_find_custom(include_files, p, (GCompareFunc)strcmp)) {
+		out_printf(out, "#include \"%s.h\"\n\n", filebase);
 		found_header = FALSE;
 	}
 	g_free(p);
 
 	/* if we are creating a private header see if it was included */
 	if(outph) {
-		p = g_strconcat(filebase,"-private.h",NULL);
-		if(!g_list_find_custom(include_files,p,(GCompareFunc)strcmp)) {
-			out_printf(out,"#include \"%s-private.h\"\n\n",
+		p = g_strconcat(filebase, "-private.h", NULL);
+		if(!g_list_find_custom(include_files, p, (GCompareFunc)strcmp)) {
+			out_printf(out, "#include \"%s-private.h\"\n\n",
 				   filebase);
 			if(found_header)
 				print_error(TRUE,
@@ -1901,21 +2316,21 @@ print_header_prefixes(void)
 {
 	char *p;
 
-	p = replace_sep(((Class *)class)->otype,'_');
+	p = replace_sep(((Class *)class)->otype, '_');
 	g_strup(p);
-	out_printf(outh,"#ifndef __%s_H__\n#define __%s_H__\n\n",p,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"
+		out_printf(outph, "#ifndef __%s_PRIVATE_H__\n"
 			   "#define __%s_PRIVATE_H__\n\n"
-			   "#include \"%s.h\"\n\n",p,p,filebase);
+			   "#include \"%s.h\"\n\n", p, p, filebase);
 	g_free(p);
 
 	if(!no_extern_c) {
-		out_printf(outh,"#ifdef __cplusplus\n"
+		out_printf(outh, "#ifdef __cplusplus\n"
 			   "extern \"C\" {\n"
 			   "#endif /* __cplusplus */\n\n");
 		if(outph)
-			out_printf(outph,"#ifdef __cplusplus\n"
+			out_printf(outph, "#ifdef __cplusplus\n"
 				   "extern \"C\" {\n"
 				   "#endif /* __cplusplus */\n\n");
 	}
@@ -1925,16 +2340,16 @@ static void
 print_header_postfixes(void)
 {
 	if(!no_extern_c)
-		out_printf(outh,"\n#ifdef __cplusplus\n"
+		out_printf(outh, "\n#ifdef __cplusplus\n"
 			   "}\n"
 			   "#endif /* __cplusplus */\n");
-	out_printf(outh,"\n#endif");
+	out_printf(outh, "\n#endif\n");
 	if(outph) {
 		if(!no_extern_c)
-			out_printf(outph,"\n#ifdef __cplusplus\n"
+			out_printf(outph, "\n#ifdef __cplusplus\n"
 				   "}\n"
 				   "#endif /* __cplusplus */\n");
-		out_printf(outph,"\n#endif");
+		out_printf(outph, "\n#endif\n");
 	}
 }
 
@@ -1960,7 +2375,7 @@ print_header_top(void)
 	GList *li;
 
 	/* mandatory include */
-	out_printf(outh,"#include <gtk/gtk.h>\n\n");
+	out_printf(outh, "#include <gtk/gtk.h>\n\n");
 
 	/* print the HT_CCODE blocks */
 	for(li=nodes;li;li=g_list_next(li)) {
@@ -2008,8 +2423,9 @@ generate_outfiles(void)
 static void
 print_help(void)
 {
-	fprintf(stderr,"Gob version %s\n\n",VERSION);
-	fprintf(stderr,"Options:\n"
+	fprintf(stderr, "Gob version %s\n\n", VERSION);
+	fprintf(stderr, "gob [options] file.gob\n\n");
+	fprintf(stderr, "Options:\n"
 		"\t--help,-h,-?            Display this help\n"
 		"\t--version               Display version\n"
 		"\t--exit-on-warn,-w       Exit with an error on warnings\n"
@@ -2022,13 +2438,25 @@ print_help(void)
 		                          "really changed\n"
 		"\t--always-private-header Always create a private header "
 					  "file,\n"
-		"\t                        even if it would be empty\n"
+		"\t                        even if it would be empty "
+		                          "[default]\n"
+		"\t--ondemand-private-header Create private header only when "
+					  "needed\n"
 		"\t--no-private-header     Don't create a private header, "
 					  "put private\n"
 	  	"\t                        structure and protected "
 					  "prototypes inside c file\n"
+		"\t--always-private-struct Always create a private pointer "
+					  "in\n"
+		"\t                        the object structure\n"
 		"\t--no-write,-n           Don't write output files, just "
-					  "check syntax\n");
+					  "check syntax\n"
+		"\t--no-lines              Don't print '#line' to output\n"
+		"\t--no-self-alias         Don't create self type and macro "
+		                          "aliases\n"
+		"\t--no-kill-underscores   Don't remove the leading underscore "
+		                          "from\n"
+		"\t                        short id names\n");
 }
 
 static void
@@ -2050,10 +2478,10 @@ parse_options(int argc, char *argv[])
 			}
 			filename = argv[i];
 			got_file = TRUE;
-		} else if(strcmp(argv[i],"--help")==0) {
+		} else if(strcmp(argv[i], "--help")==0) {
 			print_help();
 			exit(0);
-		} else if(strcmp(argv[i],"--version")==0) {
+		} else if(strcmp(argv[i], "--version")==0) {
 			fprintf(stderr, "Gob version %s\n", VERSION);
 			exit(0);
 		} else if(strcmp(argv[i], "--exit-on-warn")==0) {
@@ -2064,22 +2492,30 @@ parse_options(int argc, char *argv[])
 			for_cpp = TRUE;
 		} else if(strcmp(argv[i], "--no-touch-headers")==0) {
 			no_touch_headers = TRUE;
+		} else if(strcmp(argv[i], "--ondemand-private-header")==0) {
+			private_header = PRIVATE_HEADER_ONDEMAND;
 		} else if(strcmp(argv[i], "--always-private-header")==0) {
-			no_private_header = FALSE;
-			always_private_header = TRUE;
+			private_header = PRIVATE_HEADER_ALWAYS;
 		} else if(strcmp(argv[i], "--no-private-header")==0) {
-			always_private_header = FALSE;
-			no_private_header = TRUE;
+			private_header = PRIVATE_HEADER_NEVER;
 		} else if(strcmp(argv[i], "--no-gnu")==0) {
 			no_gnu = TRUE;
 		} else if(strcmp(argv[i], "--no-extern-c")==0) {
 			no_extern_c = TRUE;
 		} else if(strcmp(argv[i], "--no-write")==0) {
 			no_write = TRUE;
+		} else if(strcmp(argv[i], "--no-lines")==0) {
+			no_lines = TRUE;
+		} else if(strcmp(argv[i], "--no-self-alias")==0) {
+			no_self_alias = TRUE;
+		} else if(strcmp(argv[i], "--no-kill-underscores")==0) {
+			no_kill_underscores = TRUE;
+		} else if(strcmp(argv[i], "--always-private-struct")==0) {
+			always_private_struct = TRUE;
 		} else if(strcmp(argv[i], "--")==0) {
 			/*further arguments are files*/
 			no_opts = TRUE;
-		} else if(strncmp(argv[i], "--",2)==0) {
+		} else if(strncmp(argv[i], "--", 2)==0) {
 			/*unknown long option*/
 			fprintf(stderr, "Unknown option '%s'!\n", argv[i]);
 			print_help();
@@ -2118,7 +2554,7 @@ compare_and_move_header(void)
 	char *hfnew = g_strconcat("#gob#", filebase, ".h#gob#", NULL);
 	char *hf = g_strconcat(filebase, ".h", NULL);
 	struct stat s;
-	if(stat(hf,&s)==0) {
+	if(stat(hf, &s)==0) {
 		char *s;
 		s = g_strdup_printf("cmp '%s' '%s' > /dev/null", hf, hfnew);
 		if(system(s)==0) {
@@ -2134,7 +2570,7 @@ compare_and_move_header(void)
 		if(unlink(hf)!=0)
 			print_error(FALSE, "Can't remove old header file", 0);
 	}
-	if(rename(hfnew,hf)!=0)
+	if(rename(hfnew, hf)!=0)
 		print_error(FALSE, "Can't rename new header file", 0);
 	g_free(hfnew);
 	g_free(hf);
@@ -2169,13 +2605,22 @@ main(int argc, char *argv[])
 	overrides = count_overrides((Class *)class);
 	privates = count_privates((Class *)class);
 	protecteds = count_protecteds((Class *)class);
+	destructors = count_destructors((Class *)class);
+	initializers = count_initializers((Class *)class);
 
 	make_bases();
 	make_inits((Class *)class);
-	if(privates>0)
-		make_finalize((Class *)class);
+	if(destructors > 0) {
+		need_destroy = TRUE;
+		find_destroy((Class *)class);
+	}
+	if(privates > 0) {
+		need_finalize = TRUE;
+		find_finalize((Class *)class);
+	}
 	check_bad_symbols((Class *)class);
 	check_duplicate_symbols((Class *)class);
+	check_duplicate_overrides((Class *)class);
 	check_duplicate_signals_args((Class *)class);
 	check_public_new((Class *)class);
 	check_vararg((Class *)class);
@@ -2183,12 +2628,15 @@ main(int argc, char *argv[])
 	check_nonvoidempty((Class *)class);
 	check_signal_args((Class *)class);
 	check_argument_types((Class *)class);
+	check_func_arg_checks((Class *)class);
 
 	exit_on_error = TRUE;
 	
 	if(got_error)
 		exit(1);
 
+	any_special = setup_special_array((Class *)class, special_array);
+
 	open_files();
 	
 	generate_outfiles();