/* 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 <glib.h>
#include <popt.h>
#include <time.h>
#include <stdio.h>
#include <string.h>

#include "tree.h"
#include "y.tab.h"

#ifndef VERSION
#define VERSION "0.0.1"
#endif

char *filename = "stdin";

int yyparse(void);

extern int yydebug;
extern FILE * yyin;
extern Node *class;
extern GList *nodes;

static char *filebase;
static char *funcbase;
static char *pfuncbase;
static char *macrobase;
static char *macrois;
static char *typebase;
static char *ptypebase;

static FILE *out;
static FILE *outh;

int exit_on_warn = FALSE;

static void
print_error(int is_warn, char *error,int line)
{
	char *w;
	if(is_warn)
		w = "Warning:";
	else
		w = "Error:";
	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(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;
}

static char *
make_is_macro(char *base)
{
	char *s1,*s2;
	char *s;

	separns_replace_sep(base,&s1,&s2,'_');
	if(s1)
		s = g_strconcat(s1,"_IS_",s2,NULL);
	else
		s = g_strconcat("IS_",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_is_macro(((Class *)class)->otype);

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

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

static void
def_methods(Class *c)
{
	GList *li;
	
	fprintf(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;
			
			fprintf(out,"#define %s %s_%s\n",m->id,funcbase,m->id); 
		}
	}
	fprintf(out,"\n");
}

static void
undef_methods(Class *c)
{
	GList *li;
	
	fprintf(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;
			
			fprintf(out,"#undef %s\n",m->id); 
		}
	}
	fprintf(out,"\n");
}

static void
print_type(FILE *fp, Type *t)
{
	char *s;
	int i;
	s = remove_sep(t->name);
	fprintf(fp,"%s ",s); 
	g_free(s);
	
	for(i=0;i<t->stars;i++)
		fprintf(fp,"*"); 
}

static void
put_variable(Variable *v)
{
	fprintf(outh,"\t");
	if(v->scope == PRIVATE_SCOPE)
		fprintf(outh,"/* private */ "); 
	print_type(outh,v->vtype);

	fprintf(outh,"%s;\n",v->id); 
}

static void
print_method(FILE *fp, char *typeprefix, char *nameprefix,
	     char *namepostfix,char *postfix, Method *m)
{
	GList *li;

	fprintf(fp,"%s",typeprefix); 
	print_type(fp,m->mtype);
	fprintf(fp,"%s%s_%s%s(",
		nameprefix,funcbase,m->id,namepostfix); 
	
	for(li=m->args;li;li=g_list_next(li)) {
		FuncArg *arg = li->data;
		print_type(fp,arg->atype);
		if(li->next)
			fprintf(fp,"%s, ",arg->name); 
		else
			fprintf(fp,"%s",arg->name); 

	}
	fprintf(fp,")%s\n",postfix); 
}

static void
put_vs_method(Method *m)
{
	if(m->scope != SIGNAL_LAST_METHOD &&
	   m->scope != SIGNAL_FIRST_METHOD &&
	   m->scope != VIRTUAL_METHOD)
		return;

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

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

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

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

	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);
	} else {
		print_method(out,"static ",""," ",";",m);
	}
}

static GList *
make_init_args(Class *cl, char *name, int is_class)
{
	Node *node;
	Node *type;
	char *tn;
	
	if(is_class)
		tn = g_strconcat(cl->otype,":Class",NULL);
	else
		tn = g_strdup(cl->otype);

	type = new_type(1,tn);
	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,g_strdup("class_init"),
				  make_init_args(cl,g_strdup("c"),TRUE),
				  NULL, NULL,0);
		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,g_strdup("init"),
				  make_init_args(cl,g_strdup("o"),FALSE),
				  NULL, NULL,0);
		cl->nodes = g_list_prepend(cl->nodes,node);
	}
}

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)
		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);
	
	fprintf(out,"\ntypedef ");
	print_type(out,m->mtype);
	
	fprintf(out,"(*%s) (",s);
	
	for(li=m->args;li;li=g_list_next(li)) {
		FuncArg *arg = li->data;
		print_type(out,arg->atype);
		fprintf(out,", "); 
	}
	fprintf(out,"gpointer);\n"); 
	
	fprintf(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;
		fprintf(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) {
			for(i=0,li=m->gtktypes->next;li;
			    i++,li=g_list_next(li)) {
				fprintf(out, ",\n\t\tGTK_VALUE_%s(args[%d])",
					(char *)li->data,i);
			}
		}
		fprintf(out, ",\n\t\tfunc_data);\n}\n\n");
	} else {
		int i;
		fprintf(out, "\t%s rfunc;\n\t",s);
		print_type(out,m->mtype);
		fprintf(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) {
			for(i=0,li=m->gtktypes->next;li;
			    i++,li=g_list_next(li)) {
				fprintf(out, ",\n\t\tGTK_VALUE_%s(args[%d])",
					(char *)li->data,i);
			}
		}
		fprintf(out, ",\n\t\tfunc_data);\n}\n\n");
	}

}

static void
add_enums(Class *c)
{
	GList *li;
	fprintf(out,"\nenum {\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) {
				char *s = g_strdup(m->id);
				g_strup(s);
				fprintf(out,"\t%s_SIGNAL,\n",s);
				g_free(s);
			}
		}
	}
	fprintf(out,"\tLAST_SIGNAL\n"
		"};\n\n"
		"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);
			fprintf(out,"\tARG_%s,\n",s);
			g_free(s);
		}
	}
	fprintf(out, "};\n\n"
		"static guint object_signals[LAST_SIGNAL] = {0};\n\n"
		"static %sClass *parent_class = NULL;\n\n",ptypebase);
}

static void
add_get_type(void)
{
	fprintf(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)
{
	GList *li;
	GHashTable *done;
	char *s;
	
	done = g_hash_table_new(g_str_hash,g_str_equal);
	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);

		fprintf(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;

	fprintf(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;
		if(n->type != METHOD_NODE ||
		   (((Method *)n)->scope != SIGNAL_FIRST_METHOD &&
		    ((Method *)n)->scope != SIGNAL_LAST_METHOD))
			continue;

		m = (Method *)n;

		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);
		fprintf(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,
			m->scope==SIGNAL_LAST_METHOD?"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))
				fprintf(out,",\n\t\t\tGTK_TYPE_%s",
					(char *)l->data);
		}

		fprintf(out,");\n");
	}
	fprintf(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;

	fprintf(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 != 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);
			fprintf(out,"\t%s_class->%s = %s_%s;\n",
				s,m->id,funcbase,m->id);
		} else {
			if(m->cbuf)
				fprintf(out,"\t%s->%s = _real_%s_%s;\n",
					oname,m->id,funcbase,m->id);
			else
				fprintf(out,"\t%s->%s = NULL;\n",
					oname,m->id);
		}
	}
}

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

	fprintf(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);
		fprintf(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);
	}
	
	fprintf(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) {
			print_method(out,"static ","\n"," ","",m);
			if(m->cbuf)
				fprintf(out,"{\n%s\n}\n\n",m->cbuf->str);
			else
				fprintf(out,"{\n\treturn;\n}\n\n");
		} else if(m->scope == CLASS_INIT_METHOD) {
			print_method(out,"static ","\n"," ","",m);
			fprintf(out,"{\n"
				"\tGtkObjectClass *gtk_object_class = "
				"(GtkObjectClass*) %s;\n",
				((FuncArg *)m->args->data)->name);
			
			add_overrides(c, ((FuncArg *)m->args->data)->name);
			
			fprintf(out,"\n\tparent_class = "
				"gtk_type_class (%s_get_type ());\n",
				pfuncbase);

			add_signals(c);

			set_def_handlers(c, ((FuncArg *)m->args->data)->name);
			
			make_arguments(c);
			
			if(m->cbuf)
				fprintf(out," {\n%s\n }\n",m->cbuf->str);
			fprintf(out,"}\n");
		}
	}
}

static void
add_getset_arg(Class *c, int is_set)
{
	GList *li;
	fprintf(out,"\nstatic void\n"
		"__object_%s_arg (GtkObject *object,\n"
		"\tGtkArg *arg,\n"
		"\tguint arg_id)\n"
		"{\n"
		"\t%s *this;\n\n"
		"\tthis = %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;
		if(n->type != ARGUMENT_NODE)
			continue;
		a = (Argument *)n;
		if((is_set && !a->set) ||
		   (!is_set && !a->get))
			continue;
		s = g_strdup(a->name);
		g_strup(s);
		fprintf(out,"\tcase ARG_%s:\n"
			"#define ARG (GTK_VALUE_%s(*arg))\n"
			"\t\t{\n%s\n\t\t}\n\t\tbreak;\n"
			"#undef ARG\n",
			s,a->gtktype,a->set->str);
		g_free(s);
	}
	fprintf(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)
			fprintf(out,"\tg_return_if_fail (");
		else
			fprintf(out,"\tg_return_val_if_fail (");
		switch(ch->chtype) {
		case NULL_CHECK:
			fprintf(out,"%s != NULL",fa->name);
			break;
		case TYPE_CHECK:
			s = make_is_macro(fa->atype->name);
			fprintf(out,"%s (%s)",s,fa->name);
			g_free(s);
			break;
		case LT_CHECK:
			fprintf(out,"%s < %s",fa->name,ch->number);
			break;
		case GT_CHECK:
			fprintf(out,"%s > %s",fa->name,ch->number);
			break;
		case LE_CHECK:
			fprintf(out,"%s <= %s",fa->name,ch->number);
			break;
		case GE_CHECK:
			fprintf(out,"%s >= %s",fa->name,ch->number);
			break;
		case EQ_CHECK:
			fprintf(out,"%s == %s",fa->name,ch->number);
			break;
		case NE_CHECK:
			fprintf(out,"%s != %s",fa->name,ch->number);
			break;
		}
		if(is_void)
			fprintf(out,");\n");
		else {
			fprintf(out,", (");
			print_type(out,m->mtype);
			fprintf(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);
	}
}

static void
print_method_body(Method *m, int pre)
{
	fprintf(out,"{\n");
	if(pre) {
		print_preconditions(m);
		fprintf(out,"\t{\n");
	}

	fprintf(out,"\t\t%s\n",m->cbuf->str);

	if(pre)
		fprintf(out,"\t}\n");
	fprintf(out,"}\n");
}

static void
put_method(Method *m)
{
	char *s;
	fprintf(out,"\n");
	if(strcmp(m->id,"new")==0) {
		fprintf(out,"#define GET_NEW (gtk_type_new(%s_get_type()))\n",
			funcbase);
	}
	switch(m->scope) {
	case PUBLIC_SCOPE:
		print_method(out,"","\n"," ","",m);
		print_method_body(m,TRUE);
		break;
	case PRIVATE_SCOPE:
		print_method(out,"static ","\n"," ","",m);
		print_method_body(m,TRUE);
		break;
	case SIGNAL_FIRST_METHOD:
	case SIGNAL_LAST_METHOD:
		print_method(out,"","\n"," ","",m);
		fprintf(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);
			fprintf(out,"\tgtk_signal_emit (GTK_OBJECT (this),\n"
				"\t\tobject_signals[%s_SIGNAL]",s);
			for(li=m->args->next;li;li=g_list_next(li)) {
				FuncArg *fa = li->data;
				fprintf(out,",\n\t\t%s",fa->name);
			}
			fprintf(out,");\n}\n");
		} else {
			GList *li;
			fprintf(out,"\t");
			print_type(out,m->mtype);
			fprintf(out,"return_val;\n");
			print_preconditions(m);
			fprintf(out,"\tgtk_signal_emit (GTK_OBJECT (this),\n"
				"\t\tobject_signals[%s_SIGNAL]",s);
			for(li=m->args->next;li;li=g_list_next(li)) {
				FuncArg *fa = li->data;
				fprintf(out,",\n\t\t%s",fa->name);
			}
			fprintf(out,",\n\t\t&return_val);\n"
				"\treturn return_val;\n}\n");
		}

		if(!m->cbuf)
			break;
		print_method(out,"static ","\n_real_"," ","",m);
		print_method_body(m,FALSE);
		break;
	case VIRTUAL_METHOD:
		print_method(out,"","\n"," ","",m);
		fprintf(out,"{\n"
			"\t%sClass *class;\n",typebase);
		print_preconditions(m);
		fprintf(out,"\tclass = %s_CLASS(GTK_OBJECT(this)->klass);\n\n"
			"\tif(class->%s)\n",
			macrobase,m->id);
		if(strcmp(m->mtype->name,"void")==0 &&
		   m->mtype->stars==0) {
			GList *li;
			fprintf(out,"\t\t(*class->%s)(this",m->id);
			for(li=m->args->next;li;li=g_list_next(li)) {
				FuncArg *fa = li->data;
				fprintf(out,",%s",fa->name);
			}
			fprintf(out,");\n}\n");
		} else {
			GList *li;
			fprintf(out,"\t\treturn (*class->%s)(this",m->id);
			for(li=m->args->next;li;li=g_list_next(li)) {
				FuncArg *fa = li->data;
				fprintf(out,",%s",fa->name);
			}
			fprintf(out,");\n"
				"\telse\n"
				"\t\treturn (");
			print_type(out,m->mtype);
			fprintf(out,")(%s);\n}\n",
				m->onerror?m->onerror:"0");
		}

		if(!m->cbuf)
			break;
		print_method(out,"static ","\n_real_"," ","",m);
		print_method_body(m,FALSE);
		break;
	case OVERRIDE_METHOD:
		print_method(out,"static ","\n"," ","",m);
		print_method_body(m,TRUE);
		break;
	default:
		break;
	}
	if(strcmp(m->id,"new")==0)
		fprintf(out,"#undef GET_NEW\n");
}

static void
open_files(void)
{
	char *outfile,*outfileh;

	outfile = g_strconcat(filebase,".c",NULL);
	outfileh = g_strconcat(filebase,".h",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);
	}
}

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

	time(&curtime);
	fprintf(outh,"/* Generated by GOB (v%s) on %s"
	       "   (do not edit directly) */\n\n",VERSION,ctime(&curtime));
	fprintf(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);
	fprintf(outh,"#ifndef __%s_H__\n#define __%s_H__\n\n"
		"#include <gtk/gtk.h>\n\n",p,p);
	g_free(p);

	fprintf(outh,"#ifdef __cplusplus\n"
		"extern \"C\" {\n"
		"#endif /* __cplusplus */\n\n");
	
	fprintf(out,"#include \"%s.h\"\n\n",filebase);
	
	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;
			else
				fp = out;
			fprintf(fp,"\n%s\n",cc->cbuf->str);
		} else if(node->type == CLASS_NODE) {
			GList *l;
			Class *c = (Class *)class;
			char *otype,*ptype;
			
			fprintf(outh,"\n#define %s(obj)\t"
				"GTK_CHECK_CAST((obj),%s_get_type(),%s)\n",
				macrobase,funcbase,typebase);
			fprintf(outh,"#define %s_CLASS(klass)\t"
				"GTK_CHECK_CLASS_CAST((klass),%s_get_type(),%sClass)\n",
				macrobase,funcbase,typebase);
			fprintf(outh,"#define %s(obj)\t"
				"GTK_CHECK_TYPE((obj), %s_get_type ())\n\n",
				macrois,funcbase);

			otype = remove_sep(c->otype);
			ptype = remove_sep(c->ptype);
			fprintf(outh,"\ntypedef struct _%s %s;\n",otype,otype);
			fprintf(outh,"struct _%s {\n\t%s __parent__;\n",
				otype,ptype);
			for(l=c->nodes;l;l=g_list_next(l)) {
				Node *n = l->data;
				if(n->type == VARIABLE_NODE)
					put_variable((Variable *)n);
			}
			fprintf(outh,"};\n");

			fprintf(outh,"\ntypedef struct _%sClass %sClass;\n",
				otype,otype);
			fprintf(outh,
				"struct _%sClass {\n\t%sClass __parent__;\n",
				otype,ptype);
			for(l=c->nodes;l;l=g_list_next(l)) {
				Node *n = l->data;
				if(n->type == METHOD_NODE)
					put_vs_method((Method *)n);
			}
			fprintf(outh,"};\n\n");

			fprintf(outh,"guint\t%s_get_type\t(void);\n",funcbase);
			
			fprintf(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);
				}
			}

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

			def_methods(c);
			
			add_inits(c);

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

			undef_methods(c);

			g_free(otype);
			g_free(ptype);
		} else
			g_assert_not_reached();
	}

	fprintf(outh,"\n#ifdef __cplusplus\n"
		"}\n"
		"#endif /* __cplusplus */\n\n"
		"#endif");
}

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


int
main(int argc, char *argv[])
{
	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;
	}
	
	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);
	
	make_bases();
	
	make_inits((Class *)class);
	
	open_files();
	
	generate_outfiles();

	fclose(out);
	fclose(outh);
	
	poptFreeContext(optCon);
	return 0;
}