Only in gobnew: config.h
Only in gobnew: config.log
Only in gobnew: config.status
Only in gobnew/doc: gob2.1
Only in gobnew/doc: Makefile
Only in gobnew/examples: Makefile
Only in gobnew: Makefile
Only in gobnew: o
diff -r gob2-2.0.14/src/checks.c gobnew/src/checks.c
316c316,336
< 				m->cbuf = g_strdup("/*empty*/");
---
>         if (c->isinterface) {
>           FuncArg *fa;
>           fa = m->args->data;
>           GSList *iter;
>           GString *gs = g_string_new("");
> //          m->cbuf = g_strdup("/*interempty*/");
>           char *retstr = (strcmp(m->mtype->name, "void")==0) ? "" : "return ";
>           g_string_sprintf(gs, "%s%s->%s(", retstr, fa->name, m->id);
>           iter = g_slist_next(m->args);
>             char *sep2 = "";
>           for (;iter; iter = iter->next) {
>             g_string_append(gs, sep2);
>             g_string_append(gs, ((FuncArg *) (iter->data))->name);
>             sep2 = ",";
>           }
>             g_string_append(gs, ");");
>           m->cbuf = gs->str;
>           g_string_free(gs, FALSE);
>         }
>         else
>           m->cbuf = g_strdup("/*empty*/");
Only in gobnew/src: .checks.c.swp
Only in gobnew/src: complearn-real-compressor.c
Only in gobnew/src: complearn-real-compressor.h
Only in gob2-2.0.14/src: lexer.c
diff -r gob2-2.0.14/src/lexer.l gobnew/src/lexer.l
407a408,420
> interface		{
> 			static int found_classes = 0;
> 			look_for_includes = 2;
> 			BEGIN(CLASS_CODE);
> 
> 			if(++found_classes > 1) {
> 				error_print(GOB_ERROR, line_no,
> 					    "Only one interface per file allowed");
> 			}
> 
> 			return INTERFACE;
> 		}
> 
diff -r gob2-2.0.14/src/main.c gobnew/src/main.c
1068c1068,1089
< 	out_printf(out,
---
>   if (((Class *)class)->isinterface)
>     out_printf(out,
> 		   "GType\n"
> 		   "%s_get_type (void)\n"
> 		   "{\n"
> 		   "\tstatic GType type = 0;\n\n"
> 		   "\tif ___GOB_UNLIKELY(type == 0) {\n"
> 		   "\t\tstatic const GTypeInfo info = {\n"
> 		   "\t\t\tsizeof (%sClass),\n"
> 		   "\t\t\t(GBaseInitFunc) %s_class_init,\n"
> 		   "\t\t\t(GBaseFinalizeFunc) NULL,\n"
> 		   "\t\t\t(GClassInitFunc) NULL,\n"
> 		   "\t\t\t(GClassFinalizeFunc) NULL,\n"
> 		   "\t\t\tNULL /* class_data */,\n"
> 		   "\t\t\t0,\n"
> 		   "\t\t\t0,\n"
> 		   "\t\t\tNULL,\n"
> 		   "\t\t\tNULL\n"
> 		   "\t\t};\n\n",
> 		   funcbase, typebase, funcbase);
>   else
>     out_printf(out,
2400,2401c2421,2427
< 
< 		if(m->cbuf) {
---
>     if (c->isinterface) {
> 			out_printf(out, " {\n");
> 			out_printf(out, " %s_GET_CLASS (self)->%s (self);",
>                        macrobase, m->id);
> 			out_printf(out, " }\n");
>     }
> 		if(!c->isinterface && m->cbuf) {
Only in gobnew/src: Makefile
Only in gobnew/src: o
Only in gob2-2.0.14/src: parse.c
Only in gob2-2.0.14/src: parse.h
diff -r gob2-2.0.14/src/parse.y gobnew/src/parse.y
47a48
> static gboolean isinterface = FALSE;
676c677
< %token CLASS FROM
---
> %token CLASS INTERFACE FROM
689,692c690,697
< prog:		ccodes class ccodes	{ ; }
< 	|	class ccodes		{ ; }
< 	|	ccodes class		{ ; }
< 	|	class			{ ; }
---
> prog:		ccodes iclass ccodes	{ ; }
> 	|	iclass ccodes		{ ; }
> 	|	ccodes iclass		{ ; }
> 	|	iclass			{ ; }
> 	;
> 
> iclass:	class	{ ; }
> 	|	interface		{ ; }
760a766,786
> interface:		interfacedec '{' interfacecode '}'{
> 			((Class *)class)->nodes = class_nodes;
>         isinterface = TRUE;
>         ((Class *)class)->isinterface = TRUE;
> 			class_nodes = NULL;
> 			nodes = g_list_append(nodes,class);
> 						}
> 	|	interfacedec ';'	{
> 			((Class *)class)->nodes = class_nodes;
>         isinterface = TRUE;
>         ((Class *)class)->isinterface = TRUE;
> 			class_nodes = NULL;
> 			nodes = g_list_append(nodes,class);
> 						}
> 	|	interfacedec '{' '}'		{
> 			((Class *)class)->nodes = NULL;
> 			class_nodes = NULL;
> 			nodes = g_list_append(nodes,class);
> 						}
> 	;
> 
772a799,897
> interfacedec:	INTERFACE TYPETOKEN FROM TYPETOKEN interfaceflags	{
> 			class = node_new (CLASS_NODE,
> 					  "otype:steal", $<id>2,
> 					  "ptype:steal", $<id>4,
> 					  "bonobo_object_class:steal", bonobo_object_class,
> 					  "glade_xml", glade_xml,
> 					  "interfaces:steal", interfaces,
> 					  "chunk_size:steal", chunk_size,
> 					  "abstract", abstract,
>             "isinterface", isinterface,
> 					  NULL);
> 			bonobo_object_class = NULL;
> 			glade_xml = FALSE;
> 			chunk_size = NULL;
> 			interfaces = NULL;
>       isinterface = FALSE;
> 						}
> 	;
> 
> interfaceflags:
> 	| '(' TOKEN ')' interfaceflags {
> 			if(strcmp($<id>2,"abstract") == 0) {
> 				abstract = TRUE;
> 			} else {
> 				yyerror(_("parse error"));
> 				YYERROR;
> 			}
> 		}
> 	| '(' TOKEN TOKEN ')' interfaceflags {
> 			if(strcmp($<id>2,"chunks") == 0) {
> 				g_free (chunk_size);
> 				chunk_size = g_strdup($<id>3);
> 			} else if(strcmp($<id>2,"BonoboObject") == 0) {
> 				g_free (bonobo_object_class);
> 				bonobo_object_class = g_strdup($<id>3);
> 			} else {
> 				yyerror(_("parse error"));
> 				YYERROR;
> 			}
> 		}
> 	| '(' TOKEN TYPETOKEN ')' interfaceflags {
> 			if (strcmp ($<id>2, "interface") == 0) {
> 				interfaces = g_list_append (interfaces,
> 							    g_strdup ($<id>3));
> 			} else {
> 				yyerror(_("parse error"));
> 				YYERROR;
> 			}
> 		}
> 	| '(' TOKEN NUMBER ')' interfaceflags {
> 			if(strcmp($<id>2,"chunks") == 0) {
> 				g_free (chunk_size);
> 				if(atoi($<id>3) != 0)
> 					chunk_size = g_strdup($<id>3);
> 				else
> 					chunk_size = NULL;
> 			} else {
> 				yyerror(_("parse error"));
> 				YYERROR;
> 			}
> 		}
> 	| '(' TOKEN STRING STRING ')' interfaceflags {
> 			if (strcmp ($<id>2, "GladeXML") == 0) {
> 				glade_xml = TRUE;
> 				add_construct_glade($<id>3, $<id>4, NULL);
> 			} else {
> 				yyerror(_("parse error"));
> 				YYERROR;
> 			}
> 		}
> 	| '(' TOKEN STRING STRING STRING ')' interfaceflags {
> 			if (strcmp ($<id>2, "GladeXML") == 0) {
> 				glade_xml = TRUE;
> 				add_construct_glade($<id>3, $<id>4, $<id>5);
> 			} else {
> 				yyerror(_("parse error"));
> 				YYERROR;
> 			}
> 		}
> 	| '(' TOKEN TOKEN STRING ')' interfaceflags {
> 			if (strcmp ($<id>2, "GladeXML") == 0) {
> 				glade_xml = TRUE;
> 				add_construct_glade($<id>3, $<id>4, NULL);
> 			} else {
> 				yyerror(_("parse error"));
> 				YYERROR;
> 			}
> 		}
> 	| '(' TOKEN TOKEN STRING STRING ')' interfaceflags {
> 			if (strcmp ($<id>2, "GladeXML") == 0) {
> 				glade_xml = TRUE;
> 				add_construct_glade($<id>3, $<id>4, $<id>5);
> 			} else {
> 				yyerror(_("parse error"));
> 				YYERROR;
> 			}
> 		}
> 	;	
> 
873a999,1027
> interfacecode:	interfacecode interfacething			{ ; }
> 	|	interfacething		{ ; }
> 	;
> 
> interfacething: 		method				{ ; }
> 	|	TOKEN method			{
> 			if (strcmp ($<id>1, "BonoboObject") != 0) {
> 				g_free ($<id>1);
> 				yyerror (_("parse error"));
> 				YYERROR;
> 			}
> 			g_free ($<id>1);
> 			last_added_method->bonobo_object_func = TRUE;
> 						}
> 	|	TOKEN TYPETOKEN method			{
> 			if (strcmp ($<id>1, "interface") != 0) {
> 				g_free ($<id>1);
> 				g_free ($<id>2);
> 				yyerror (_("parse error"));
> 				YYERROR;
> 			}
> 			g_free ($<id>1);
> 			node_set ((Node *)last_added_method,
> 				  "interface:steal", $<id>2,
> 				  NULL);
> 						}
> 	|	';'				{ ; }
> 	;
> 
Only in gobnew/src: t2.gob
diff -r gob2-2.0.14/src/test.gob gobnew/src/test.gob
1,11c1
< /* 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 1.99.0
< 
< %at{
< /* ALL TOP */
< %}
< 
---
> requires 2.0.0
13,44c3,4
< /* 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>
< #include <gtk/gtk.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 "test-object.h"
< #include "test-object-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);
< 
< #define _(x) x
---
> #include <glib/garray.h>
> #include "real-compressor.h"
47,629c7
< %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);
< 
< /* Fake boxed */
< #define PACKAGE_TYPE_BOXED 1
< typedef void * PackageBoxed;
< 
< %}
< %header{
< /* this should be in the header, just under bubu prototype */
< #define TEST_ARRAY 5
< %}
< 
< enum LAME_CLIENT {
< 	IS_CONNECTED,
< 	NONE = 9,
< 	LAST
< } Test:Enum;
< 
< flags BUGA_BUGA {
< 	ONE,
< 	TWO,
< 	MANY,
< } Some:Flags;
< 
< error TEST_OBJECT_ERROR {
< 	BAD_THIS,
< 	BAD_THAT
< } Test:Object:Error;
< 
< enum BUBLE {
<         KEIN = 0,
<         STANDARD,
<         STANDARD_RO,
<         KOMPLETT,
<         ALT
< } Buble:Enum;
< 
< class Test:Object from /*G:Object*/ Gtk:Container
< 	(interface Gtk:Tree:Model)
< 	/* We can add more interfaces by adding more lines like the above */
< 	/* Note that there must exist a GtkTreeModelIface structure */
< {
< 
< 	/* function implemented for the Gtk:Tree:Model interface */
< 	interface Gtk:Tree:Model
< 	private GtkTreeModelFlags
< 	get_flags (Gtk:Tree:Model *self (check null type))
< 	{
< 		/* FOO */
< 		return (GtkTreeModelFlags)0;
< 	}
< 
< 
< 
< 	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 Test:Object * testingobj
< 		unrefwith g_object_unref;
< 	argument POINTER testingobj objectlink;
< 
< 	public Test:Object * testingobjllll
< 		unrefwith gtk_widget_destroy;
< 	argument POINTER testingobjllll objectlink;
< 
< 	public Test:Object * testingobjfoo
< 		unref { if (VAR) g_object_unref (VAR); };
< 	argument POINTER testingobjfoo objectlink;
< 
< 	classwide int foo = 20;
< 	argument INT foo link;
< 
< 	public G:Object * testingobj2
< 		destroy {
< 			if(VAR)
< 				g_object_unref(G_OBJECT(VAR));
< 		};
< 	argument POINTER (type G:Object *) testingobj2 objectlink;
< 	
< 	argument POINTER (type GObject *) 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 char a_property;
< 	property CHAR a_property
< 		(nick = _("Nick"),
< 		 blurb = _("Blurb"),
< 		 minimum = 'a',
< 		 maximum = 'Z',
< 		 default_value = 'C',
< 		 export)
< 		set { self->_priv->a_property = g_value_get_char (VAL); }
< 		get { g_value_set_char (VAL, self->_priv->a_property); };
< 
< 	property OBJECT foobarblahllll1
< 		(nick = "xxxxxxx1",
< 		 blurb = "yyyyyy",
< 		 object_type = Gtk:Button)
< 		get { /* FOO1 */ };
< 	property OBJECT foobarblahllll2
< 		(nick = "xxxxxxx2",
< 		 blurb = "yyyyyy",
< 		 object_type = G:Object)
< 		set { /* FOO2 */ };
< 
< 	private double dblnum;
< 	property DOUBLE dblnum
< 		(nick = _("dblnum"),
< 		 blurb = _("dblnum"),
< 		 minimum = 0.1,
< 		 maximum = 99.1,
< 		 default_value = 0.3,
< 		 flags = CONSTRUCT|CONSTRUCT_ONLY,
< 		 export,
< 		 link);
< 
< 	private char *b_property;
< 	property STRING b_property
< 		(nick = _("Nick b"),
< 		 blurb = _("Blurb b"),
< 		 default_value = "default",
< 		 type = char *,
< 		 flags = CONSTRUCT,
< 		 export,
< 		 link);
< 
< 	private Test:Object *objectproperty;
< 	property OBJECT objectproperty (nick   = "object",
< 				blurb  = "obj property",
< 				object_type = Test:Object,
< 				link);
< 
< 	private Test:Enum enum_property;
< 	property ENUM enum_property (nick   = "enumprop",
< 				blurb  = "enumprop",
< 				enum_type = Test:Enum,
< 				link);
< 
< 	private Some:Flags flags_property;
< 	property FLAGS flags_property (nick   = "flagsprop",
< 				blurb  = "flagsprop",
< 				flags_type = Some:Flags,
< 				link);
< 
< 	  private PackageBoxed prop;
< 	  property BOXED prop (nick="prop",
< 			       blurb="prop",
< 			       boxed_type=Package:Boxed,
< 			       link);
< 	  /* testing old semantics */
< 	  private PackageBoxed prop2;
< 	  property BOXED prop2 (nick="prop2",
< 			       blurb="prop2",
< 			       boxed_type=PACKAGE_TYPE_BOXED,
< 			       link);
< 
< 	private char ov_prop;
< 	property CHAR ov_prop
< 		(export,
< 		 override)
< 		set { self->_priv->ov_prop = g_value_get_char (VAL); }
< 		get { g_value_set_char (VAL, self->_priv->ov_prop); };
< 
< 
< 	private int j;
< 	public GObject * 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 GObject * new(int j (check > 0)) {
< 		GObject *ret;
< 		ret = G_OBJECT (GET_NEW);
< 
< 		SELF(ret)->_priv->j = j;
< 
< 		return ret;
< 	}
< 	private int blah(self, G:Object * wid (check null type),
< 			 int h (check > 0)) onerror -1 {
< 		g_object_set (G_OBJECT (self),
< 			      TEST_OBJECT_PROP_I (99),
< 			      NULL);
< 		return h;
< 	}
< 	/**
< 	 * bleh:
< 	 * @self: foo
< 	 * @wid: foo
< 	 * @h: foo
< 	 *
< 	 * budliky budliky 2
< 	 *
< 	 * Returns: new object
< 	 **/
< 	signal last STRING (POINTER, INT)
< 	char * bleh(self, G:Object * wid (check null type),
< 		        int h (check > 0)) {
< 		return self_blah(self,wid,h) > 0 ? g_strdup ("foo") : g_strdup ("bar");
< 	}
< 
< 	private
< 	char *
< 	test_handler (self, GObject *w, int h, gpointer data)
< 	{
< 		data = w = NULL;
< 		h = 0;
< 			
< 		return NULL;
< 	}
< 
< 	/**
< 	 * 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 G:Object * wid (check null type),
< 		        int h (check > 0)) {
< 
< 		test_object_connect__bleh (self, self_test_handler, NULL);
< 		self_connect__bleh (self, self_test_handler, NULL);
< 		test_object_connect_after__bleh (self, self_test_handler, NULL);
< 		self_connect_after__bleh (self, self_test_handler, NULL);
< 		test_object_connect_data__bleh (self, self_test_handler, NULL, NULL, 0);
< 		self_connect_data__bleh (self, self_test_handler, NULL, NULL, 0);
< 
< 		wid = NULL;
< 		h = 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 {
< 		self_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);
< 	}
< 
< 	override(G:Object)
< 	void dispatch_properties_changed (G:Object      *object,
< 					  guint	   n_pspecs,
< 					  GParamSpec  **pspecs)
< 	{
< 		object = NULL;
< 		n_pspecs = 0;
< 		pspecs = NULL;
< 		/* EKI! */
< 	}
< 
< 	public int consttest(self, const gchar *text, ...)
< 	{
< 		text = NULL;
< 		return 25;
< 	}
< 	public int consttest2(self, gchar const *text, ...)
< 	{
< 		text = NULL;
< 		return 25;
< 	}
< 	public int consttest3(self, G:Object const *wid (check null type))
< 	{
< 		wid = NULL;
< 		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 = TEST_OBJECT_CONST(self);
< 		return 25;
< 	}
< 	public int consttest9(const self, int i, double b)
< 	{
< 		b = 0.0;
< 		i = 0;
< 		return 25;
< 	}
< 	public int consttest10(self const, int i, double b)
< 	{
< 		b = 0.0;
< 		i = 0;
< 		return 25;
< 	}
< 	signal private first NONE (NONE)
< 	void googlegoogle(self)
< 	{
< 		puts("TEST1");
< 		self_googlegoogle2(self);
< 	}
< 	signal first private NONE (NONE)
< 	void googlegoogle2(self)
< 	{
< 		int array[5][8][9]={{{0}}};
< 		Self *foo = self;
< 		puts("TEST2");
< 		self_testprivvirtual(foo, array);
< 	}
< 	private signal first NONE (NONE)
< 	void googlegoogle3(self)
< 	{
< 		puts("TEST3");
< 	}
< 	protected signal first NONE (NONE)
< 	void googlegoogle4(self)
< 	{
< 		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])
< 	{
< 		puts("TEST3");
< 		self_googlegoogle(self);
< 		if (some_array[0]) return;
< 	}
< 	private virtual
< 	void testprivvirtual2(self, const int some_array[5][8][9])
< 	{
< 		/* nothing here */
< 		if (some_array[0]) return;
< 	}
< 	public virtual
< 	void testpublicvirtual(self, int const some_array[5][8][9])
< 	{
< 		/* nothing here */
< 		if (some_array[0]) return;
< 	}
< 	protected virtual
< 	void testprotectedvirtual(self, int some_array[5][8][9])
< 	{
< 		/* nothing here */
< 		if (some_array[0]) return;
< 	}
< 	signal first NONE (POINTER, ENUM)
< 	void testarrsignal(self, long arr[8], Buble:Enum foo)
< 	{
< 		/* foo */
< 		arr[0] = 1;
< 		foo = BUBLE_KEIN;
< 	}
< 
< 	/* 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,BOOLEAN,INT,UINT,LONG,ULONG,FLOAT,DOUBLE,
< 			 STRING,ENUM,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,
< 		 gpointer o, GObject *p)
< 	{
< 		h = i = k = 0;
< 		a = b = c = d = e = f = g = 0;
< 		o = p = (GObject *)NULL;
< 		j = (char *)NULL;
< 		/* 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 BOOLEAN (NONE)
< 	gboolean
< 	test_none_thing (self)
< 	{
< 		return FALSE;
< 	}
< 
< 	/* some more enum testing */
< 	public BubleEnum buble;
<         property ENUM buble
<                 (nick = "Buble",
<                  blurb = "Buble",
<                  enum_type = Buble:Enum,
<                  default_value = BUBLE_STANDARD,
<                  link, export);
< 
< 	/* 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) {
< 		self_method_with_no_arguments ();
< 	}
< 
< 	/* this is to test custom get_type */
< 	/*public GtkType
< 	get_type (void)
< 	{
< 		static guint type = 0;
< 
< 		if ( ! type) {
< 			static const GtkTypeInfo info = {
< 				"GtkWeirdButton",
< 				sizeof (GtkWeirdButton),
< 				sizeof (GtkWeirdButtonClass),
< 				(GtkClassInitFunc) gtk_weird_button_class_init,
< 				(GtkObjectInitFunc) gtk_weird_button_init,
< 				NULL,
< 				NULL,
< 				(GtkClassInitFunc) NULL
< 			};
< 
< 			type = gtk_type_unique (gtk_button_get_type(), &info);
< 		}
< 
< 		return type;
< 	}*/
< 
< 
< 	/* testing empty statements */
< 	;
< 	;
< 	;
< }
< 
< %{
< 
< static void
< jjjj(void)
---
> interface CompLearn:Real:Compressor from G:Type:Interface
630a9,39
>   public G:Object *
>   new(void) {
>     GObject *ret = (GObject *) GET_NEW;
>     return G_OBJECT (ret);
>   }
>   public GString *
>   compress(CompLearnRealCompressor *rc,const GString *input);
>   public GString *
>   decompress(CompLearnRealCompressor *rc,const GString *input);
>   public GString *
>   canonical_extension(CompLearnRealCompressor *rc);
> public GString *
>   blurb(CompLearnRealCompressor *rc);
> public GString *
>   name(CompLearnRealCompressor *rc);
> public GString *
>   compressor_version(CompLearnRealCompressor *rc);
> public GString *
>   binding_version(CompLearnRealCompressor *rc);
> public gdouble
>   compressed_size(CompLearnRealCompressor *rc, const GString *input);
> public gboolean
>   is_just_size(CompLearnRealCompressor *rc);
> public gboolean
>   is_operational(CompLearnRealCompressor *self);
> public gboolean
>   is_decompressible(CompLearnRealCompressor *rc, const GString *input);
> public gboolean
>   is_private_property(CompLearnRealCompressor *rc, const char *input);
> public guint64
>   window_size(CompLearnRealCompressor *rc);
632,639d40
< 
< void
< bubu(void)
< {
< 	jjjj();
< }
< 
< %}
diff -r gob2-2.0.14/src/treefuncs.c gobnew/src/treefuncs.c
108a109
> 	QUARK_isinterface,
216a218
> 	g_hash_table_insert (quark_ht, "isinterface", GINT_TO_POINTER (QUARK_isinterface));
365a368
> 	new->isinterface = self->isinterface;
957a961,965
> 		case QUARK_isinterface: {
> 			gboolean isinterface = va_arg (__ap, gboolean);
> 			self->isinterface = isinterface;
> 			break;
> 		}
diff -r gob2-2.0.14/src/treefuncs.def gobnew/src/treefuncs.def
59c59,60
<   BOOL		abstract # if G_TYPE_FLAG_ABSTRACT should be used
---
>   BOOL		abstract    # if G_TYPE_FLAG_ABSTRACT should be used
>   BOOL		isinterface # if it is an interface instead of a class
diff -r gob2-2.0.14/src/treefuncs.h gobnew/src/treefuncs.h
121a122
> 	gboolean isinterface;
Only in gobnew: stamp-h