X-Git-Url: http://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/e10d6e307623d0952f6e1f5d9fee8720ddab4808..c9d96fcfcf9b74099775a3a260eccdfdc31474c7:/src/test.gob diff --git a/src/test.gob b/src/test.gob index 3adbd25..36fe62b 100644 --- a/src/test.gob +++ b/src/test.gob @@ -3,10 +3,15 @@ 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.92.1 +requires 0.93.0 + +%at{ +/* ALL TOP */ +%} %headertop{ /* this should go on the very top of the header */ + %} %ht{ /* this should go on the very top of the header as well */ @@ -37,15 +42,49 @@ 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 */ @@ -66,15 +105,24 @@ class Gtk:Weird:Button from Gtk:Button { 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); - GTK_WEIRD_BUTTON(ret)->_priv->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); @@ -83,20 +131,63 @@ class Gtk:Weird:Button from Gtk:Button { 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, Gtk:Widget * wid (check null type), + 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; } @@ -109,6 +200,45 @@ class Gtk:Weird:Button from Gtk:Button { { return 25; } + public int consttest2(self, gchar const *text, ...) + { + return 25; + } + public int consttest3(self, Gtk:Widget const *wid (check null type)) + { + return 25; + } + public int consttest4(const self) + { + return 25; + } + public int consttest5(self const) + { + return 25; + } + virtual int consttest6(const self) + { + return 25; + } + virtual int consttest7(self const) + { + return 25; + } + public int consttest8(self) + { + Self const *selfconst1, *selfconst2; + selfconst1 = SELF_CONST(self); + selfconst2 = GTK_WEIRD_BUTTON_CONST(self); + return 25; + } + public int consttest9(const self, int i, double b) + { + return 25; + } + public int consttest10(self const, int i, double b) + { + return 25; + } signal private first NONE (NONE) void googlegoogle(self) { @@ -119,8 +249,9 @@ class Gtk:Weird:Button from Gtk:Button { void googlegoogle2(self) { int array[5][8][9]={{{0}}}; + Self *foo = self; puts("TEST2"); - testprivvirtual(self,array); + testprivvirtual(foo, array); } private signal first NONE (NONE) void googlegoogle3(self) @@ -132,6 +263,16 @@ class Gtk:Weird:Button from Gtk:Button { { puts("TEST4"); } + protected signal first NONE (NONE) + void googlegoogle_const1(const self) + { + puts("TEST4"); + } + protected signal first NONE (NONE) + void googlegoogle_const2(self const) + { + puts("TEST4"); + } virtual private void testprivvirtual(self, int some_array[5][8][9]) { @@ -139,12 +280,12 @@ class Gtk:Weird:Button from Gtk:Button { googlegoogle(self); } private virtual - void testprivvirtual2(self, int some_array[5][8][9]) + void testprivvirtual2(self, const int some_array[5][8][9]) { /* nothing here */ } public virtual - void testpublicvirtual(self, int some_array[5][8][9]) + void testpublicvirtual(self, int const some_array[5][8][9]) { /* nothing here */ } @@ -185,6 +326,14 @@ class Gtk:Weird:Button from Gtk:Button { 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 */ @@ -200,6 +349,56 @@ class Gtk:Weird:Button from Gtk:Button { { /* 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 method with no arguments */ + public void method_with_no_arguments (void) + { + /* FOO */ + } + + /* testing calling the above method */ + public void foo (self) { + method_with_no_arguments (); + } + + + /* testing empty statements */ + ; + ; + ; } %{