/* GOB C Preprocessor
 * Copyright (C) 1999 the Free Software Foundation.
 *
 * Author: George Lebl
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the  Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */

#include "config.h"
#include <glib.h>
#if 0
#include <popt.h>
#endif
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>

#include "tree.h"
#include "parse.h"
#include "out.h"
#include "main.h"

char *filename = NULL;

int yyparse(void);

extern int yydebug;
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; /* 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 */

static gboolean made_aliases = FALSE;  /* if we made any shorthand aliases
					  and need the REALLY UGLY HACK to
					  avoid warnings */

FILE *out = NULL;
FILE *outh = NULL;
FILE *outph = NULL;

gboolean no_touch_headers = FALSE;
gboolean for_cpp = 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;

void
print_error(int is_warn, char *error,int line)
{
	char *w;
	if(is_warn)
		w = "Warning:";
	else {
		w = "Error:";
		got_error = TRUE;
	}
	if(line>0)
		fprintf(stderr,"%s:%d: %s %s\n",filename,line,w,error);
	else
		fprintf(stderr,"%s: %s %s\n",filename,w,error);
	if((!is_warn || exit_on_warn) && exit_on_error)
		exit(1);
}

static char *
remove_sep(char *base)
{
	char *p;
	char *s = g_strdup(base);
	while((p=strchr(s,':')))
		strcpy(p,p+1);
	return s;
}

static char *
replace_sep(char *base, char r)
{
	char *p;
	char *s = g_strdup(base);
	while((p=strchr(s,':')))
		*p = r;
	if(*s == r) {
		p = g_strdup(s+1);
		g_free(s);
		return p;
	}
	return s;
}

/*separate the namespace part and then replace rest of
  separators with r*/
static void
separns_replace_sep(char *base, char **ns, char **name, char r)
{
	char *p;
	char *s = g_strdup(base);
	*ns = NULL;
	if((p=strchr(s,':')) && p!=s) {
		*p = '\0';
		*ns = g_strdup(s);
		p = g_strdup(p+1);
		g_free(s);
		s = p;
	}
	while((p=strchr(s,':')))
		*p = r;
	if(*s == r) {
		*name = g_strdup(s+1);
		g_free(s);
	} else
		*name = s;
}

/* make a macro with some prefix before the name but after
   namespace */
static char *
make_pre_macro(char *base, char *pre)
{
	char *s1,*s2;
	char *s;

	separns_replace_sep(base,&s1,&s2,'_');
	if(s1)
		s = g_strconcat(s1,"_",pre,"_",s2,NULL);
	else
		s = g_strconcat(pre,"_",s2,NULL);

	g_strup(s);
	
	g_free(s1);
	g_free(s2);

	return s;
}

static void
make_bases(void)
{
	filebase = replace_sep(((Class *)class)->otype,'-');
	g_strdown(filebase);

	funcbase = replace_sep(((Class *)class)->otype,'_');
	g_strdown(funcbase);

	pfuncbase = replace_sep(((Class *)class)->ptype,'_');
	g_strdown(pfuncbase);

	macrobase = replace_sep(((Class *)class)->otype,'_');
	g_strup(macrobase);
	
	macrois = make_pre_macro(((Class *)class)->otype,"IS");
	macrotype = make_pre_macro(((Class *)class)->otype,"TYPE");

	typebase = remove_sep(((Class *)class)->otype);

	ptypebase = remove_sep(((Class *)class)->ptype);
}

static void
print_type(FILE *fp, Type *t, gboolean postfix_to_stars)
{
	char *s;
	int i;
	int extra;

	s = remove_sep(t->name);
	out_printf(fp,"%s ",s); 
	g_free(s);

	extra = 0;
	if(postfix_to_stars) {
		char *p;
		/*XXX: this is ugly perhaps we can do this whole postfix thing
		  in a nicer way, we just count the number of '[' s and from that
		  we deduce the number of dimensions */
		for(p=t->postfix; p && *p; p++)
			if(*p == '[') extra++;
	}
	
	for(i=0;i<(t->stars+extra);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,TRUE);
	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,FALSE);
			if(li->next)
				out_printf(fp,"%s%s, ",arg->name,
					   arg->atype->postfix?
					   arg->atype->postfix:""); 
			else
				out_printf(fp,"%s%s",arg->name,
					   arg->atype->postfix?
					   arg->atype->postfix:""); 
		}
		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;
	
	out_printf(out,"\n");
	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;

			/* 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);

			made_aliases = TRUE;
		}
	}
	out_printf(out,"\n");
}

static void
add_bad_hack_to_avoid_unused_warnings(Class *c)
{
	GList *li;

	/* if we haven't had any methods, just return */
	if(!made_aliases)
		return;
	
	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;

			/* in C++ mode we don't alias new */
			if(for_cpp && strcmp(m->id,"new")==0)
				continue;

			out_printf(out,"\t((void (*)(void))%s)();\n",m->id);
		}
	}
	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;\n",v->id,
		   v->vtype->postfix?
		   v->vtype->postfix:""); 
}

static void
put_vs_method(Method *m)
{
	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)
		return;

	print_method(outh,"\t","(* ",") ",";\n",m,TRUE);
}

static void
put_pub_method(Method *m)
{
	if(m->scope == PRIVATE_SCOPE ||
	   m->scope == OVERRIDE_METHOD ||
	   m->scope == INIT_METHOD ||
	   m->scope == CLASS_INIT_METHOD ||
	   m->scope == PRIVATE_SIGNAL_LAST_METHOD ||
	   m->scope == PRIVATE_SIGNAL_FIRST_METHOD ||
	   m->scope == PRIVATE_VIRTUAL_METHOD)
		return;

	print_method(outh,"","\t","\t",";\n",m,FALSE);
}

static void
put_priv_method_prot(Method *m)
{
	if(m->scope == PUBLIC_SCOPE)
		return;

	if(m->scope == PRIVATE_SIGNAL_LAST_METHOD ||
	   m->scope == PRIVATE_SIGNAL_FIRST_METHOD ||
	   m->scope == PRIVATE_VIRTUAL_METHOD) {
		if(m->cbuf && *m->cbuf->str)
			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 || !*m->cbuf->str)
			return;
		print_method(out,"static ","_real_"," ",";\n",m,FALSE);
	} else {
		print_method(out,"static ",""," ",";\n",m,FALSE);
	}
}

static GList *
make_func_arg(char *typename, int is_class, char *name)
{
	Node *node;
	Node *type;
	char *tn;
	
	if(is_class)
		tn = g_strconcat(typename,":Class",NULL);
	else
		tn = g_strdup(typename);

	type = new_type(1,tn,NULL);
	node = new_funcarg((Type *)type,name,NULL);
	return g_list_prepend(NULL, node);
}

static void
make_inits(Class *cl)
{
	int got_class_init = FALSE;
	int got_init = 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 == INIT_METHOD) {
				if(got_init)
					print_error(FALSE,"init defined more then once",m->line_no);
				got_init = TRUE;
			} else if(m->scope == CLASS_INIT_METHOD) {
				if(got_class_init)
					print_error(FALSE,"class_init defined more then once",m->line_no);
				got_class_init = TRUE;
			}
		}
	}
	if(!got_class_init) {
		node = new_method(CLASS_INIT_METHOD,
				  (Type *)new_type(0,g_strdup("void"),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);
	}
	if(!got_init) {
		node = new_method(INIT_METHOD,
				  (Type *)new_type(0,g_strdup("void"),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);
	}
}

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"),NULL),
				  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
add_signal_prots(Method *m)
{
	GList *li;
	static int sig = 1;
	char *s;
	
	if(m->scope != SIGNAL_LAST_METHOD &&
	   m->scope != SIGNAL_FIRST_METHOD &&
	   m->scope != PRIVATE_SIGNAL_LAST_METHOD &&
	   m->scope != PRIVATE_SIGNAL_FIRST_METHOD)
		return;

	if(!marsh)
		marsh = g_hash_table_new(NULL,NULL);
	
	if(strcmp(m->gtktypes->data,"NONE")==0 &&
	   strcmp(m->gtktypes->next->data,"NONE")==0)
		return;
	
	s = g_strdup_printf("__Sig%d",sig++);
	
	g_hash_table_insert(marsh,m,s);
	
	out_printf(out,"\ntypedef ");
	print_type(out,m->mtype,TRUE);
	
	out_printf(out,"(*%s) (",s);
	
	for(li=m->args;li;li=g_list_next(li)) {
		FuncArg *arg = li->data;
		print_type(out,arg->atype,TRUE);
		out_printf(out,", ");
	}
	out_printf(out,"gpointer);\n"); 
	
	out_printf(out,"\nstatic void\n"
		"marshal_%s (GtkObject * object,\n"
		"\tGtkSignalFunc func,\n"
		"\tgpointer func_data,\n"
		"\tGtkArg * args)\n"
		"{\n",s);
	
	if(strcmp(m->gtktypes->data,"NONE")==0) {
		int i;
		out_printf(out, "\t%s rfunc;\n\n"
			"\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)) {
				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,TRUE);
					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");
	} else {
		int i;
		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);
		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)) {
				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,TRUE);
					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");
	}

}

static void
add_enums(Class *c)
{
	GList *li;
	out_printf(out,"\n");
	if(signals>0) {
		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->scope == SIGNAL_LAST_METHOD ||
				   m->scope == SIGNAL_FIRST_METHOD ||
				   m->scope == PRIVATE_SIGNAL_LAST_METHOD ||
				   m->scope == PRIVATE_SIGNAL_FIRST_METHOD) {
					char *s = g_strdup(m->id);
					g_strup(s);
					out_printf(out,"\t%s_SIGNAL,\n",s);
					g_free(s);
				}
			}
		}
		out_printf(out,"\tLAST_SIGNAL\n};\n\n");
	}
	if(arguments>0) {
		out_printf(out,"enum {\n\tARG_0,\n");
		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,"\tARG_%s,\n",s);
				g_free(s);
			}
		}
		out_printf(out, "};\n\n");
	}

	if(signals>0)
		out_printf(out,
			   "static guint object_signals[LAST_SIGNAL] = {0};\n\n");

	out_printf(out, "static %sClass *parent_class = NULL;\n\n",ptypebase);
}

static void
add_get_type(void)
{
	out_printf(out, "guint\n"
		"%s_get_type (void)\n"
		"{\n"
		"\tstatic guint type = 0;\n\n"
		"\tif (!type) {\n"
		"\t\tstatic const GtkTypeInfo info = {\n"
		"\t\t\t\"%s\",\n"
		"\t\t\tsizeof (%s),\n"
		"\t\t\tsizeof (%sClass),\n"
		"\t\t\t(GtkClassInitFunc) %s_class_init,\n"
		"\t\t\t(GtkObjectInitFunc) %s_init,\n"
		"\t\t\t/* reserved_1 */ NULL,\n"
		"\t\t\t/* reserved_2 */ NULL,\n"
		"\t\t\t(GtkClassInitFunc) NULL,\n"
		"\t\t};\n\n"
		"\t\ttype = gtk_type_unique (%s_get_type(), &info);\n"
		"\t}\n\n"
		"\treturn type;\n"
		"}\n\n",
		funcbase,typebase,typebase,typebase,
		funcbase,funcbase,pfuncbase);
}

static void
add_overrides(Class *c, char *oname, gboolean did_gtk_obj)
{
	GList *li;
	GHashTable *done;
	char *s;
	
	done = g_hash_table_new(g_str_hash,g_str_equal);
	if(did_gtk_obj) {
		s = g_strdup("GtkObject"); /* This was already done */
		g_hash_table_insert(done,s,s);
	}
	for(li=c->nodes;li;li=g_list_next(li)) {
		Node *n = li->data;
		char *f;
		Method *m;
		if(n->type != METHOD_NODE ||
		   ((Method *)n)->scope != OVERRIDE_METHOD)
			continue;
		m = (Method *)n;
		
		s = remove_sep(m->otype);
		
		if(g_hash_table_lookup(done,s)) {
			g_free(s);
			continue;
		}
		g_hash_table_insert(done,s,s);

		f = replace_sep(m->otype,'_');
		g_strdown(f);

		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_destroy(done);
}

static void
add_signals(Class *c)
{
	GList *li;

	out_printf(out,"\n");
	for(li=c->nodes;li;li=g_list_next(li)) {
		Node *n = li->data;
		Method *m;
		char *mar;
		char *sig;
		int is_none;
		int last = FALSE;
		if(n->type != METHOD_NODE ||
		   (((Method *)n)->scope != SIGNAL_FIRST_METHOD &&
		    ((Method *)n)->scope != SIGNAL_LAST_METHOD &&
		    ((Method *)n)->scope != PRIVATE_SIGNAL_FIRST_METHOD &&
		    ((Method *)n)->scope != PRIVATE_SIGNAL_LAST_METHOD))
			continue;

		m = (Method *)n;
		
		if(m->scope == SIGNAL_FIRST_METHOD ||
		   m->scope == PRIVATE_SIGNAL_FIRST_METHOD)
			last = FALSE;
		else
			last = TRUE;

		if(g_hash_table_lookup(marsh,m))
			mar = g_strconcat("marshal_",
					  (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);
		g_strup(sig);
		out_printf(out,"\tobject_signals[%s_SIGNAL] =\n"
    			"\t\tgtk_signal_new (\"%s\",\n"
			"\t\t\tGTK_RUN_%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,
			last?"LAST":"FIRST",
			typebase,m->id,mar,(char *)m->gtktypes->data,
			is_none?0:g_list_length(m->gtktypes->next));
		g_free(mar);
		g_free(sig);
		
		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",
					(char *)l->data);
		}

		out_printf(out,");\n");
	}
	out_printf(out,"\tgtk_object_class_add_signals (gtk_object_class,\n"
		"\t\tobject_signals, LAST_SIGNAL);\n\n");
}

static void
set_def_handlers(Class *c, char *oname)
{
	GList *li;

	out_printf(out,"\n");
	for(li=c->nodes;li;li=g_list_next(li)) {
		Node *n = li->data;
		Method *m;
		if(n->type != METHOD_NODE ||
		   (((Method *)n)->scope != SIGNAL_FIRST_METHOD &&
		    ((Method *)n)->scope != SIGNAL_LAST_METHOD &&
		    ((Method *)n)->scope != PRIVATE_SIGNAL_FIRST_METHOD &&
		    ((Method *)n)->scope != PRIVATE_SIGNAL_LAST_METHOD &&
		    ((Method *)n)->scope != VIRTUAL_METHOD &&
		    ((Method *)n)->scope != PRIVATE_VIRTUAL_METHOD &&
		    ((Method *)n)->scope != OVERRIDE_METHOD))
			continue;

		m = (Method *)n;

		if(m->scope == OVERRIDE_METHOD) {
			char *s;
			s = replace_sep(m->otype,'_');
			g_strdown(s);
			out_printf(out,"\t%s_class->%s = %s_%s;\n",
				s,m->id,funcbase,m->id);
		} else {
			if(m->cbuf && *m->cbuf->str)
				out_printf(out,"\t%s->%s = _real_%s_%s;\n",
					oname,m->id,funcbase,m->id);
			else
				out_printf(out,"\t%s->%s = NULL;\n",
					oname,m->id);
		}
	}
}

static void
make_arguments(Class *c)
{
	GList *li;

	out_printf(out,"\n");
	for(li=c->nodes;li;li=g_list_next(li)) {
		Node *n = li->data;
		Argument *a;
		GString *flags;
		GList *l;
		char *s;
		if(n->type != ARGUMENT_NODE)
			continue;

		a = (Argument *)n;
		
		if(a->get && a->set)
			flags = g_string_new("GTK_ARG_READWRITE");
		else if(a->get)
			flags = g_string_new("GTK_ARG_READABLE");
		else
			flags = g_string_new("GTK_ARG_WRITABLE");
		
		for(l=a->flags;l;l=g_list_next(l))
			g_string_sprintfa(flags," | GTK_ARG_%s",(char *)l->data);

		s = g_strdup(a->name);
		g_strup(s);
		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);
		g_free(s);
		g_string_free(flags,TRUE);
	}
	
	out_printf(out,
		   "\n\tgtk_object_class->set_arg = __object_set_arg;\n"
		   "\tgtk_object_class->get_arg = __object_get_arg;\n");
}

static void
add_inits(Class *c)
{
	GList *li;
	for(li=c->nodes;li;li=g_list_next(li)) {
		Node *n = li->data;
		Method *m;
		if(n->type != METHOD_NODE)
			continue;
		m = (Method *)n;
		if(m->scope == INIT_METHOD) {
			if(m->line_no>0)
				out_addline_infile(out,m->line_no);
			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"," ","\n",m,FALSE);
			if(m->line_no>0)
				out_addline_outfile(out);
			out_printf(out,"{\n");
			if(signals>0 ||
			   arguments>0)
				out_printf(out,
					   "\tGtkObjectClass *"
					   "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 = ");
			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);

			set_def_handlers(c, ((FuncArg *)m->args->data)->name);
			
			if(arguments>0)
				make_arguments(c);

		} else
			continue;

		if(m->cbuf && *m->cbuf->str) {
			out_printf(out," {\n");
			out_addline_infile(out,m->ccode_line);
			out_printf(out,"%s\n",m->cbuf->str);
			out_addline_outfile(out);
			out_printf(out," }\n",m->cbuf->str);
		} else {
			out_printf(out,"return;\n");
		}
		out_printf(out,"}\n");
	}
}

static void
add_getset_arg(Class *c, int 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);

	for(li=c->nodes;li;li=g_list_next(li)) {
		Node *n = li->data;
		Argument *a;
		char *s;
		GString *cbuf;
		int line_no;
		if(n->type != ARGUMENT_NODE)
			continue;
		a = (Argument *)n;
		if(is_set) {
			cbuf = a->set;
			line_no = a->set_line;
		} else {
			cbuf = a->get;
			line_no = a->get_line;
		}
		if(!cbuf)
			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);
		g_free(s);
		out_addline_infile(out,line_no);
		out_printf(out,"%s\n",cbuf->str);
		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");
}

static void
print_checks(Method *m, FuncArg *fa)
{
	GList *li;
	int is_void;
	is_void = (strcmp(m->mtype->name,"void")==0 &&
		   m->mtype->stars == 0);
	
	for(li=fa->checks;li;li=g_list_next(li)) {
		Check *ch = li->data;
		char *s;
		if(is_void)
			out_printf(out,"\tg_return_if_fail (");
		else
			out_printf(out,"\tg_return_val_if_fail (");
		switch(ch->chtype) {
		case NULL_CHECK:
			out_printf(out,"%s != NULL",fa->name);
			break;
		case TYPE_CHECK:
			s = make_pre_macro(fa->atype->name,"IS");
			out_printf(out,"%s (%s)",s,fa->name);
			g_free(s);
			break;
		case LT_CHECK:
			out_printf(out,"%s < %s",fa->name,ch->number);
			break;
		case GT_CHECK:
			out_printf(out,"%s > %s",fa->name,ch->number);
			break;
		case LE_CHECK:
			out_printf(out,"%s <= %s",fa->name,ch->number);
			break;
		case GE_CHECK:
			out_printf(out,"%s >= %s",fa->name,ch->number);
			break;
		case EQ_CHECK:
			out_printf(out,"%s == %s",fa->name,ch->number);
			break;
		case NE_CHECK:
			out_printf(out,"%s != %s",fa->name,ch->number);
			break;
		}
		if(is_void)
			out_printf(out,");\n");
		else {
			out_printf(out,", (");
			print_type(out,m->mtype,TRUE);
			out_printf(out,")%s);\n",
				m->onerror?m->onerror:"0");
		}
	}
}

static void
print_preconditions(Method *m)
{
	GList *li;
	
	for(li=m->args;li;li=g_list_next(li)) {
		FuncArg *fa = li->data;
		if(fa->checks)
			print_checks(m,fa);
	}
}

/* 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)
		print_preconditions(m);
	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);

	out_printf(out,"\t}\n");
	out_printf(out,"}\n");
}

static void
put_method(Method *m)
{
	char *s;
	int private = FALSE;
	int is_void;
	is_void = (strcmp(m->mtype->name,"void")==0 &&
		   m->mtype->stars == 0);
	out_printf(out,"\n");
	switch(m->scope) {
	case PUBLIC_SCOPE:
		out_addline_infile(out,m->line_no);
		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"," ","\n",m,FALSE);
		print_method_body(m,TRUE);
		break;
	case PRIVATE_SIGNAL_FIRST_METHOD:
	case PRIVATE_SIGNAL_LAST_METHOD:
		private = TRUE;
	case SIGNAL_FIRST_METHOD:
	case SIGNAL_LAST_METHOD:
		out_addline_infile(out,m->line_no);
		print_method(out,private?"static ":"","\n"," ","\n",m,FALSE);
		out_addline_outfile(out);
		out_printf(out,"{\n");
		s = g_strdup(m->id);
		g_strup(s);
		if(strcmp(m->mtype->name,"void")==0 &&
		   m->mtype->stars==0) {
			GList *li;
			print_preconditions(m);
			if(((FuncArg *)m->args->data)->name)
			out_printf(out,"\tgtk_signal_emit (GTK_OBJECT (%s),\n"
				"\t\tobject_signals[%s_SIGNAL]",
				((FuncArg *)m->args->data)->name,s);
			for(li=m->args->next;li;li=g_list_next(li)) {
				FuncArg *fa = li->data;
				out_printf(out,",\n\t\t%s",fa->name);
			}
			out_printf(out,");\n}\n");
		} else {
			GList *li;
			out_printf(out,"\t");
			print_type(out,m->mtype,TRUE);
			out_printf(out,"return_val;\n");
			print_preconditions(m);
			out_printf(out,"\tgtk_signal_emit (GTK_OBJECT (%s),\n"
				"\t\tobject_signals[%s_SIGNAL]",
				((FuncArg *)m->args->data)->name,s);
			for(li=m->args->next;li;li=g_list_next(li)) {
				FuncArg *fa = li->data;
				out_printf(out,",\n\t\t%s",fa->name);
			}
			out_printf(out,",\n\t\t&return_val);\n"
				"\treturn return_val;\n}\n");
		}

		if(!m->cbuf || !*m->cbuf->str)
			break;
		out_addline_infile(out,m->line_no);
		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"," ","\n",m,FALSE);
		out_addline_outfile(out);
		out_printf(out,"{\n"
			"\t%sClass *klass;\n",typebase);
		print_preconditions(m);
		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(*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;
				out_printf(out,",%s",fa->name);
			}
			out_printf(out,");\n}\n");
		} else {
			GList *li;
			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;
				out_printf(out,",%s",fa->name);
			}
			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");
		}

		if(!m->cbuf || !*m->cbuf->str)
			break;
		out_addline_infile(out,m->line_no);
		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"," ","\n",m,FALSE);
		s = replace_sep(m->otype,'_');
		g_strup(s);
		if(is_void) {
			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);
		} else {
			out_printf(out,"#define PARENT_HANDLER(args...) \\\n"
				   "\t((%s_CLASS(parent_class)->%s)? \\\n"
				   "\t\t(* %s_CLASS(parent_class)->%s)(##args): \\\n"
				   "\t\t(",
				   s,m->id,s,m->id);
			out_printf(out,"(");
			print_type(out,m->mtype,TRUE);
			out_printf(out,")%s))\n",
				   m->onerror?m->onerror:"0");
		}
		g_free(s);
		print_method_body(m,TRUE);
		out_printf(out,"#undef PARENT_HANDLER\n");
		break;
	default:
		break;
	}
}

static void
check_duplicate(Class *c,Node *node,char *id, int line_no)
{
	GList *l;
	for(l=c->nodes;l;l=g_list_next(l)) {
		Node *n = l->data;
		char *nid;
		int nline_no;
		char *s;
		if(n->type == METHOD_NODE) {
			Method *m = (Method *)n;
			nid = m->id;
			nline_no = m->line_no;
		} else if(n->type == VARIABLE_NODE) {
			Variable *v = (Variable *)n;
			nid = v->id;
			nline_no = v->line_no;
		} else
			continue;
		if(n==node ||
		   line_no>=nline_no ||
		   strcmp(nid,id)!=0 ||
		   n->type != node->type)
			continue;
		s = g_strdup_printf("symbol '%s' redefined, "
				    "first defined on line %d",
				    id,line_no);
		print_error(FALSE,s,nline_no);
	}
}

static void
check_duplicate_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;
			check_duplicate(c,n,m->id,m->line_no);
		} else if(n->type == VARIABLE_NODE) {
			Variable *v = (Variable *)n;
			check_duplicate(c,n,v->id,v->line_no);
		}
	}
}

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)
{
	GList *l;
	for(l=c->nodes;l;l=g_list_next(l)) {
		Node *n = l->data;
		char *nid;
		int nline_no;
		char *s;
		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) {
				nid = m->id;
				nline_no = m->line_no;
			} else
				continue;
		} else if(n->type == ARGUMENT_NODE) {
			Argument *a = (Argument *)n;
			nid = a->name;
			nline_no = a->line_no;
		} else
			continue;
		if(n==node ||
		   line_no>=nline_no ||
		   strcmp(nid,id)!=0)
			continue;
		s = g_strdup_printf("named symbol (argument or signal) '%s' "
				    "redefined, first defined on line %d",
				    id,line_no);
		print_error(FALSE,s,nline_no);
	}
}

static void
check_duplicate_signals_args(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)
				check_duplicate_named(c,n,m->id,m->line_no);
		} else if(n->type == ARGUMENT_NODE) {
			Argument *a = (Argument *)n;
			check_duplicate_named(c,n,a->name,a->line_no);
		}
	}
}

static void
check_public_new(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!=PUBLIC_SCOPE &&
			   strcmp(m->id,"new")==0)
				print_error(TRUE,
					    "'new' should be a public method",
					    m->line_no);
		}
	}
}

static void
check_vararg(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->vararg)
				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 variable argument "
					    "lists",
					    m->line_no);
			}
		}
	}
}

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)
{
	int num = 0;
	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)
				num++;
		}
	}
	return num;
}

static int
count_arguments(Class *c)
{
	int num = 0;
	GList *li;

	for(li=c->nodes;li;li=g_list_next(li)) {
		Node *n = li->data;
		if(n->type == ARGUMENT_NODE)
			num ++;
	}
	return num;
}

static int
count_overrides(Class *c)
{
	int num = 0;
	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 == OVERRIDE_METHOD)
				num++;
		}
	}
	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,*outfileph;

	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);

	if((privates>0 || always_private_header) &&
	   !no_private_header)
		outfileph = g_strconcat(filebase,"-private.h",NULL);
	else
		outfileph = NULL;

	
	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);
	}
	if(outfileph) {
		outph = fopen(outfileph,"w");
		if(!outph) {
			g_error("Cannot open outfile: %s",outfileh);
		}
	}
}

static void
generate_outfiles(void)
{
	char *p;
	GList *li;
	time_t curtime;
	gboolean found_header;

	time(&curtime);
	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));
	
	p = replace_sep(((Class *)class)->otype,'_');
	g_strup(p);
	out_printf(outh,"#ifndef __%s_H__\n#define __%s_H__\n\n"
		"#include <gtk/gtk.h>\n\n",p,p);
	if(outph)
		out_printf(outph,"#ifndef __%s_PRIVATE_H__\n"
			   "#define __%s_PRIVATE_H__\n\n"
			   "#include \"%s.h\"\n\n",p,p,filebase);
	g_free(p);

	if(!for_cpp) {
		out_printf(outh,"#ifdef __cplusplus\n"
			   "extern \"C\" {\n"
			   "#endif /* __cplusplus */\n\n");
		if(outph)
			out_printf(outph,"#ifdef __cplusplus\n"
				   "extern \"C\" {\n"
				   "#endif /* __cplusplus */\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);
		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",
				   filebase);
			if(found_header)
				print_error(TRUE,
					    "Implicit private header include "
					    "added to top of\n"
					    "\tsource file, while public "
					    "header is at a custom location, "
					    "you should\n"
					    "\texplicitly include "
					    "the private header below the "
					    "public one.", 0);
		}
		g_free(p);
	}

	for(li=nodes;li;li=g_list_next(li)) {
		Node *node = li->data;
		if(node->type == CCODE_NODE) {
			CCode *cc = (CCode *)node;
			FILE *fp;
			if(cc->header) {
				fp = outh;
				out_printf(fp,"\n");
			} else {
				fp = out;
				out_printf(fp,"\n");
				out_addline_infile(fp,cc->line_no);
			}
			out_printf(fp,"%s\n",cc->cbuf->str);
			if(!cc->header)
				out_addline_outfile(fp);
		} else if(node->type == CLASS_NODE) {
			Class *c = (Class *)class;
			GList *l;

			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"
				"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);

			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",
				   typebase,ptypebase);
			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 == PUBLIC_SCOPE)
					put_variable((Variable *)n,outh);
			}
			if(privates>0)
				out_printf(outh,"\t%sPrivate *_priv;\n",typebase);
			out_printf(outh,"};\n");

			if(privates>0) {
				FILE *outfp;

				/* if we are to stick this into the private
				   header, otherwise stick it directly into the
				   C file */
				if(outph) 
					outfp = outph;
				else
					outfp = out;

				out_printf(outfp,"struct _%sPrivate {\n",
					   typebase);
				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_outfile(outfp);
				out_printf(outfp,"};\n");
			}

			out_printf(outh,"\ntypedef struct _%sClass %sClass;\n",
				typebase,typebase);
			out_printf(outh,
				"struct _%sClass {\n\t%sClass __parent__;\n",
				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");

			out_printf(outh,"guint\t%s_get_type\t(void);\n",funcbase);
			
			if(arguments>0) {
				out_printf(out,"static void __object_set_arg "
					   "(GtkObject *object, GtkArg *arg, "
					   "guint arg_id);\n"
					   "static void __object_get_arg "
					   "(GtkObject *object, GtkArg *arg, "
					   "guint arg_id);\n");
			}

			for(l=c->nodes;l;l=g_list_next(l)) {
				Node *n = l->data;
				if(n->type == METHOD_NODE) {
					put_pub_method((Method *)n);
					put_priv_method_prot((Method *)n);
				}
			}

			if(signals>0) {
				for(l=c->nodes;l;l=g_list_next(l)) {
					Node *n = l->data;
					if(n->type == METHOD_NODE) {
						add_signal_prots((Method *)n);
					}
				}
			}
			
			add_enums(c);
			
			add_get_type();

			make_method_pointers(c);

			out_printf(out,"#define GET_NEW (gtk_type_new(%s_get_type()))\n",
				   funcbase);

			add_inits(c);

			if(arguments>0) {
				add_getset_arg(c, TRUE);
				add_getset_arg(c, FALSE);
			}

			for(l=c->nodes;l;l=g_list_next(l)) {
				Node *n = l->data;
				if(n->type == METHOD_NODE) {
					put_method((Method *)n);
				}
			}

			out_printf(out,"#undef GET_NEW\n");

			add_bad_hack_to_avoid_unused_warnings(c);
		} else
			g_assert_not_reached();
	}

	if(!for_cpp)
		out_printf(outh,"\n#ifdef __cplusplus\n"
			   "}\n"
			   "#endif /* __cplusplus */\n");
	out_printf(outh,"\n#endif");
	if(outph) {
		if(!for_cpp)
			out_printf(outph,"\n#ifdef __cplusplus\n"
				   "}\n"
				   "#endif /* __cplusplus */\n");
		out_printf(outph,"\n#endif");
	}
}

#if 0
static void
usage(poptContext optCon, int exitcode, char *error, char *addl)
{
	poptPrintUsage(optCon, stderr, 0);
	if (error) fprintf(stderr, "%s: %s", error, addl);
	exit(exitcode);
}
#endif

static void
print_help(void)
{
	fprintf(stderr,"Gob version %s\n\n",VERSION);
	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--for-cpp               Create C++ files\n"
		"\t--no-touch-headers      Don't touch headers unless they "
		                          "really changed\n"
		"\t--always-private-header Always create a private header "
					  "file, even if it would be empty\n"
		"\t--no-private-header     Don't create a private header, "
					  "put private structure inside c "
					  "file\n");
}

static void
parse_options(int argc, char *argv[])
{
	int i;
	int got_file = FALSE;
	int no_opts = FALSE;

	filename = NULL;

	for(i=1;i<argc;i++) {
		if(no_opts || argv[i][0]!='-') {
			/*must be a file*/
			if(got_file) {
				fprintf(stderr,"Specify only one file!\n");
				print_help();
				exit(1);
			}
			filename = argv[i];
			got_file = TRUE;
		} else if(strcmp(argv[i],"--help")==0) {
			print_help();
			exit(0);
		} else if(strcmp(argv[i],"--exit-on-warn")==0) {
			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],"--always-private-header")==0) {
			no_private_header = FALSE;
			always_private_header = TRUE;
		} else if(strcmp(argv[i],"--no-private-header")==0) {
			always_private_header = FALSE;
			no_private_header = TRUE;
		} else if(strcmp(argv[i],"--")==0) {
			/*further arguments are files*/
			no_opts = TRUE;
		} else if(strncmp(argv[i],"--",2)==0) {
			/*unknown long option*/
			fprintf(stderr,"Unknown option '%s'!\n",argv[i]);
			print_help();
			exit(1);
		} else {
			/*by now we know we have a string starting with
			  - which is a short option string*/
			char *p = argv[i]+1;
			for(p=argv[i]+1;*p;p++) {
				switch(*p) {
				case 'w':
					exit_on_warn=TRUE;
					break;
				case 'h':
				case '?':
					print_help();
					exit(0);
				default:
					fprintf(stderr,
						"Unknown option '%c'!\n",*p);
					print_help();
					exit(1);
				}
			}
		}
	}
}

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[])
{
#if 0
	int c;
	poptContext optCon;
	
	struct poptOption optionsTable[] = {
		{ "exit-on-warn", 'w', 0, &exit_on_warn, 0,
			 "exit on warnings" },
		POPT_AUTOHELP
		{ NULL, 0, 0, NULL, 0 }
	};
	
	optCon = poptGetContext(NULL, argc, argv, optionsTable, 0);
	poptSetOtherOptionHelp(optCon, "[OPTIONS]* [filename]");
	
	while ((c = poptGetNextOpt(optCon)) >= 0)
		;
	
	filename = poptGetArg(optCon);
	if(!(poptPeekArg(optCon) == NULL))
		usage(optCon, 1, "Specify only one file",
		      ".e.g., filename.gob");
			
	if (c < -1) {
		/* an error occurred during option processing */
		fprintf(stderr, "%s: %s\n",
			poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
			poptStrerror(c));
		return 1;
	}
#endif

	parse_options(argc,argv);
	
	if(filename) {
		yyin = fopen(filename,"r");
		if(!yyin) {
			fprintf(stderr,"Error: can't open file '%s'\n",
				filename);
			exit(1);
		}
	} else
		filename = "stdin";

	/*yydebug = 1;*/
	if(yyparse()!=0)
		g_error("Parsing errors, quitting");
	if(!class)
		print_error(FALSE," no class defined",0);
	

	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)
		exit(1);

	open_files();
	
	generate_outfiles();

	fclose(out);
	fclose(outh);

	if(no_touch_headers)
		compare_and_move_header();
	
#if 0
	poptFreeContext(optCon);
#endif
	return 0;
}