/* this is a TEST file, it's VERY VERY ugly, it's just supposed to test
   the parser of gob and somewhat test some output as well, you can
   look in here to see a whole array of different syntax options, but
   don't expect this to be an easy to read file */

requires 0.93.0

%headertop{
/* this should go on the very top of the header */
%}
%ht{
/* this should go on the very top of the header as well */
%}
%ph{
/* this should go into the private header */
%}
%privateheader{
/* this should go into the private header as well*/
%}


%{
#include <stdio.h>
/* the next line is not mandatory, but if gob finds an include in one of
   the %{ %} sections above the class definitions, it will not put it in
   the file itself.  So you can this way select where the include file is
   at */
#include "gtk-weird-button.h"
#include "gtk-weird-button-private.h"

/* this is to test if the lexer won't get confused by requires inside
   some c code
requires 99.99.99
*/

static void jjjj(void);
%}

%h{
void bubu(void);
%}
%header{
/* this should be in the header, just under bubu prototype */
#define TEST_ARRAY 5
%}

class Gtk:Weird:Button from Gtk:Button {
	public int test_array[TEST_ARRAY];
	public int i;
	argument INT i set { self->i = ARG; } get { ARG = self->i; } ;

	public int testing = 1;
	argument INT testing link;

	public char * testingstring = {g_strdup("test")}
		destroywith g_free;
	argument POINTER testingstring stringlink;

	public Gtk:Weird:Button * testingobj
		destroywith gtk_object_unref;
	argument POINTER testingobj objectlink;

	classwide int foo = 20;
	argument INT foo link;

	public Gtk:Object * testingobj2
		destroy {
			if(VAR)
				gtk_object_unref(GTK_OBJECT(VAR));
		};
	argument POINTER (type Gtk:Object *) testingobj2 objectlink;
	
	argument POINTER (type GtkObject *) some_object
		set { /* set some_object */ }
		get { /* get some_object */
			ARG=NULL; };
	argument (CONSTRUCT) LONG (type long) write_only_long
		set { /* set write_only_long */ };
	argument POINTER (type char *) read_only_string
		get { /* get readonly_long */
			ARG = g_strdup("BLAH"); };
	private int j;
	public GtkWidget * h;
	public char *bleh;
	public double array[23][18];
	protected unsigned long int wagawaga;
	public int wagawaga_should_be_after_this_in_the_header;

	init(object) {
		object->i=0;
	}
	class_init(klass);

	/**
	 * new:
	 * @j: foo
	 *
	 * budliky budliky
	 *
	 * Returns: new object
	 */
	public GtkWidget * new(int j (check > 0)) {
		GtkWidget *ret;
		ret = GTK_WIDGET (GET_NEW);

		SELF(ret)->_priv->j = j;

		return ret;
	}
	private int _blah(self, Gtk:Widget * wid (check null type),
			 int h (check > 0)) onerror -1 {
		gtk_container_add(GTK_CONTAINER(self),wid);

		gtk_object_set(GTK_OBJECT(self),
			       GTK_WEIRD_BUTTON_ARG_I(99),
			       NULL);
		return h;
	}
	/**
	 * bleh:
	 * @self: foo
	 * @wid: foo
	 * @h: foo
	 *
	 * budliky budliky 2
	 *
	 * Returns: new object
	 **/
	signal last INT (POINTER, INT)
	int bleh(self, Gtk:Widget * wid (check null type),
		        int h (check > 0)) {
		return _blah(self,wid,h);
	}
	/**
	 * gtk_weird_button_bleh2:
	 * @self: foo
	 * @wid: foo
	 * @h: foo
	 *
	 * budliky budliky 3
	 *
	 * Returns: new object */
	signal last INT (POINTER, INT)
	int bleh2(self, Gtk:Widget * wid (check null type),
		        int h (check > 0)) {
		/* testing multiple marshaller support */
		return 0;
	}
	/* this should not get documented as it's nonstandard */
	/**
	 * bloh:

	 ******/

	/* Here we are testing how the gtk-doc extraction code error handeling
	   it should just ingore these */
	/**
	  */

	/** */
	/**
	 *
	 * bubu
	 *********/
	/**
	 *
	 * bubu
	 **zblunk*******/
	/**
	 *
	 * bubu
	 *zblunk*******//**//**/
	signal first NONE (NONE)
	void bloh(self);
	virtual void * bah(self, int h (check > 0)) onerror NULL defreturn 0 {
		beh(self,h);
		return NULL;
	}
	virtual int beh(self, int h (check > 0));
	override(Gtk:Container) void add(Gtk:Container * self (check null type),
				         Gtk:Widget * wid (check null type)) {
		PARENT_HANDLER(self,wid);
	}
	public int consttest(self, const gchar *text, ...)
	{
		return 25;
	}
	signal private first NONE (NONE)
	void googlegoogle(self)
	{
		puts("TEST1");
		googlegoogle2(self);
	}
	signal first private NONE (NONE)
	void googlegoogle2(self)
	{
		int array[5][8][9]={{{0}}};
		Self *foo = self;
		puts("TEST2");
		testprivvirtual(foo, array);
	}
	private signal first NONE (NONE)
	void googlegoogle3(self)
	{
		puts("TEST3");
	}
	protected signal first NONE (NONE)
	void googlegoogle4(self)
	{
		puts("TEST4");
	}
	virtual private
	void testprivvirtual(self, int some_array[5][8][9])
	{
		puts("TEST3");
		googlegoogle(self);
	}
	private virtual
	void testprivvirtual2(self, int some_array[5][8][9])
	{
		/* nothing here */
	}
	public virtual
	void testpublicvirtual(self, int some_array[5][8][9])
	{
		/* nothing here */
	}
	protected virtual
	void testprotectedvirtual(self, int some_array[5][8][9])
	{
		/* nothing here */
	}
	signal first NONE (POINTER)
	void testarrsignal(self, long arr[8])
	{
		/* foo */
	}

	/* testing empty func */
	public void foofoofoo(self) {}
	/* testing empty func 2 */
	public void foofoofoo2(self);
	/* testing empty func 3 */
	public void foofoofoo3(self) {   }
	/* testing empty func 4 */
	public void foofoofoo4(self)
	{
	}

	override (Gtk:Widget)
	int event(Gtk:Widget *self (check null type),
		  GdkEvent *event (check null)) onerror FALSE
	{
		int ret;
		/* some code */
		ret = PARENT_HANDLER(self,event);
		/* some code */
		return ret;
	}
	override(Gtk:Container)
	void
	remove(Gtk:Container * self (check null type),
	       Gtk:Widget * wid (check null type));

	override(Gtk:Object)
	void
	destroy(Gtk:Object * self (check null type))
	{
		/* foo bar */
		PARENT_HANDLER(self);
	}

	protected
	int foobar(self) {
		/* just an empty function */
		return 5;
	}

	signal last NONE(CHAR,UCHAR,BOOL,INT,UINT,LONG,ULONG,FLOAT,DOUBLE,
			 STRING,ENUM,FLAGS,BOXED,POINTER,OBJECT)
	void
	testargs(self, gchar a, guchar b, gboolean c, gint d, guint e, glong f,
		 gulong g, gfloat h, gdouble i, gchar * j, gint k,
		 guint l, gpointer m, gpointer o, GtkObject *p)
	{
		/* ugh, testing casting */
	}

	public signal (NO_HOOKS) last INT (INT)
	int testflags(self, int w (check > 0)) defreturn -99 {
		/*foo*/
		return w;
	}

	/* testing NONE */
	signal BOOL (NONE)
	gboolean
	test_none_thing (self)
	{
		return FALSE;
	}
	/* testing empty statements */
	;
	;
	;
}

%{

static void
jjjj(void)
{
}

void
bubu(void)
{
	jjjj();
}

%}