X-Git-Url: http://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/8cb6370effd9f2dacc6dc9b662a43ea19ee637ac..40647d7b7b7fbeae828e0a032a3c3a5f204cdfa8:/src/main.c

diff --git a/src/main.c b/src/main.c
index d706cef..07158f5 100644
--- a/src/main.c
+++ b/src/main.c
@@ -27,6 +27,8 @@
 #include <time.h>
 #include <stdio.h>
 #include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
 
 #include "tree.h"
 #include "parse.h"
@@ -42,24 +44,30 @@ extern FILE * yyin;
 extern Node *class;
 extern GList *nodes;
 
+extern GList *include_files;
+
 char *filebase;
 static char *funcbase;
 static char *pfuncbase;
 static char *macrobase;
 static char *macrois;
+static char *macrotype;
 static char *typebase;
 static char *ptypebase;
 
-static int signals = 0;
-static int arguments = 0;
-static int overrides = 0;
+static int signals = 0; /* number of signals */
+static int arguments = 0; /* number of named arguments */
+static int overrides = 0; /* number of override functions */
+static int privates = 0; /* number of private data members */
 
 FILE *out;
 FILE *outh;
 
-int exit_on_warn = FALSE;
-int exit_on_error = TRUE;
-int got_error = FALSE;
+gboolean no_touch_headers = FALSE;
+gboolean for_cpp = FALSE;
+gboolean exit_on_warn = FALSE;
+gboolean exit_on_error = TRUE;
+gboolean got_error = FALSE;
 
 void
 print_error(int is_warn, char *error,int line)
@@ -128,17 +136,19 @@ separns_replace_sep(char *base, char **ns, char **name, char r)
 		*name = s;
 }
 
+/* make a macro with some prefix before the name but after
+   namespace */
 static char *
-make_is_macro(char *base)
+make_pre_macro(char *base, char *pre)
 {
 	char *s1,*s2;
 	char *s;
 
 	separns_replace_sep(base,&s1,&s2,'_');
 	if(s1)
-		s = g_strconcat(s1,"_IS_",s2,NULL);
+		s = g_strconcat(s1,"_",pre,"_",s2,NULL);
 	else
-		s = g_strconcat("IS_",s2,NULL);
+		s = g_strconcat(pre,"_",s2,NULL);
 
 	g_strup(s);
 	
@@ -163,7 +173,8 @@ make_bases(void)
 	macrobase = replace_sep(((Class *)class)->otype,'_');
 	g_strup(macrobase);
 	
-	macrois = make_is_macro(((Class *)class)->otype);
+	macrois = make_pre_macro(((Class *)class)->otype,"IS");
+	macrotype = make_pre_macro(((Class *)class)->otype,"TYPE");
 
 	typebase = remove_sep(((Class *)class)->otype);
 
@@ -171,7 +182,55 @@ make_bases(void)
 }
 
 static void
-def_methods(Class *c)
+print_type(FILE *fp, Type *t)
+{
+	char *s;
+	int i;
+	s = remove_sep(t->name);
+	out_printf(fp,"%s ",s); 
+	g_free(s);
+	
+	for(i=0;i<t->stars;i++)
+		out_printf(fp,"*"); 
+}
+
+static void
+print_method(FILE *fp, char *typeprefix, char *nameprefix,
+	     char *namepostfix,char *postfix, Method *m,
+	     gboolean no_funcbase)
+{
+	GList *li;
+
+	out_printf(fp,"%s",typeprefix); 
+	print_type(fp,m->mtype);
+	if(no_funcbase)
+		out_printf(fp,"%s%s%s(",
+			   nameprefix,m->id,namepostfix); 
+	else
+		out_printf(fp,"%s%s_%s%s(",
+			   nameprefix,funcbase,m->id,namepostfix); 
+	
+	if(m->args) {
+		for(li=m->args;li;li=g_list_next(li)) {
+			FuncArg *arg = li->data;
+			print_type(fp,arg->atype);
+			if(li->next)
+				out_printf(fp,"%s, ",arg->name); 
+			else
+				out_printf(fp,"%s",arg->name); 
+
+		}
+		if(m->vararg)
+			out_printf(fp,", ..."); 
+	} else {
+		out_printf(fp,"void"); 
+	}
+	out_printf(fp,")%s",postfix); 
+}
+
+
+static void
+make_method_pointers(Class *c)
 {
 	GList *li;
 	
@@ -185,86 +244,64 @@ def_methods(Class *c)
 			   m->scope == CLASS_INIT_METHOD ||
 			   m->scope == OVERRIDE_METHOD)
 				continue;
-			
-			out_printf(out,"#define %s %s_%s\n",m->id,funcbase,m->id); 
+
+			/* in C++ mode don't alias new */
+			if(for_cpp && strcmp(m->id,"new")==0)
+				continue;
+
+			print_method(out,"static ","(* ",") ","",m,TRUE);
+			out_printf(out," = %s_%s;\n",funcbase,m->id);
 		}
 	}
 	out_printf(out,"\n");
 }
 
 static void
-undef_methods(Class *c)
+add_bad_hack_to_avoid_unused_warnings(Class *c)
 {
 	GList *li;
 	
-	out_printf(out,"\n");
+	out_printf(out,"\n\n/*REALLY BAD HACK\n"
+		   "  This is to avoid unused warnings if you don't call\n"
+		   "  some method, it pollutes the namespace but the call\n"
+		   "  is weird enough.  I need to find a better way to do\n"
+		   "  this */\n");
+	out_printf(out,"void __%s_really_bad_hack_to_avoid_warnings(void);\n",
+		   funcbase);
+	out_printf(out,"void\n__%s_really_bad_hack_to_avoid_warnings(void)\n"
+		   "{\n",funcbase);
 	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->scope == INIT_METHOD ||
 			   m->scope == CLASS_INIT_METHOD ||
 			   m->scope == OVERRIDE_METHOD)
 				continue;
-			
-			out_printf(out,"#undef %s\n",m->id); 
-		}
-	}
-	out_printf(out,"\n");
-}
-
-static void
-print_type(FILE *fp, Type *t)
-{
-	char *s;
-	int i;
-	s = remove_sep(t->name);
-	out_printf(fp,"%s ",s); 
-	g_free(s);
-	
-	for(i=0;i<t->stars;i++)
-		out_printf(fp,"*"); 
-}
 
-static void
-put_variable(Variable *v)
-{
-	out_printf(outh,"\t");
-	if(v->scope == PRIVATE_SCOPE)
-		out_printf(outh,"/* private */ "); 
-	print_type(outh,v->vtype);
+			/* in C++ mode we don't alias new */
+			if(for_cpp && strcmp(m->id,"new")==0)
+				continue;
 
-	out_printf(outh,"%s;\n",v->id); 
+			out_printf(out,"\t((void (*)(void))%s)();\n",m->id);
+		}
+	}
+	out_printf(out,"}\n\n");
 }
 
 static void
-print_method(FILE *fp, char *typeprefix, char *nameprefix,
-	     char *namepostfix,char *postfix, Method *m)
+put_variable(Variable *v, FILE *fp, int priv)
 {
-	GList *li;
-
-	out_printf(fp,"%s",typeprefix); 
-	print_type(fp,m->mtype);
-	out_printf(fp,"%s%s_%s%s(",
-		nameprefix,funcbase,m->id,namepostfix); 
-	
-	if(m->args) {
-		for(li=m->args;li;li=g_list_next(li)) {
-			FuncArg *arg = li->data;
-			print_type(fp,arg->atype);
-			if(li->next)
-				out_printf(fp,"%s, ",arg->name); 
-			else
-				out_printf(fp,"%s",arg->name); 
-
-		}
-		if(m->vararg)
-			out_printf(fp,", ..."); 
+	if(v->scope == PRIVATE_SCOPE) {
+		if(!priv) return;
 	} else {
-		out_printf(fp,"void"); 
+		if(priv) return;
 	}
-	out_printf(fp,")%s\n",postfix); 
+
+	out_printf(fp,"\t");
+	print_type(fp,v->vtype);
+	out_printf(fp,"%s;\n",v->id); 
 }
 
 static void
@@ -278,7 +315,7 @@ put_vs_method(Method *m)
 	   m->scope != PRIVATE_VIRTUAL_METHOD)
 		return;
 
-	print_method(outh,"\t","(* ",") ",";",m);
+	print_method(outh,"\t","(* ",") ",";\n",m,TRUE);
 }
 
 static void
@@ -293,7 +330,7 @@ put_pub_method(Method *m)
 	   m->scope == PRIVATE_VIRTUAL_METHOD)
 		return;
 
-	print_method(outh,"","\t","\t",";",m);
+	print_method(outh,"","\t","\t",";\n",m,FALSE);
 }
 
 static void
@@ -306,30 +343,30 @@ put_priv_method_prot(Method *m)
 	   m->scope == PRIVATE_SIGNAL_FIRST_METHOD ||
 	   m->scope == PRIVATE_VIRTUAL_METHOD) {
 		if(m->cbuf)
-			print_method(out,"static ","_real_"," ",";",m);
-		print_method(out,"static ",""," ",";",m);
+			print_method(out,"static ","_real_"," ",";\n",m,FALSE);
+		print_method(out,"static ",""," ",";\n",m,FALSE);
 	} else if(m->scope == SIGNAL_LAST_METHOD ||
 		  m->scope == SIGNAL_FIRST_METHOD ||
 		  m->scope == VIRTUAL_METHOD) {
 		if(!m->cbuf)
 			return;
-		print_method(out,"static ","_real_"," ",";",m);
+		print_method(out,"static ","_real_"," ",";\n",m,FALSE);
 	} else {
-		print_method(out,"static ",""," ",";",m);
+		print_method(out,"static ",""," ",";\n",m,FALSE);
 	}
 }
 
 static GList *
-make_init_args(Class *cl, char *name, int is_class)
+make_func_arg(char *typename, int is_class, char *name)
 {
 	Node *node;
 	Node *type;
 	char *tn;
 	
 	if(is_class)
-		tn = g_strconcat(cl->otype,":Class",NULL);
+		tn = g_strconcat(typename,":Class",NULL);
 	else
-		tn = g_strdup(cl->otype);
+		tn = g_strdup(typename);
 
 	type = new_type(1,tn);
 	node = new_funcarg((Type *)type,name,NULL);
@@ -362,7 +399,7 @@ make_inits(Class *cl)
 		node = new_method(CLASS_INIT_METHOD,
 				  (Type *)new_type(0,g_strdup("void")),
 				  NULL,NULL,g_strdup("class_init"),
-				  make_init_args(cl,g_strdup("c"),TRUE),
+				  make_func_arg(cl->otype,TRUE,g_strdup("c")),
 				  NULL, NULL,0,0,FALSE);
 		cl->nodes = g_list_prepend(cl->nodes,node);
 	}
@@ -370,12 +407,50 @@ make_inits(Class *cl)
 		node = new_method(INIT_METHOD,
 				  (Type *)new_type(0,g_strdup("void")),
 				  NULL,NULL,g_strdup("init"),
-				  make_init_args(cl,g_strdup("o"),FALSE),
+				  make_func_arg(cl->otype,FALSE,g_strdup("o")),
 				  NULL, NULL,0,0,FALSE);
 		cl->nodes = g_list_prepend(cl->nodes,node);
 	}
 }
 
+static void
+make_destroy(Class *cl)
+{
+	int got_destroy = FALSE;
+	GList *li;
+	Node *node;
+	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->scope == OVERRIDE_METHOD &&
+			   strcmp(m->id,"destroy")==0) {
+				if(strcmp(m->otype,"Gtk:Object")==0) {
+					got_destroy = TRUE;
+					break;
+				} else {
+					print_error(FALSE,"destroy method override "
+						    "of class other then Gtk:Object",
+						    m->line_no);
+				}
+
+			}
+		}
+	}
+	if(!got_destroy) {
+		node = new_method(OVERRIDE_METHOD,
+				  (Type *)new_type(0,g_strdup("void")),
+				  g_strdup("Gtk:Object"),
+				  NULL,g_strdup("destroy"),
+				  make_func_arg("Gtk:Object",FALSE,g_strdup("o")),
+				  NULL,
+				  g_string_new("PARENT_HANDLER (o);\n"),
+				  0,0,FALSE);
+		cl->nodes = g_list_append(cl->nodes,node);
+		overrides++;
+	}
+}
+
 static GHashTable *marsh = NULL;
 
 static void
@@ -427,10 +502,21 @@ add_signal_prots(Method *m)
 			"\trfunc = (%s)func;\n\n"
 			"\t(*rfunc)((%s *)object",s,s,typebase);
 		if(strcmp(m->gtktypes->next->data,"NONE")!=0) {
+			GList *ali = m->args->next;
 			for(i=0,li=m->gtktypes->next;li;
 			    i++,li=g_list_next(li)) {
-				out_printf(out, ",\n\t\tGTK_VALUE_%s(args[%d])",
-					(char *)li->data,i);
+				if(!for_cpp || !ali)
+					out_printf(out, ",\n\t\tGTK_VALUE_%s(args[%d])",
+						   (char *)li->data,i);
+				else {
+					FuncArg *fa = ali->data;
+					out_printf(out, ",\n\t\t(");
+					print_type(out,fa->atype);
+					out_printf(out, ")GTK_VALUE_%s(args[%d])",
+						   (char *)li->data,i);
+				}
+
+				if(ali) ali = ali->next;
 			}
 		}
 		out_printf(out, ",\n\t\tfunc_data);\n}\n\n");
@@ -445,10 +531,21 @@ add_signal_prots(Method *m)
 			s,(char *)m->gtktypes->data,
 			g_list_length(m->gtktypes)-1,typebase);
 		if(strcmp(m->gtktypes->next->data,"NONE")!=0) {
+			GList *ali = m->args->next;
 			for(i=0,li=m->gtktypes->next;li;
 			    i++,li=g_list_next(li)) {
-				out_printf(out, ",\n\t\tGTK_VALUE_%s(args[%d])",
-					(char *)li->data,i);
+				if(!for_cpp || !ali)
+					out_printf(out, ",\n\t\tGTK_VALUE_%s(args[%d])",
+						   (char *)li->data,i);
+				else {
+					FuncArg *fa = ali->data;
+					out_printf(out, ",\n\t\t(");
+					print_type(out,fa->atype);
+					out_printf(out, ")GTK_VALUE_%s(args[%d])",
+						   (char *)li->data,i);
+				}
+
+				if(ali) ali = ali->next;
 			}
 		}
 		out_printf(out, ",\n\t\tfunc_data);\n}\n\n");
@@ -729,14 +826,20 @@ add_inits(Class *c)
 		if(m->scope == INIT_METHOD) {
 			if(m->line_no>0)
 				out_addline_infile(out,m->line_no);
-			print_method(out,"static ","\n"," ","",m);
+			print_method(out,"static ","\n"," ","\n",m,FALSE);
 			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",
+					   ((FuncArg *)m->args->data)->name,
+					   typebase);
+			}
 		} else if(m->scope == CLASS_INIT_METHOD) {
 			if(m->line_no>0)
 				out_addline_infile(out,m->line_no);
-			print_method(out,"static ","\n"," ","",m);
+			print_method(out,"static ","\n"," ","\n",m,FALSE);
 			if(m->line_no>0)
 				out_addline_outfile(out);
 			out_printf(out,"{\n");
@@ -747,15 +850,17 @@ add_inits(Class *c)
 					   "gtk_object_class = "
 					   "(GtkObjectClass*) %s;\n",
 					   ((FuncArg *)m->args->data)->name);
-			
+
 			if(overrides>0)
 				add_overrides(c,
 					      ((FuncArg *)m->args->data)->name,
 					      (signals>0 || arguments>0));
 			
-			out_printf(out,"\n\tparent_class = "
-				"gtk_type_class (%s_get_type ());\n",
-				pfuncbase);
+			out_printf(out,"\n\tparent_class = ");
+			if(for_cpp)
+				out_printf(out,"(%sClass *)",ptypebase);
+			out_printf(out,"gtk_type_class (%s_get_type ());\n",
+				   pfuncbase);
 
 			if(signals>0)
 				add_signals(c);
@@ -764,6 +869,7 @@ add_inits(Class *c)
 			
 			if(arguments>0)
 				make_arguments(c);
+
 		} else
 			continue;
 
@@ -789,8 +895,8 @@ add_getset_arg(Class *c, int is_set)
 		"\tGtkArg *arg,\n"
 		"\tguint arg_id)\n"
 		"{\n"
-		"\t%s *self, *this;\n\n"
-		"\tself = this = %s (object);\n\n"
+		"\t%s *self;\n\n"
+		"\tself = %s (object);\n\n"
 		"\tswitch (arg_id) {\n",
 		is_set?"set":"get",typebase,macrobase);
 
@@ -848,7 +954,7 @@ print_checks(Method *m, FuncArg *fa)
 			out_printf(out,"%s != NULL",fa->name);
 			break;
 		case TYPE_CHECK:
-			s = make_is_macro(fa->atype->name);
+			s = make_pre_macro(fa->atype->name,"IS");
 			out_printf(out,"%s (%s)",s,fa->name);
 			g_free(s);
 			break;
@@ -894,21 +1000,39 @@ print_preconditions(Method *m)
 	}
 }
 
+/* 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->scope == OVERRIDE_METHOD &&
+	   strcmp(m->id,"destroy")==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");
-	if(pre) {
+	if(pre)
 		print_preconditions(m);
-		out_printf(out,"\t{\n");
-	}
+	put_in_gen_code(m);
+
+	out_printf(out,"\t{\n");
 
 	out_addline_infile(out,m->ccode_line);
 	out_printf(out,"\t\t%s\n",m->cbuf->str);
 	out_addline_outfile(out);
 
-	if(pre)
-		out_printf(out,"\t}\n");
+	out_printf(out,"\t}\n");
 	out_printf(out,"}\n");
 }
 
@@ -921,12 +1045,12 @@ put_method(Method *m)
 	switch(m->scope) {
 	case PUBLIC_SCOPE:
 		out_addline_infile(out,m->line_no);
-		print_method(out,"","\n"," ","",m);
+		print_method(out,"","\n"," ","\n",m,FALSE);
 		print_method_body(m,TRUE);
 		break;
 	case PRIVATE_SCOPE:
 		out_addline_infile(out,m->line_no);
-		print_method(out,"static ","\n"," ","",m);
+		print_method(out,"static ","\n"," ","\n",m,FALSE);
 		print_method_body(m,TRUE);
 		break;
 	case PRIVATE_SIGNAL_FIRST_METHOD:
@@ -935,7 +1059,7 @@ put_method(Method *m)
 	case SIGNAL_FIRST_METHOD:
 	case SIGNAL_LAST_METHOD:
 		out_addline_infile(out,m->line_no);
-		print_method(out,private?"static ":"","\n"," ","",m);
+		print_method(out,private?"static ":"","\n"," ","\n",m,FALSE);
 		out_addline_outfile(out);
 		out_printf(out,"{\n");
 		s = g_strdup(m->id);
@@ -973,25 +1097,25 @@ put_method(Method *m)
 		if(!m->cbuf)
 			break;
 		out_addline_infile(out,m->line_no);
-		print_method(out,"static ","\n_real_"," ","",m);
+		print_method(out,"static ","\n_real_"," ","\n",m,FALSE);
 		print_method_body(m,FALSE);
 		break;
 	case PRIVATE_VIRTUAL_METHOD:
 		private = TRUE;
 	case VIRTUAL_METHOD:
 		out_addline_infile(out,m->line_no);
-		print_method(out,private?"static ":"","\n"," ","",m);
+		print_method(out,private?"static ":"","\n"," ","\n",m,FALSE);
 		out_addline_outfile(out);
 		out_printf(out,"{\n"
-			"\t%sClass *class;\n",typebase);
+			"\t%sClass *klass;\n",typebase);
 		print_preconditions(m);
-		out_printf(out,"\tclass = %s_CLASS(GTK_OBJECT(%s)->klass);\n\n"
-			"\tif(class->%s)\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) {
 			GList *li;
-			out_printf(out,"\t\t(*class->%s)(%s",m->id,
+			out_printf(out,"\t\t(*klass->%s)(%s",m->id,
 				   ((FuncArg *)m->args->data)->name);
 			for(li=m->args->next;li;li=g_list_next(li)) {
 				FuncArg *fa = li->data;
@@ -1000,7 +1124,7 @@ put_method(Method *m)
 			out_printf(out,");\n}\n");
 		} else {
 			GList *li;
-			out_printf(out,"\t\treturn (*class->%s)(%s",m->id,
+			out_printf(out,"\t\treturn (*klass->%s)(%s",m->id,
 				   ((FuncArg *)m->args->data)->name);
 			for(li=m->args->next;li;li=g_list_next(li)) {
 				FuncArg *fa = li->data;
@@ -1017,13 +1141,21 @@ put_method(Method *m)
 		if(!m->cbuf)
 			break;
 		out_addline_infile(out,m->line_no);
-		print_method(out,"static ","\n_real_"," ","",m);
+		print_method(out,"static ","\n_real_"," ","\n",m,FALSE);
 		print_method_body(m,FALSE);
 		break;
 	case OVERRIDE_METHOD:
 		out_addline_infile(out,m->line_no);
-		print_method(out,"static ","\n"," ","",m);
+		print_method(out,"static ","\n"," ","\n",m,FALSE);
+		s = replace_sep(m->otype,'_');
+		g_strup(s);
+		out_printf(out,"#define PARENT_HANDLER(args...) \\\n"
+			   "\t{ if(%s_CLASS(parent_class)->%s) \\\n"
+			   "\t\t(* %s_CLASS(parent_class)->%s)(##args); }\n",
+			   s,m->id,s,m->id);
+		g_free(s);
 		print_method_body(m,TRUE);
+		out_printf(out,"#undef PARENT_HANDLER\n");
 		break;
 	default:
 		break;
@@ -1051,7 +1183,8 @@ check_duplicate(Class *c,Node *node,char *id, int line_no)
 			continue;
 		if(n==node ||
 		   line_no>=nline_no ||
-		   strcmp(nid,id)!=0)
+		   strcmp(nid,id)!=0 ||
+		   n->type != node->type)
 			continue;
 		s = g_strdup_printf("symbol '%s' redefined, "
 				    "first defined on line %d",
@@ -1076,6 +1209,44 @@ check_duplicate_symbols(Class *c)
 	}
 }
 
+static void
+check_bad_symbols(Class *c)
+{
+	GList *l;
+	for(l=c->nodes;l;l=g_list_next(l)) {
+		Node *n = l->data;
+		if(n->type == METHOD_NODE) {
+			Method *m = (Method *)n;
+			if((m->scope == SIGNAL_LAST_METHOD ||
+			    m->scope == SIGNAL_FIRST_METHOD ||
+			    m->scope == PRIVATE_SIGNAL_LAST_METHOD ||
+			    m->scope == PRIVATE_SIGNAL_FIRST_METHOD ||
+			    m->scope == VIRTUAL_METHOD ||
+			    m->scope == PRIVATE_VIRTUAL_METHOD) &&
+			   strcmp(m->id,"__parent__")==0) {
+				char *s;
+				s = g_strdup_printf("'%s' not allowed as an "
+						    "identifier of signal "
+						    "or virtual methods",
+						    m->id);
+				print_error(FALSE,s,m->line_no);
+				g_free(s);
+			}
+		} else if(n->type == VARIABLE_NODE) {
+			Variable *v = (Variable *)n;
+			if(strcmp(v->id,"_priv")==0 ||
+			   strcmp(v->id,"__parent__")==0) {
+			char *s;
+				s = g_strdup_printf("'%s' not allowed as a data "
+						    "member name",v->id);
+				print_error(FALSE,s,v->line_no);
+				g_free(s);
+			}
+		}
+	}
+}
+
+
 static void
 check_duplicate_named(Class *c,Node *node,char *id, int line_no)
 {
@@ -1176,6 +1347,32 @@ check_vararg(Class *c)
 	}
 }
 
+static void
+check_firstarg(Class *c)
+{
+	GList *l;
+	for(l=c->nodes;l;l=g_list_next(l)) {
+		Node *n = l->data;
+		if(n->type == METHOD_NODE) {
+			Method *m = (Method *)n;
+			if(m->args)
+				continue;
+			if(m->scope == OVERRIDE_METHOD ||
+			   m->scope == SIGNAL_LAST_METHOD ||
+			   m->scope == SIGNAL_FIRST_METHOD ||
+			   m->scope == PRIVATE_SIGNAL_LAST_METHOD ||
+			   m->scope == PRIVATE_SIGNAL_FIRST_METHOD ||
+			   m->scope == VIRTUAL_METHOD ||
+			   m->scope == PRIVATE_VIRTUAL_METHOD) {
+				print_error(FALSE,
+					    "signals, overrides and virtuals, "
+					    "can't have no arguments",
+					    m->line_no);
+			}
+		}
+	}
+}
+
 static int
 count_signals(Class *c)
 {
@@ -1225,14 +1422,36 @@ count_overrides(Class *c)
 	return num;
 }
 
+static int
+count_privates(Class *c)
+{
+	int num = 0;
+	GList *l;
+	for(l=c->nodes;l;l=g_list_next(l)) {
+		Node *n = l->data;
+		if(n->type == VARIABLE_NODE) {
+			Variable *v = (Variable *)n;
+			if(v->scope == PRIVATE_SCOPE)
+				num++;
+		}
+	}
+	return num;
+}
+
 
 static void
 open_files(void)
 {
 	char *outfile,*outfileh;
 
-	outfile = g_strconcat(filebase,".c",NULL);
-	outfileh = g_strconcat(filebase,".h",NULL);
+	if(!for_cpp)
+		outfile = g_strconcat(filebase,".c",NULL);
+	else
+		outfile = g_strconcat(filebase,".cc",NULL);
+	if(no_touch_headers)
+		outfileh = g_strconcat("#gob#",filebase,".h#gob#",NULL);
+	else
+		outfileh = g_strconcat(filebase,".h",NULL);
 	
 	out = fopen(outfile,"w");
 	if(!out) {
@@ -1252,8 +1471,8 @@ generate_outfiles(void)
 	time_t curtime;
 
 	time(&curtime);
-	out_printf(outh,"/* Generated by GOB (v%s) on %s"
-	       "   (do not edit directly) */\n\n",VERSION,ctime(&curtime));
+	out_printf(outh,"/* 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));
 	
@@ -1263,12 +1482,16 @@ generate_outfiles(void)
 		"#include <gtk/gtk.h>\n\n",p,p);
 	g_free(p);
 
-	out_printf(outh,"#ifdef __cplusplus\n"
-		"extern \"C\" {\n"
-		"#endif /* __cplusplus */\n\n");
-	
-	out_printf(out,"#include \"%s.h\"\n\n",filebase);
+	if(!for_cpp)
+		out_printf(outh,"#ifdef __cplusplus\n"
+			   "extern \"C\" {\n"
+			   "#endif /* __cplusplus */\n\n");
 	
+	p = g_strconcat(filebase,".h",NULL);
+	if(!g_list_find_custom(include_files,p,(GCompareFunc)strcmp))
+		out_printf(out,"#include \"%s.h\"\n\n",filebase);
+	g_free(p);
+
 	for(li=nodes;li;li=g_list_next(li)) {
 		Node *node = li->data;
 		if(node->type == CCODE_NODE) {
@@ -1286,15 +1509,13 @@ generate_outfiles(void)
 			if(!cc->header)
 				out_addline_outfile(fp);
 		} else if(node->type == CLASS_NODE) {
-			GList *l;
 			Class *c = (Class *)class;
-			char *otype,*ptype;
+			GList *l;
 
-			signals = count_signals(c);
-			arguments = count_arguments(c);
-			overrides = count_overrides(c);
-			
-			out_printf(outh,"\n#define %s(obj)\t"
+			out_printf(outh,"\n#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"
@@ -1304,23 +1525,41 @@ generate_outfiles(void)
 				"GTK_CHECK_TYPE((obj), %s_get_type ())\n\n",
 				macrois,funcbase);
 
-			otype = remove_sep(c->otype);
-			ptype = remove_sep(c->ptype);
-			out_printf(outh,"\ntypedef struct _%s %s;\n",otype,otype);
+			if(privates>0)
+				out_printf(outh,"\ntypedef struct _%sPrivate %sPrivate;\n",typebase,typebase);
+
+			out_printf(outh,"\ntypedef struct _%s %s;\n",typebase,typebase);
 			out_printf(outh,"struct _%s {\n\t%s __parent__;\n",
-				   otype,ptype);
+				   typebase,ptypebase);
 			for(l=c->nodes;l;l=g_list_next(l)) {
 				Node *n = l->data;
 				if(n->type == VARIABLE_NODE)
-					put_variable((Variable *)n);
+					put_variable((Variable *)n,outh,FALSE);
 			}
+			if(privates>0)
+				out_printf(outh,"\t%sPrivate *_priv;\n",typebase);
 			out_printf(outh,"};\n");
 
+			if(privates>0) {
+				out_printf(out,"struct _%sPrivate {\n",
+					   typebase);
+				for(l=c->nodes;l;l=l->next) {
+					Node *n = l->data;
+					if(n->type == VARIABLE_NODE) {
+						Variable *v = (Variable *)n;
+						out_addline_infile(out,v->line_no);
+						put_variable(v,out,TRUE);
+					}
+				}
+				out_addline_outfile(out);
+				out_printf(out,"};\n");
+			}
+
 			out_printf(outh,"\ntypedef struct _%sClass %sClass;\n",
-				otype,otype);
+				typebase,typebase);
 			out_printf(outh,
 				"struct _%sClass {\n\t%sClass __parent__;\n",
-				otype,ptype);
+				typebase,ptypebase);
 			for(l=c->nodes;l;l=g_list_next(l)) {
 				Node *n = l->data;
 				if(n->type == METHOD_NODE)
@@ -1360,11 +1599,11 @@ generate_outfiles(void)
 			
 			add_get_type();
 
-			def_methods(c);
+			make_method_pointers(c);
 
 			out_printf(out,"#define GET_NEW (gtk_type_new(%s_get_type()))\n",
-				funcbase);
-			
+				   funcbase);
+
 			add_inits(c);
 
 			if(arguments>0) {
@@ -1381,18 +1620,16 @@ generate_outfiles(void)
 
 			out_printf(out,"#undef GET_NEW\n");
 
-			undef_methods(c);
-
-			g_free(otype);
-			g_free(ptype);
+			add_bad_hack_to_avoid_unused_warnings(c);
 		} else
 			g_assert_not_reached();
 	}
 
-	out_printf(outh,"\n#ifdef __cplusplus\n"
-		"}\n"
-		"#endif /* __cplusplus */\n\n"
-		"#endif");
+	if(!for_cpp)
+		out_printf(outh,"\n#ifdef __cplusplus\n"
+			   "}\n"
+			   "#endif /* __cplusplus */\n");
+	out_printf(outh,"\n#endif");
 }
 
 #if 0
@@ -1412,7 +1649,10 @@ print_help(void)
 	fprintf(stderr,"Options:\n"
 		"\t--help,-h,-?         Display this help\n"
 		"\t--exit-on-warn,-w	Exit with an error on warnings\n"
-		"\t--no-exit-on-warn	Don't exit on warnings [default]\n");
+		"\t--no-exit-on-warn	Don't exit on warnings [default]\n"
+		"\t--for-cpp            Create C++ files\n"
+		"\t--no-touch-headers   Don't touch headers unless they "
+		                       "really changed\n");
 }
 
 static void
@@ -1441,6 +1681,10 @@ parse_options(int argc, char *argv[])
 			exit_on_warn = TRUE;
 		} else if(strcmp(argv[i],"--no-exit-on-warn")==0) {
 			exit_on_warn = FALSE;
+		} else if(strcmp(argv[i],"--for-cpp")==0) {
+			for_cpp = TRUE;
+		} else if(strcmp(argv[i],"--no-touch-headers")==0) {
+			no_touch_headers = TRUE;
 		} else if(strcmp(argv[i],"--")==0) {
 			/*further arguments are files*/
 			no_opts = TRUE;
@@ -1473,6 +1717,33 @@ parse_options(int argc, char *argv[])
 	}
 }
 
+static void
+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) {
+		char *s;
+		s = g_strdup_printf("cmp '%s' '%s' > /dev/null",hf,hfnew);
+		if(system(s)==0) {
+			if(unlink(hfnew)!=0)
+				print_error(FALSE,"Can't remove new header file",0);
+			g_free(hfnew);
+			g_free(hf);
+			g_free(s);
+			return;
+		}
+		g_free(s);
+		if(unlink(hf)!=0)
+			print_error(FALSE,"Can't remove old header file",0);
+	}
+	if(rename(hfnew,hf)!=0)
+		print_error(FALSE,"Can't rename new header file",0);
+	g_free(hfnew);
+	g_free(hf);
+}
+
 int
 main(int argc, char *argv[])
 {
@@ -1525,14 +1796,25 @@ main(int argc, char *argv[])
 	if(!class)
 		print_error(FALSE," no class defined",0);
 	
-	make_bases();
-	
+
 	exit_on_error = FALSE;
+
+	signals = count_signals((Class *)class);
+	arguments = count_arguments((Class *)class);
+	overrides = count_overrides((Class *)class);
+	privates = count_privates((Class *)class);
+
+	make_bases();
 	make_inits((Class *)class);
+	if(privates>0)
+		make_destroy((Class *)class);
+	check_bad_symbols((Class *)class);
 	check_duplicate_symbols((Class *)class);
 	check_duplicate_signals_args((Class *)class);
 	check_public_new((Class *)class);
 	check_vararg((Class *)class);
+	check_firstarg((Class *)class);
+
 	exit_on_error = TRUE;
 	
 	if(got_error)
@@ -1544,6 +1826,9 @@ main(int argc, char *argv[])
 
 	fclose(out);
 	fclose(outh);
+
+	if(no_touch_headers)
+		compare_and_move_header();
 	
 #if 0
 	poptFreeContext(optCon);