new version of interface patch
|
View:
New views
3 Messages
—
Rating Filter:
Alert me
|
 |
new version of interface patch
by Rudi Cilibrasi, Ph.D.
::
Rate this Message:
new version of patch
[second-interface-r.patch] 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: 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; > } > 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, < < 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); > } > ; > > 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; > } > } > ; > > 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); > } > | ';' { ; } > ; > 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); < < 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 [second-interface-u.patch] Only in gobnew: config.h Only in gobnew: config.log Only in gobnew: config.status Common subdirectories: gob2-2.0.14/debian and gobnew/debian Common subdirectories: gob2-2.0.14/doc and gobnew/doc Common subdirectories: gob2-2.0.14/examples and gobnew/examples Only in gobnew: Makefile Only in gobnew: o Common subdirectories: gob2-2.0.14/src and gobnew/src Only in gobnew: stamp-h -- to unsubscribe: send mail to minimalist@... with "unsubscribe gob-list" in the subject |
|
|
Re: new version of interface patch
by Jiri Lebl
::
Rate this Message:
Rudi Cilibrasi, Ph.D. wrote:
> new version of patch Is there a newer version of this patch? If so I will put it into svn test and make a release of gob in the very near future (I have slightly more time recently than up till now) Also can you please document the new features as well? George -- George <jirka@...> If the facts don't fit the theory, change the facts. -- Albert Einstein -- to unsubscribe: send mail to minimalist@... with "unsubscribe gob-list" in the subject |
|
|
Re: new version of interface patch
by Rudi Cilibrasi, Ph.D.
::
Rate this Message:
Hi Jiri,
I don't think it was ever quite good enough to go in. There is no more recent version yet. If I get inspired I may take another crack at it. If I remember correctly, this version worked ok for my purposes but was terribly limitted in some way. I forget how though because it has been a while. I think the patch is close but not good enough yet. Best regards, Rudi On 9/27/07, Jiri Lebl <jirka@...> wrote: > Rudi Cilibrasi, Ph.D. wrote: > > new version of patch > > Is there a newer version of this patch? If so I will put it into svn test > and make a release of gob in the very near future (I have slightly more time > recently than up till now) > > Also can you please document the new features as well? > > George > > -- > George <jirka@...> > If the facts don't fit the theory, change the facts. > -- Albert Einstein > -- "We can try to do it by breaking free of the mental prison of separation and exclusion and see the world in its interconnectedness and non-separability, allowing new alternatives to emerge." -- after Vandana Shiva -- to unsubscribe: send mail to minimalist@... with "unsubscribe gob-list" in the subject |
| Free embeddable forum powered by Nabble | Forum Help |
