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

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

static int signals = 0;
static int arguments = 0;
static int overrides = 0;

FILE *out;
FILE *outh;

int exit_on_warn = FALSE;
int exit_on_error = TRUE;
int got_error = 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;
}

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;
	
	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;
			
			out_printf(out,"#define %s %s_%s\n",m->id,funcbase,m->id); 
		}
	}
	out_printf(out,"\n");
}

static void
undef_methods(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;
			
			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);

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

static void
print_method(FILE *fp, char *typeprefix, char *nameprefix,
	     char *namepostfix,char *postfix, Method *m)
{
	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,", ..."); 
	} else {
		out_printf(fp,"void"); 
	}
	out_printf(fp,")%s\n",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","(* ",") ",";",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 ||
	   m->scope == PRIVATE_SIGNAL_LAST_METHOD ||
	   m->scope == PRIVATE_SIGNAL_FIRST_METHOD ||
	   m->scope == PRIVATE_VIRTUAL_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 == PRIVATE_SIGNAL_LAST_METHOD ||
	   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);
	} 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);
	} 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,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,g_strdup("init"),
				  make_init_args(cl,g_strdup("o"),FALSE),
				  NULL, NULL,0,0,FALSE);
		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 &&
	   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);
	
	out_printf(out,"(*%s) (",s);
	
	for(li=m->args;li;li=g_list_next(li)) {
		FuncArg *arg = li->data;
		print_type(out,arg->atype);
		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) {
			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);
			}
		}
		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);
		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) {
			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);
			}
		}
		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)
				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"," ","",m);
			if(m->line_no>0)
				out_addline_outfile(out);
			out_printf(out,"{\n");
		} 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);
			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 = "
				"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) {
			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, *this;\n\n"
		"\tself = this = %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_is_macro(fa->atype->name);
			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);
			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);
	}
}

static void
print_method_body(Method *m, int pre)
{
	out_printf(out,"{\n");
	if(pre) {
		print_preconditions(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,"}\n");
}

static void
put_method(Method *m)
{
	char *s;
	int private = FALSE;
	out_printf(out,"\n");
	switch(m->scope) {
	case PUBLIC_SCOPE:
		out_addline_infile(out,m->line_no);
		print_method(out,"","\n"," ","",m);
		print_method_body(m,TRUE);
		break;
	case PRIVATE_SCOPE:
		out_addline_infile(out,m->line_no);
		print_method(out,"static ","\n"," ","",m);
		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"," ","",m);
		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);
			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)
			break;
		out_addline_infile(out,m->line_no);
		print_method(out,"static ","\n_real_"," ","",m);
		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);
		out_addline_outfile(out);
		out_printf(out,"{\n"
			"\t%sClass *class;\n",typebase);
		print_preconditions(m);
		out_printf(out,"\tclass = %s_CLASS(GTK_OBJECT(%s)->klass);\n\n"
			"\tif(class->%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,
				   ((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 (*class->%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);
			out_printf(out,")(%s);\n}\n",
				m->onerror?m->onerror:"0");
		}

		if(!m->cbuf)
			break;
		out_addline_infile(out,m->line_no);
		print_method(out,"static ","\n_real_"," ","",m);
		print_method_body(m,FALSE);
		break;
	case OVERRIDE_METHOD:
		out_addline_infile(out,m->line_no);
		print_method(out,"static ","\n"," ","",m);
		print_method_body(m,TRUE);
		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)
			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_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 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 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);
	out_printf(outh,"/* Generated by GOB (v%s) on %s"
	       "   (do not edit directly) */\n\n",VERSION,ctime(&curtime));
	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);
	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);
	
	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) {
			GList *l;
			Class *c = (Class *)class;
			char *otype,*ptype;

			signals = count_signals(c);
			arguments = count_arguments(c);
			overrides = count_overrides(c);
			
			out_printf(outh,"\n#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);

			otype = remove_sep(c->otype);
			ptype = remove_sep(c->ptype);
			out_printf(outh,"\ntypedef struct _%s %s;\n",otype,otype);
			out_printf(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);
			}
			out_printf(outh,"};\n");

			out_printf(outh,"\ntypedef struct _%sClass %sClass;\n",
				otype,otype);
			out_printf(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);
			}
			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();

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

			undef_methods(c);

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

	out_printf(outh,"\n#ifdef __cplusplus\n"
		"}\n"
		"#endif /* __cplusplus */\n\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");
}

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],"--")==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);
				}
			}
		}
	}
}

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);
	
	make_bases();
	
	exit_on_error = FALSE;
	make_inits((Class *)class);
	check_duplicate_symbols((Class *)class);
	check_duplicate_signals_args((Class *)class);
	check_public_new((Class *)class);
	check_vararg((Class *)class);
	exit_on_error = TRUE;
	
	if(got_error)
		exit(1);

	open_files();
	
	generate_outfiles();

	fclose(out);
	fclose(outh);
	
#if 0
	poptFreeContext(optCon);
#endif
	return 0;
}