X-Git-Url: https://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/64034bc2613afefb289d1450411e69a0de4bce4e..486240dc4c5d57b0afaddba60d87fe375112bed5:/src/test.gob diff --git a/src/test.gob b/src/test.gob index bac330a..be3f543 100644 --- a/src/test.gob +++ b/src/test.gob @@ -1,58 +1,347 @@ +/* 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 +/* 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{ +enum _gob__enum_t { + BUDLIKY, BUDLIKY2 +}; + +struct _gob__struct_t { + int i, x, y, z; +}; +union _gob__union_t { + int i, x, y, z; +}; 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) { - GtkWeirdButton *but = GTK_WEIRD_BUTTON(object); - but->i=0; + object->i=0; } - class_init(class); + 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); - GTK_WEIRD_BUTTON(ret)->j = j; + SELF(ret)->_priv->j = j; return ret; } - private int blah(self, Gtk:Widget * wid (check null type), + 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); + 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, const 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 { + 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)) { - if (GTK_CONTAINER_CLASS (parent_class)->add) - (* GTK_CONTAINER_CLASS (parent_class)->add) (self,wid); + PARENT_HANDLER(self,wid); } public int consttest(self, const gchar *text, ...) { return 25; } + public int consttest2(self, gchar const *text, ...) + { + return 25; + } + public int consttest3(self, Gtk:Widget const *wid (check null type)) + { + 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, const int some_array[5][8][9]) + { + /* nothing here */ + } + public virtual + void testpublicvirtual(self, int const 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 types */ + public int t1; + public long int t2; + public int long t3; + public int long const t4; + public const int long t5; + public const char * const t6; + public char const * const t7; + public enum _gob__enum_t const * const t8; + public union _gob__union_t t9; + public union _gob__union_t * const * const * t10; + public struct _gob__struct_t * const * const * t11; + public const struct _gob__struct_t * const * const * t13; + public const enum _gob__enum_t * const * const * t14; + public enum _gob__enum_t t15; + public gchar const t16; + public const gchar * const t17; + public const gchar t18; + + /* testing empty statements */ + ; + ; + ; } %{