*** empty log message ***

svn path=/trunk/externals/miXed/; revision=1639

5 files changed, 168 insertions, 90 deletions

diff --git a/Makefile.common b/Makefile.common
index 7f88cd1..fd57c44 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -31,6 +31,14 @@ OPT_CFLAGS = -O6 -funroll-loops -fomit-frame-pointer
 LFLAGS = -export_dynamic  -shared
 endif
 
+ifeq ($(OS_NAME),MinGW)
+CC = gcc
+X_SUFFIX = dll
+DEFINES = -DNT -DMSW
+OPT_CFLAGS = -funroll-loops
+LFLAGS = -shared $(PD_DIR)/../bin/pd.dll
+endif
+
 ifeq ($(OS_NAME),Darwin)
 CC = gcc2
 X_SUFFIX = pd_darwin
diff --git a/cyclone/hammer/Table.c b/cyclone/hammer/Table.c
index 9b08cbe..e366cbb 100644
--- a/cyclone/hammer/Table.c
+++ b/cyclone/hammer/Table.c
@@ -61,7 +61,7 @@ typedef struct _tablecommon
 typedef struct _table
 {
     t_object        x_ob;
-    t_canvas       *x_canvas;
+    t_canvas       *x_glist;
     t_symbol       *x_name;
     t_tablecommon  *x_common;
     t_float         x_value;
@@ -92,8 +92,8 @@ static void tablecommon_modified(t_tablecommon *cc, int relocated)
     {
 	t_table *x;
 	for (x = cc->c_refs; x; x = x->x_next)
-	    if (x->x_canvas && glist_isvisible(x->x_canvas))
-		canvas_dirty(x->x_canvas, 1);
+	    if (x->x_glist && glist_isvisible(x->x_glist))
+		canvas_dirty(x->x_glist, 1);
     }
 }
 
@@ -223,9 +223,37 @@ static int tablecommon_quantile(t_tablecommon *cc, float f)
     return (ndx);
 }
 
+/* LATER binary files */
 static void tablecommon_doread(t_tablecommon *cc, t_symbol *fn, t_canvas *cv)
 {
     /* FIXME */
+    t_binbuf *bb = binbuf_new();
+    int ac;
+    t_atom *av;
+    char buf[MAXPDSTRING];
+    if (!fn)
+	return;  /* CHECKME complaint */
+    if (cv || (cv = cc->c_lastcanvas))  /* !cv: 'read' w/o arg */
+	canvas_makefilename(cv, fn->s_name, buf, MAXPDSTRING);
+    else
+    {
+    	strncpy(buf, fn->s_name, MAXPDSTRING);
+    	buf[MAXPDSTRING-1] = 0;
+    }
+    binbuf_read(bb, buf, "", 0);
+    if ((ac = binbuf_getnatom(bb)) &&
+	(av = binbuf_getvec(bb)) &&
+	av->a_type == A_SYMBOL &&
+	av->a_w.w_symbol == gensym("table"))
+    {
+	post("Table: %s read successful", fn->s_name);  /* CHECKME */
+	/* FIXME */
+    }
+#if 0  /* FIXME */
+    else  /* CHECKME complaint */
+	loud_error((t_pd *)cc, "invalid file %s", fn->s_name);
+#endif
+    binbuf_free(bb);
 }
 
 static void tablecommon_readhook(t_pd *z, t_symbol *fn, int ac, t_atom *av)
@@ -235,7 +263,23 @@ static void tablecommon_readhook(t_pd *z, t_symbol *fn, int ac, t_atom *av)
 
 static void tablecommon_dowrite(t_tablecommon *cc, t_symbol *fn, t_canvas *cv)
 {
-    /* FIXME */
+    t_binbuf *bb = binbuf_new();
+    char buf[MAXPDSTRING];
+    int ndx, *ptr;
+    if (!fn)
+	return;  /* CHECKME complaint */
+    if (cv || (cv = cc->c_lastcanvas))  /* !cv: 'write' w/o arg */
+	canvas_makefilename(cv, fn->s_name, buf, MAXPDSTRING);
+    else
+    {
+    	strncpy(buf, fn->s_name, MAXPDSTRING);
+    	buf[MAXPDSTRING-1] = 0;
+    }
+    binbuf_addv(bb, "s", gensym("table"));
+    for (ndx = 0, ptr = cc->c_table; ndx < cc->c_length; ndx++, ptr++)
+	binbuf_addv(bb, "i", *ptr);
+    binbuf_write(bb, buf, "", 0);
+    binbuf_free(bb);
 }
 
 static void tablecommon_writehook(t_pd *z, t_symbol *fn, int ac, t_atom *av)
@@ -365,7 +409,7 @@ static void table_bind(t_table *x, t_symbol *name)
 	{
 	    pd_bind(&cc->c_pd, name);
 	    /* LATER rethink canvas unpredictability */
-	    tablecommon_doread(cc, name, x->x_canvas);
+	    tablecommon_doread(cc, name, x->x_glist);
 	}
 	else
 	{
@@ -641,20 +685,35 @@ static void table_fquantile(t_table *x, t_floatarg f)
 		 (t_float)tablecommon_quantile(x->x_common, f));
 }
 
-/* FIXME arguments (from, to) */
-/* CHECKED no remote dumping, symbol args bashed to 0 */
 static void table_dump(t_table *x, t_symbol *s, int ac, t_atom *av)
 {
     t_tablecommon *cc = x->x_common;
+    int thelength = cc->c_length;
+    int *thetable = cc->c_table;
     t_outlet *out = ((t_object *)x)->ob_outlet;
-    int ndx;
-    /* The usual way of traversing the table by incrementing a pointer is
-       not robust, because calling outlet_float() may invalidate the pointer.
-       The test below is simpler than generic selfmod detection ala coll,
-       but behaviour may be different.  LATER revisit, consider asserting
-       invariance of cc->c_table and cc->c_length, instead. */
-    for (ndx = 0; ndx < cc->c_length; ndx++)
-	outlet_float(out, (t_float)cc->c_table[ndx]);
+    int ndx, nmx, *ptr;
+    /* CHECKED optional arguments: from, to,  Negative 'from' causes
+       invalid output, symbols are bashed to zero for both arguments,
+       inconsistent warnings, etc. -- no strict emulation attempted below. */
+    if (ac && av->a_type == A_FLOAT)
+	ndx = tablecommon_getindex(cc, (int)av->a_w.w_float);
+    else
+	ndx = 0;
+    if (ac > 1 && av[1].a_type == A_FLOAT)
+	nmx = tablecommon_getindex(cc, (int)av[1].a_w.w_float);
+    else
+	nmx = thelength - 1;
+    for (ptr = thetable + ndx; ndx <= nmx; ndx++, ptr++)
+    {
+	/* Plain traversing by incrementing a pointer is not robust,
+	   because calling outlet_float() may invalidate the pointer.
+	   Continous storage does not require generic selfmod detection
+	   (ala coll), so we can get away with the simpler test below. */
+	if (cc->c_length != thelength || cc->c_table != thetable)
+	    break;
+	/* CHECKED no remote dumping */
+	outlet_float(out, (t_float)*ptr);
+    }
 }
 
 static void table_refer(t_table *x, t_symbol *s)
@@ -669,7 +728,7 @@ static void table_read(t_table *x, t_symbol *s)
 {
     t_tablecommon *cc = x->x_common;
     if (s && s != &s_)
-	tablecommon_doread(cc, s, x->x_canvas);
+	tablecommon_doread(cc, s, x->x_glist);
     else
 	hammerpanel_open(cc->c_filehandle, 0);
 }
@@ -678,9 +737,8 @@ static void table_write(t_table *x, t_symbol *s)
 {
     t_tablecommon *cc = x->x_common;
     if (s && s != &s_)
-	tablecommon_dowrite(cc, s, x->x_canvas);
+	tablecommon_dowrite(cc, s, x->x_glist);
     else
-	/* CHECKED default name is plain `Untitled' */
 	hammerpanel_save(cc->c_filehandle, 0, 0);
 }
 
@@ -709,6 +767,7 @@ static void table_open(t_table *x)
     int count = cc->c_length, col = 0;
     /* LATER prepend "table: " */
     hammereditor_open(cc->c_filehandle,
+		      /* CHECKED default name is plain `Untitled' */
 		      x->x_name ? x->x_name->s_name : "Untitled");
     while (count--)
 	col = tablecommon_editorappend(cc, *bp++, buf, col);
@@ -754,7 +813,7 @@ static void *table_new(t_symbol *s)
 	loud_warning((t_pd *)x, 0, "Table is not ready yet");
 	warned = 1;
     }
-    x->x_canvas = canvas_getcurrent();
+    x->x_glist = canvas_getcurrent();
     x->x_valueset = 0;
     x->x_head = 0;
     x->x_intraversal = 0;  /* CHECKED */
diff --git a/cyclone/hammer/coll.c b/cyclone/hammer/coll.c
index a6d6476..850c2c7 100644
--- a/cyclone/hammer/coll.c
+++ b/cyclone/hammer/coll.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2002-2003 krzYszcz and others.
+/* Copyright (c) 2002-2004 krzYszcz and others.
  * For information on usage and redistribution, and for a DISCLAIMER OF ALL
  * WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */
 
@@ -16,6 +16,10 @@
 
 #define COLL_DEBUG
 
+enum { COLL_HEADRESET,
+       COLL_HEADNEXT, COLL_HEADPREV,  /* distinction not used, currently */
+       COLL_HEADDELETED };
+
 typedef struct _collelem
 {
     int                e_hasnumkey;
@@ -41,8 +45,8 @@ typedef struct _collcommon
     t_hammerfile  *c_filehandle;
     t_collelem    *c_first;
     t_collelem    *c_last;
-    t_collelem    *c_ahead;
-    t_collelem    *c_back;
+    t_collelem    *c_head;
+    int            c_headstate;
 } t_collcommon;
 
 typedef struct _coll
@@ -184,10 +188,12 @@ static void collcommon_takeout(t_collcommon *cc, t_collelem *ep)
 	ep->e_next->e_prev = ep->e_prev;
     else
 	cc->c_last = ep->e_prev;
-    if (cc->c_ahead == ep)
-	cc->c_ahead = ep->e_next;
-    if (cc->c_back == ep)
-	cc->c_back = ep->e_prev;
+    if (cc->c_head == ep)
+    {
+	cc->c_head = ep->e_next;  /* asymmetric, LATER rethink */
+	cc->c_headstate = COLL_HEADDELETED;
+    }
+
 }
 
 static void collcommon_modified(t_collcommon *cc, int relinked)
@@ -222,7 +228,8 @@ static void collcommon_clearall(t_collcommon *cc)
 	}
 	while (ep1 = ep2);
 	cc->c_first = cc->c_last = 0;
-	cc->c_ahead = cc->c_back = 0;
+	cc->c_head = 0;
+	cc->c_headstate = COLL_HEADRESET;
 	collcommon_modified(cc, 1);
     }
 }
@@ -581,8 +588,6 @@ static int collcommon_frombinbuf(t_collcommon *cc, t_binbuf *bb)
 static void collcommon_doread(t_collcommon *cc, t_symbol *fn, t_canvas *cv)
 {
     t_binbuf *bb;
-    int ac;
-    t_atom *av;
     char buf[MAXPDSTRING];
     if (!fn && !(fn = cc->c_filename))  /* !fn: 'readagain' */
 	return;
@@ -761,7 +766,8 @@ static void *collcommon_new(void)
     t_collcommon *cc = (t_collcommon *)pd_new(collcommon_class);
     cc->c_embedflag = 0;
     cc->c_first = cc->c_last = 0;
-    cc->c_ahead = cc->c_back = 0;
+    cc->c_head = 0;
+    cc->c_headstate = COLL_HEADRESET;
     return (cc);
 }
 
@@ -1203,70 +1209,59 @@ static void coll_swap(t_coll *x, t_symbol *s, int ac, t_atom *av)
     else loud_messarg((t_pd *)x, s);
 }
 
+/* CHECKED traversal direction change is consistent with the general rule:
+   'next' always outputs e_next of a previous output, and 'prev' always
+   outputs e_prev, whether preceded by 'prev', or by 'next'.  This is
+   currently implemented by pre-updating of the head (which is inhibited
+   if there was no previous output, i.e. after 'goto', 'end', or collection
+   initialization).  CHECKME again. */
+
 static void coll_next(t_coll *x)
 {
     t_collcommon *cc = x->x_common;
-    if (!cc->c_ahead && !(cc->c_ahead = cc->c_first))
-	return;
-    coll_keyoutput(x, cc->c_ahead);
-    if (cc->c_selfmodified && !cc->c_ahead)
-	return;
-    coll_dooutput(x, cc->c_ahead->e_size, cc->c_ahead->e_data);
-    /* LATER think why c74 updates the heads prior to sendout
-       (it seems so clumsy...) */
-    if (!cc->c_ahead && !(cc->c_ahead = cc->c_first))
-    {
-	cc->c_back = 0;
-	return;
-    }
-    if (cc->c_ahead->e_next)
-    {
-	cc->c_ahead = cc->c_ahead->e_next;
-	if (!(cc->c_back = cc->c_ahead->e_prev))  /* LATER rethink */
-	    cc->c_back = cc->c_last;
-    }
-    else
+    if (cc->c_headstate != COLL_HEADRESET &&
+	cc->c_headstate != COLL_HEADDELETED)  /* asymmetric, LATER rethink */
     {
-	/* CHECKED wraping */
-	cc->c_back = cc->c_ahead;
-	cc->c_ahead = 0;
+	if (cc->c_head)
+	    cc->c_head = cc->c_head->e_next;
+	if (!cc->c_head && !(cc->c_head = cc->c_first))  /* CHECKED wrapping */
+	    return;
     }
+    else if (!cc->c_head && !(cc->c_head = cc->c_first))
+	return;
+    cc->c_headstate = COLL_HEADNEXT;
+    coll_keyoutput(x, cc->c_head);
+    if (cc->c_head)
+	coll_dooutput(x, cc->c_head->e_size, cc->c_head->e_data);
+    else if (!cc->c_selfmodified)
+	bug("coll_next");  /* LATER rethink */
 }
 
 static void coll_prev(t_coll *x)
 {
     t_collcommon *cc = x->x_common;
-    if (!cc->c_back && !(cc->c_back = cc->c_last))
-	return;
-    coll_keyoutput(x, cc->c_back);
-    if (cc->c_selfmodified && !cc->c_back)
-	return;
-    coll_dooutput(x, cc->c_back->e_size, cc->c_back->e_data);
-    /* LATER think why c74 updates the heads prior to sendout
-       (it seems so clumsy...) */
-    if (!cc->c_back && !(cc->c_back = cc->c_last))
+    if (cc->c_headstate != COLL_HEADRESET)
     {
-	cc->c_ahead = 0;
-	return;
-    }
-    if (cc->c_back->e_prev)
-    {
-	cc->c_back = cc->c_back->e_prev;
-	if (!(cc->c_ahead = cc->c_back->e_next))  /* LATER rethink */
-	    cc->c_ahead = cc->c_first;
-    }
-    else
-    {
-	/* CHECKED wraping */
-	cc->c_ahead = cc->c_back;
-	cc->c_back = 0;
+	if (cc->c_head)
+	    cc->c_head = cc->c_head->e_prev;
+	if (!cc->c_head && !(cc->c_head = cc->c_last))  /* CHECKED wrapping */
+	    return;
     }
+    else if (!cc->c_head && !(cc->c_head = cc->c_first))
+	return;
+    cc->c_headstate = COLL_HEADPREV;
+    coll_keyoutput(x, cc->c_head);
+    if (cc->c_head)
+	coll_dooutput(x, cc->c_head->e_size, cc->c_head->e_data);
+    else if (!cc->c_selfmodified)
+	bug("coll_prev");  /* LATER rethink */
 }
 
 static void coll_end(t_coll *x)
 {
     t_collcommon *cc = x->x_common;
-    cc->c_back = cc->c_ahead = cc->c_last;
+    cc->c_head = cc->c_last;
+    cc->c_headstate = COLL_HEADRESET;
 }
 
 static void coll_goto(t_coll *x, t_symbol *s, int ac, t_atom *av)
@@ -1275,7 +1270,11 @@ static void coll_goto(t_coll *x, t_symbol *s, int ac, t_atom *av)
     {
 	t_collelem *ep = coll_findkey(x, av, s);
 	if (ep)
-	    x->x_common->c_back = x->x_common->c_ahead = ep;
+	{
+	    t_collcommon *cc = x->x_common;
+	    cc->c_head = ep;
+	    cc->c_headstate = COLL_HEADRESET;
+	}
     }
     else loud_messarg((t_pd *)x, s);
 }
diff --git a/cyclone/hammer/funbuff.c b/cyclone/hammer/funbuff.c
index 5791b1e..3ce6080 100644
--- a/cyclone/hammer/funbuff.c
+++ b/cyclone/hammer/funbuff.c
@@ -444,7 +444,7 @@ static void *funbuff_new(t_symbol *s)
     x->x_canvas = canvas_getcurrent();
     x->x_valueset = 0;
     x->x_pointer = 0;
-    x->x_pointerset = 0;
+    x->x_pointerset = 0;  /* CHECKME, rename to intraversal? */
     x->x_lastdelta = 0;
     x->x_embedflag = 0;
     hammertree_init(&x->x_tree, 0);
diff --git a/test/cyclone/Table-test.pd b/test/cyclone/Table-test.pd
index a5f6eb4..9e4af55 100644
--- a/test/cyclone/Table-test.pd
+++ b/test/cyclone/Table-test.pd
@@ -1,17 +1,17 @@
 #N canvas 278 182 656 317 12;
-#X msg 25 72 load;
-#X obj 97 102 Uzi;
-#X msg 97 72 100;
+#X msg 24 43 load;
+#X obj 100 73 Uzi;
+#X msg 100 43 100;
 #X msg 29 222 size 100;
 #X obj 119 256 print;
 #X msg 157 102 next;
 #X msg 159 137 prev;
-#X msg 148 72 goto \$1;
-#X floatatom 148 41 5 0 0 0 - - -;
-#X msg 313 72 fquantile \$1;
-#X floatatom 313 45 5 0 0 0 - - -;
-#X msg 441 72 quantile \$1;
-#X floatatom 441 45 5 0 0 0 - - -;
+#X msg 148 70 goto \$1;
+#X floatatom 148 43 5 0 0 0 - - -;
+#X msg 313 70 fquantile \$1;
+#X floatatom 313 43 5 0 0 0 - - -;
+#X msg 441 70 quantile \$1;
+#X floatatom 441 43 5 0 0 0 - - -;
 #X obj 508 222 r test;
 #X obj 508 256 print test;
 #X msg 295 223 send test \$1;
@@ -23,10 +23,16 @@
 #X obj 313 137 print;
 #X obj 313 107 Table t;
 #C restore;
-#X msg 261 72 bang;
+#X msg 261 73 bang;
 #X msg 360 196 symbol length;
-#X msg 25 102 normal;
+#X msg 24 73 normal;
 #X floatatom 159 184 5 0 0 0 - - -;
+#X msg 24 184 dump \$1 \$2;
+#X obj 24 154 pack;
+#X floatatom 24 120 5 0 0 0 - - -;
+#X floatatom 79 120 5 0 0 0 - - -;
+#X msg 79 154 dump;
+#X msg 404 107 sum \, min \, max;
 #X connect 0 0 17 0;
 #X connect 1 2 17 0;
 #X connect 2 0 1 0;
@@ -48,3 +54,9 @@
 #X connect 22 0 15 0;
 #X connect 23 0 17 0;
 #X connect 24 0 17 0;
+#X connect 25 0 17 0;
+#X connect 26 0 25 0;
+#X connect 27 0 26 0;
+#X connect 28 0 26 1;
+#X connect 29 0 17 0;
+#X connect 30 0 20 0;