From 57045df5fe3ec557e57dc7434ac1a07b5521bffc Mon Sep 17 00:00:00 2001
From: Guenter  Geiger <ggeiger@users.sourceforge.net>
Date: Mon, 29 Jul 2002 17:06:19 +0000
Subject: This commit was generated by cvs2svn to compensate for changes in
 r58, which included commits to RCS files with non-trunk default branches.

svn path=/trunk/; revision=59
---
 pd/src/g_traversal.c | 1084 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1084 insertions(+)
 create mode 100644 pd/src/g_traversal.c

(limited to 'pd/src/g_traversal.c')

diff --git a/pd/src/g_traversal.c b/pd/src/g_traversal.c
new file mode 100644
index 00000000..a9e8ce03
--- /dev/null
+++ b/pd/src/g_traversal.c
@@ -0,0 +1,1084 @@
+/* Copyright (c) 1997-1999 Miller Puckette.
+* For information on usage and redistribution, and for a DISCLAIMER OF ALL
+* WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */
+
+/* This file defines Text objects which traverse data contained in scalars
+and arrays:
+
+pointer - point to an object belonging to a template
+get -     get numeric fields
+set -     change numeric fields
+element - get an array element
+getsize - get the size of an array
+setsize - change the size of an array
+append -  add an element to a list
+sublist - get a pointer into a list which is an element of another scalar
+
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>  	/* for read/write to files */
+#include "m_pd.h"
+#include "g_canvas.h"
+
+/* ------------- gstubs and gpointers - safe pointing --------------- */
+
+/* create a gstub which is "owned" by a glist (gl) or an array ("a"). */
+
+t_gstub *gstub_new(t_glist *gl, t_array *a)
+{
+    t_gstub *gs = t_getbytes(sizeof(*gs));
+    if (gl)
+    {
+    	gs->gs_which = GP_GLIST;
+    	gs->gs_un.gs_glist = gl;
+    }
+    else
+    {
+    	gs->gs_which = GP_ARRAY;
+    	gs->gs_un.gs_array = a;
+    }
+    gs->gs_refcount = 0;
+    return (gs);
+}
+
+/* when a "gpointer" is set to point to this stub (so we can later chase
+down the owner) we increase a reference count.  The following routine is called
+whenever a gpointer is unset from pointing here.  If the owner is
+gone and the refcount goes to zero, we can free the gstub safely. */
+
+static void gstub_dis(t_gstub *gs)
+{
+    int refcount = --gs->gs_refcount;
+    if ((!refcount) && gs->gs_which == GP_NONE)
+    	t_freebytes(gs, sizeof (*gs));
+    else if (refcount < 0) bug("gstub_dis");
+}
+
+/* this routing is called by the owner to inform the gstub that it is
+being deleted.  If no gpointers are pointing here, we can free the gstub;
+otherwise we wait for the last gstub_dis() to free it. */
+
+void gstub_cutoff(t_gstub *gs)
+{
+    gs->gs_which = GP_NONE;
+    if (gs->gs_refcount < 0) bug("gstub_cutoff");
+    if (!gs->gs_refcount) t_freebytes(gs, sizeof (*gs));
+}
+
+/* call this to verify that a pointer is fresh, i.e., that it either
+points to real data or to the head of a list, and that in either case
+the object hasn't disappeared since this pointer was generated. 
+Unless "headok" is set,  the routine also fails for the head of a list. */
+
+int gpointer_check(const t_gpointer *gp, int headok)
+{
+    t_gstub *gs = gp->gp_stub;
+    if (!gs) return (0);
+    if (gs->gs_which == GP_ARRAY)
+    {
+    	if (gs->gs_un.gs_array->a_valid != gp->gp_valid) return (0);
+    	else return (1);
+    }
+    else if (gs->gs_which == GP_GLIST)
+    {
+    	if (!headok && !gp->gp_un.gp_scalar) return (0);
+    	else if (gs->gs_un.gs_glist->gl_valid != gp->gp_valid) return (0);
+    	else return (1);
+    }
+    else return (0);
+}
+
+/* call this if you know the pointer is fresh but don't know if we're pointing
+to the head of a list or to real data.   Any pointer is known to be fresh
+when it appears as the argument of a message, but if your "pointer" method 
+or inlet stores it and you use it later, call gpointer_check above. */
+
+/* LATER reconsider the above... I no longer think it's true! */
+
+static int gpointer_ishead(const t_gpointer *gp)
+{
+    return ((gp->gp_stub->gs_which == GP_GLIST) && !gp->gp_un.gp_scalar);
+}
+
+/* get the template for the object pointer to.  Assumes we've already checked
+freshness.  Returns 0 if head of list. */
+
+static t_symbol *gpointer_gettemplatesym(const t_gpointer *gp)
+{
+    t_gstub *gs = gp->gp_stub;
+    if (gs->gs_which == GP_GLIST)
+    {
+    	t_scalar *sc = gp->gp_un.gp_scalar;
+	if (sc)
+	    return (sc->sc_template);
+	else return (0);
+    }
+    else
+    {
+    	t_array *a = gs->gs_un.gs_array;
+	return (a->a_templatesym);
+    }
+}
+
+    /* copy a pointer to another, assuming the first one is fresh and
+    the second one hasn't yet been initialized. */
+void gpointer_copy(const t_gpointer *gpfrom, t_gpointer *gpto)
+{
+    *gpto = *gpfrom;
+    if (gpto->gp_stub)
+    	gpto->gp_stub->gs_refcount++;
+    else bug("gpointer_copy");
+}
+
+void gpointer_unset(t_gpointer *gp)
+{
+    t_gstub *gs;
+    if (gs = gp->gp_stub)
+    {
+    	gstub_dis(gs);
+    	gp->gp_stub = 0;
+    }
+}
+
+void gpointer_setglist(t_gpointer *gp, t_glist *glist, t_scalar *x)
+{
+    t_gstub *gs;
+    if (gs = gp->gp_stub) gstub_dis(gs);
+    gp->gp_stub = gs = glist->gl_stub;
+    gp->gp_valid = glist->gl_valid;
+    gp->gp_un.gp_scalar = x;
+    gs->gs_refcount++;
+}
+
+static void gpointer_setarray(t_gpointer *gp, t_array *array, t_word *w)
+{
+    t_gstub *gs;
+    if (gs = gp->gp_stub) gstub_dis(gs);
+    gp->gp_stub = gs = array->a_stub;
+    gp->gp_valid = array->a_valid;
+    gp->gp_un.gp_w = w;
+    gs->gs_refcount++;
+}
+
+void gpointer_init(t_gpointer *gp)
+{
+    gp->gp_stub = 0;
+    gp->gp_valid = 0;
+    gp->gp_un.gp_scalar = 0;
+}
+
+/* ---------------------- pointers ----------------------------- */
+
+static t_class *ptrobj_class;
+
+typedef struct 
+{
+    t_symbol *to_type;
+    t_outlet *to_outlet;
+} t_typedout;
+
+typedef struct _ptrobj
+{
+    t_object x_obj;
+    t_gpointer x_gp;
+    t_typedout *x_typedout;
+    int x_ntypedout;
+    t_outlet *x_otherout;
+    t_outlet *x_bangout;
+} t_ptrobj;
+
+static void *ptrobj_new(t_symbol *classname, int argc, t_atom *argv)
+{
+    t_ptrobj *x = (t_ptrobj *)pd_new(ptrobj_class);
+    t_typedout *to;
+    int n;
+    gpointer_init(&x->x_gp);
+    x->x_typedout = to = (t_typedout *)getbytes(argc * sizeof (*to));
+    x->x_ntypedout = n = argc;
+    for (; n--; to++)
+    {
+    	to->to_outlet = outlet_new(&x->x_obj, &s_pointer);
+    	to->to_type = canvas_makebindsym(atom_getsymbol(argv++));
+    }
+    x->x_otherout = outlet_new(&x->x_obj, &s_pointer);
+    x->x_bangout = outlet_new(&x->x_obj, &s_bang);
+    pointerinlet_new(&x->x_obj, &x->x_gp);
+    return (x);
+}
+
+static void ptrobj_traverse(t_ptrobj *x, t_symbol *s)
+{
+    t_glist *glist = (t_glist *)pd_findbyclass(s, canvas_class);
+    if (glist) gpointer_setglist(&x->x_gp, glist, 0);
+    else pd_error(x, "pointer: list '%s' not found", s->s_name);
+}
+
+static void ptrobj_vnext(t_ptrobj *x, float f)
+{
+    t_gobj *gobj;
+    t_gpointer *gp = &x->x_gp;
+    t_gstub *gs = gp->gp_stub;
+    t_glist *glist;
+    int wantselected = (f != 0);
+
+    if (!gs)
+    {
+    	pd_error(x, "ptrobj_next: no current pointer");
+    	return;
+    }
+    if (gs->gs_which != GP_GLIST)
+    {
+    	pd_error(x, "ptrobj_next: lists only, not arrays");
+    	return;
+    }
+    glist = gs->gs_un.gs_glist;
+    if (glist->gl_valid != gp->gp_valid)
+    {
+    	pd_error(x, "ptrobj_next: stale pointer");
+    	return;
+    }
+    if (wantselected && !glist_isvisible(glist))
+    {
+    	pd_error(x,
+	    "ptrobj_vnext: next-selected only works for a visible window");
+    	return;
+    }
+    gobj = &gp->gp_un.gp_scalar->sc_gobj;
+    
+    if (!gobj) gobj = glist->gl_list;
+    else gobj = gobj->g_next;
+    while (gobj && ((pd_class(&gobj->g_pd) != scalar_class) ||
+    	(wantselected && !glist_isselected(glist, gobj))))
+    	    gobj = gobj->g_next;
+    
+    if (gobj)
+    {
+    	t_typedout *to;
+    	int n;
+    	t_scalar *sc = (t_scalar *)gobj;
+    	t_symbol *templatesym = sc->sc_template;
+
+    	gp->gp_un.gp_scalar = sc; 
+    	for (n = x->x_ntypedout, to = x->x_typedout; n--; to++)
+    	{
+    	    if (to->to_type == templatesym)
+    	    {
+    	    	outlet_pointer(to->to_outlet, &x->x_gp);
+    	    	return;
+    	    }
+    	}
+    	outlet_pointer(x->x_otherout, &x->x_gp);
+    }
+    else
+    {
+    	gpointer_unset(gp);
+    	outlet_bang(x->x_bangout);
+    }
+}
+
+static void ptrobj_next(t_ptrobj *x)
+{
+    ptrobj_vnext(x, 0);
+}
+
+static void ptrobj_sendwindow(t_ptrobj *x, t_symbol *s, int argc, t_atom *argv)
+{
+    t_scalar *sc;
+    t_symbol *templatesym;
+    int n;
+    t_typedout *to;
+    t_glist *glist;
+    t_pd *canvas;
+    t_gstub *gs;
+    if (!gpointer_check(&x->x_gp, 1))
+    {
+    	pd_error(x, "ptrobj_bang: empty pointer");
+    	return;
+    }
+    gs = x->x_gp.gp_stub;
+    if (gs->gs_which == GP_GLIST)
+    	glist = gs->gs_un.gs_glist;  
+    else
+    {
+    	t_array *owner_array = gs->gs_un.gs_array;
+    	while (owner_array->a_gp.gp_stub->gs_which == GP_ARRAY)
+    	    owner_array = owner_array->a_gp.gp_stub->gs_un.gs_array;
+    	glist = owner_array->a_gp.gp_stub->gs_un.gs_glist;  
+    }
+    canvas = (t_pd *)glist_getcanvas(glist);
+    if (argc && argv->a_type == A_SYMBOL)
+    	pd_typedmess(canvas, argv->a_w.w_symbol, argc-1, argv+1);
+    else pd_error(x, "send-window: no message?");
+}
+
+static void ptrobj_bang(t_ptrobj *x)
+{
+    t_symbol *templatesym;
+    int n;
+    t_typedout *to;
+    if (!gpointer_check(&x->x_gp, 1))
+    {
+    	pd_error(x, "ptrobj_bang: empty pointer");
+    	return;
+    }
+    templatesym = gpointer_gettemplatesym(&x->x_gp);
+    for (n = x->x_ntypedout, to = x->x_typedout; n--; to++)
+    {
+    	if (to->to_type == templatesym)
+    	{
+    	    outlet_pointer(to->to_outlet, &x->x_gp);
+    	    return;
+    	}
+    }
+    outlet_pointer(x->x_otherout, &x->x_gp);
+}
+
+
+static void ptrobj_pointer(t_ptrobj *x, t_gpointer *gp)
+{
+    gpointer_unset(&x->x_gp);
+    gpointer_copy(gp, &x->x_gp);
+    ptrobj_bang(x);
+}
+
+static void ptrobj_free(t_ptrobj *x)
+{
+    freebytes(x->x_typedout, x->x_ntypedout * sizeof (*x->x_typedout));
+    gpointer_unset(&x->x_gp);
+}
+
+static void ptrobj_setup(void)
+{
+    ptrobj_class = class_new(gensym("pointer"), (t_newmethod)ptrobj_new,
+    	(t_method)ptrobj_free, sizeof(t_ptrobj), 0, A_GIMME, 0);
+    class_addmethod(ptrobj_class, (t_method)ptrobj_traverse, gensym("traverse"),
+    	A_SYMBOL, 0); 
+    class_addmethod(ptrobj_class, (t_method)ptrobj_next, gensym("next"), 0); 
+    class_addmethod(ptrobj_class, (t_method)ptrobj_vnext, gensym("vnext"), 
+    	A_DEFFLOAT, 0); 
+    class_addmethod(ptrobj_class, (t_method)ptrobj_sendwindow,
+    	gensym("send-window"), A_GIMME, 0); 
+    class_addpointer(ptrobj_class, ptrobj_pointer); 
+    class_addbang(ptrobj_class, ptrobj_bang); 
+}
+
+/* ---------------------- get ----------------------------- */
+
+static t_class *get_class;
+
+typedef struct _getvariable
+{
+    t_symbol *gv_sym;
+    t_outlet *gv_outlet;
+} t_getvariable;
+
+typedef struct _get
+{
+    t_object x_obj;
+    t_symbol *x_templatesym;
+    int x_nout;
+    t_getvariable *x_variables;
+} t_get;
+
+static void *get_new(t_symbol *why, int argc, t_atom *argv)
+{
+    t_get *x = (t_get *)pd_new(get_class);
+    int i;
+    t_getvariable *sp;
+    x->x_templatesym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv));
+    if (argc) argc--, argv++;
+    x->x_variables
+    	= (t_getvariable *)getbytes(argc * sizeof (*x->x_variables));
+    x->x_nout = argc;
+    for (i = 0, sp = x->x_variables; i < argc; i++, sp++)
+    {
+    	sp->gv_sym = atom_getsymbolarg(i, argc, argv);
+    	sp->gv_outlet = outlet_new(&x->x_obj, 0);
+    	    /* LATER connect with the template and set the outlet's type
+    	    correctly.  We can't yet guarantee that the template is there
+    	    before we hit this routine. */
+    }
+    return (x);
+}
+
+static void get_pointer(t_get *x, t_gpointer *gp)
+{
+    int nitems = x->x_nout, i;
+    t_symbol *templatesym = x->x_templatesym;
+    t_template *template = template_findbyname(templatesym);
+    t_gstub *gs = gp->gp_stub;
+    t_word *vec; 
+    t_getvariable *vp;
+    if (!template)
+    {
+    	pd_error(x, "get: couldn't find template %s", templatesym->s_name);
+    	return;
+    }
+    if (gpointer_ishead(gp))
+    {
+    	pd_error(x, "get: empty pointer");
+    	return;
+    }
+    if (gs->gs_which == GP_ARRAY) vec = gp->gp_un.gp_w;
+    else vec = gp->gp_un.gp_scalar->sc_vec;
+    for (i = nitems - 1, vp = x->x_variables + i; i >= 0; i--, vp--)
+    {
+    	float f = template_getfloat(template, vp->gv_sym, vec, 1);
+    	outlet_float(vp->gv_outlet, f);
+    	    /* LATER deal with other types. */
+    }
+}
+
+static void get_free(t_get *x)
+{
+    freebytes(x->x_variables, x->x_nout * sizeof (*x->x_variables));
+}
+
+static void get_setup(void)
+{
+    get_class = class_new(gensym("get"), (t_newmethod)get_new,
+    	(t_method)get_free, sizeof(t_get), 0, A_GIMME, 0);
+    class_addpointer(get_class, get_pointer); 
+}
+
+/* ---------------------- set ----------------------------- */
+
+static t_class *set_class;
+
+typedef struct _setvariable
+{
+    t_symbol *gv_sym;
+    t_float gv_f;  	/* LATER take other types */
+} t_setvariable;
+
+typedef struct _set
+{
+    t_object x_obj;
+    t_gpointer x_gp;
+    t_symbol *x_templatesym;
+    int x_nin;
+    t_setvariable *x_variables;
+} t_set;
+
+static void *set_new(t_symbol *why, int argc, t_atom *argv)
+{
+    t_set *x = (t_set *)pd_new(set_class);
+    int i;
+    t_setvariable *sp;
+    x->x_templatesym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv));
+    if (argc) argc--, argv++;
+    x->x_variables
+    	= (t_setvariable *)getbytes(argc * sizeof (*x->x_variables));
+    x->x_nin = argc;
+    if (argc)
+    {
+	for (i = 0, sp = x->x_variables; i < argc; i++, sp++)
+	{
+    	    sp->gv_sym = atom_getsymbolarg(i, argc, argv);
+    	    sp->gv_f = 0;
+    	    if (i) floatinlet_new(&x->x_obj, &sp->gv_f);
+    		/* LATER figure out type as in "get" object. */
+    	}
+    }
+    pointerinlet_new(&x->x_obj, &x->x_gp);
+    gpointer_init(&x->x_gp);
+    return (x);
+}
+
+static void set_float(t_set *x, t_float f)
+{
+    int nitems = x->x_nin, i;
+    t_symbol *templatesym = x->x_templatesym;
+    t_template *template = template_findbyname(templatesym);
+    t_setvariable *vp;
+    t_gpointer *gp = &x->x_gp;
+    t_gstub *gs = gp->gp_stub;
+    t_word *vec;
+    if (!template)
+    {
+    	pd_error(x, "set: couldn't find template %s", templatesym->s_name);
+    	return;
+    }
+    if (!gpointer_check(gp, 0))
+    {
+    	pd_error(x, "set: empty pointer");
+    	return;
+    }
+    if (gpointer_gettemplatesym(gp) != x->x_templatesym)
+    {
+    	pd_error(x, "set %s: got wrong template (%s)",
+	    x->x_templatesym->s_name, gpointer_gettemplatesym(gp)->s_name);
+    	return;
+    }
+    if (!nitems) return;
+    x->x_variables[0].gv_f = f;
+    if (gs->gs_which == GP_ARRAY) vec = gp->gp_un.gp_w;
+    else vec = gp->gp_un.gp_scalar->sc_vec;
+    for (i = 0, vp = x->x_variables; i < nitems; i++, vp++)
+    {
+    	template_setfloat(template, vp->gv_sym, vec, vp->gv_f, 1);
+    	    /* LATER deal with other types ala get_pointer. */
+    }
+    if (gs->gs_which == GP_GLIST)
+    	glist_redrawitem(gs->gs_un.gs_glist, (t_gobj *)(gp->gp_un.gp_scalar));  
+    else
+    {
+    	t_array *owner_array = gs->gs_un.gs_array;
+    	while (owner_array->a_gp.gp_stub->gs_which == GP_ARRAY)
+    	    owner_array = owner_array->a_gp.gp_stub->gs_un.gs_array;
+    	glist_redrawitem(owner_array->a_gp.gp_stub->gs_un.gs_glist,
+    	    (t_gobj *)(owner_array->a_gp.gp_un.gp_scalar));  
+    }
+}
+
+static void set_free(t_set *x)
+{
+    freebytes(x->x_variables, x->x_nin * sizeof (*x->x_variables));
+    gpointer_unset(&x->x_gp);
+}
+
+static void set_setup(void)
+{
+    set_class = class_new(gensym("set"), (t_newmethod)set_new,
+    	(t_method)set_free, sizeof(t_set), 0, A_GIMME, 0);
+    class_addfloat(set_class, set_float); 
+}
+
+/* ---------------------- elem ----------------------------- */
+
+static t_class *elem_class;
+
+typedef struct _elem
+{
+    t_object x_obj;
+    t_symbol *x_templatesym;
+    t_symbol *x_fieldsym;
+    t_gpointer x_gp;
+    t_gpointer x_gparent;
+} t_elem;
+
+static void *elem_new(t_symbol *templatesym, t_symbol *fieldsym)
+{
+    t_elem *x = (t_elem *)pd_new(elem_class);
+    x->x_templatesym = canvas_makebindsym(templatesym);
+    x->x_fieldsym = fieldsym;
+    gpointer_init(&x->x_gp);
+    gpointer_init(&x->x_gparent);
+    pointerinlet_new(&x->x_obj, &x->x_gparent);
+    outlet_new(&x->x_obj, &s_pointer);
+    return (x);
+}
+
+static void elem_float(t_elem *x, t_float f)
+{
+    int indx = f, nitems, onset;
+    t_symbol *templatesym = x->x_templatesym, *fieldsym = x->x_fieldsym,
+    	*elemtemplatesym;
+    t_template *template = template_findbyname(templatesym);
+    t_template *elemtemplate;
+    t_gpointer *gparent = &x->x_gparent;
+    t_word *w;
+    t_array *array;
+    int elemsize, type;
+    
+    if (!gpointer_check(gparent, 0))
+    {
+    	pd_error(x, "element: empty pointer");
+    	return;
+    }
+    if (gpointer_gettemplatesym(gparent) != x->x_templatesym)
+    {
+    	pd_error(x, "element %s: got wrong template (%s)",
+	    x->x_templatesym->s_name, gpointer_gettemplatesym(gparent)->s_name);
+    	return;
+    }
+    if (gparent->gp_stub->gs_which == GP_ARRAY) w = gparent->gp_un.gp_w;
+    else w = gparent->gp_un.gp_scalar->sc_vec;
+    if (!template)
+    {
+    	pd_error(x, "element: couldn't find template %s", templatesym->s_name);
+    	return;
+    }
+    if (!template_find_field(template, fieldsym,
+    	&onset, &type, &elemtemplatesym))
+    {
+    	pd_error(x, "element: couldn't find array field %s", fieldsym->s_name);
+    	return;
+    }
+    if (type != DT_ARRAY)
+    {
+    	pd_error(x, "element: field %s not of type array", fieldsym->s_name);
+    	return;
+    }
+    if (!(elemtemplate = template_findbyname(elemtemplatesym)))
+    {
+    	pd_error(x, "element: couldn't find field template %s",
+	    elemtemplatesym->s_name);
+    	return;
+    }
+
+    elemsize = elemtemplate->t_n * sizeof(t_word);
+
+    array = *(t_array **)(((char *)w) + onset);
+
+    nitems = array->a_n;
+    if (indx < 0) indx = 0;
+    if (indx >= nitems) indx = nitems-1;
+
+    gpointer_setarray(&x->x_gp, array, 
+    	(t_word *)((char *)(array->a_vec) + indx * elemsize));
+    outlet_pointer(x->x_obj.ob_outlet, &x->x_gp);
+}
+
+static void elem_free(t_elem *x, t_gpointer *gp)
+{
+    gpointer_unset(&x->x_gp);
+    gpointer_unset(&x->x_gparent);
+}
+
+static void elem_setup(void)
+{
+    elem_class = class_new(gensym("element"), (t_newmethod)elem_new,
+    	(t_method)elem_free, sizeof(t_elem), 0, A_DEFSYM, A_DEFSYM, 0);
+    class_addfloat(elem_class, elem_float); 
+}
+
+/* ---------------------- getsize ----------------------------- */
+
+static t_class *getsize_class;
+
+typedef struct _getsize
+{
+    t_object x_obj;
+    t_symbol *x_templatesym;
+    t_symbol *x_fieldsym;
+} t_getsize;
+
+static void *getsize_new(t_symbol *templatesym, t_symbol *fieldsym)
+{
+    t_getsize *x = (t_getsize *)pd_new(getsize_class);
+    x->x_templatesym = canvas_makebindsym(templatesym);
+    x->x_fieldsym = fieldsym;
+    outlet_new(&x->x_obj, &s_float);
+    return (x);
+}
+
+static void getsize_pointer(t_getsize *x, t_gpointer *gp)
+{
+    int nitems, onset, type;
+    t_symbol *templatesym = x->x_templatesym, *fieldsym = x->x_fieldsym,
+    	*elemtemplatesym;
+    t_template *template = template_findbyname(templatesym);
+    t_word *w;
+    t_array *array;
+    int elemsize;
+    t_gstub *gs = gp->gp_stub;
+    if (!template)
+    {
+    	pd_error(x, "getsize: couldn't find template %s", templatesym->s_name);
+    	return;
+    }
+    if (!template_find_field(template, fieldsym,
+    	&onset, &type, &elemtemplatesym))
+    {
+    	pd_error(x, "getsize: couldn't find array field %s", fieldsym->s_name);
+    	return;
+    }
+    if (type != DT_ARRAY)
+    {
+    	pd_error(x, "getsize: field %s not of type array", fieldsym->s_name);
+    	return;
+    }
+    if (gpointer_ishead(gp))
+    {
+    	pd_error(x, "getsize: empty pointer");
+    	return;
+    }
+    if (gpointer_gettemplatesym(gp) != x->x_templatesym)
+    {
+    	pd_error(x, "getsize %s: got wrong template (%s)",
+	    x->x_templatesym->s_name, gpointer_gettemplatesym(gp)->s_name);
+    	return;
+    }
+    if (gs->gs_which == GP_ARRAY) w = gp->gp_un.gp_w;
+    else w = gp->gp_un.gp_scalar->sc_vec;
+    
+    array = *(t_array **)(((char *)w) + onset);
+    outlet_float(x->x_obj.ob_outlet, (float)(array->a_n));
+}
+
+static void getsize_setup(void)
+{
+    getsize_class = class_new(gensym("getsize"), (t_newmethod)getsize_new, 0,
+    	sizeof(t_getsize), 0, A_DEFSYM, A_DEFSYM, 0);
+    class_addpointer(getsize_class, getsize_pointer); 
+}
+
+/* ---------------------- setsize ----------------------------- */
+
+static t_class *setsize_class;
+
+typedef struct _setsize
+{
+    t_object x_obj;
+    t_symbol *x_templatesym;
+    t_symbol *x_fieldsym;
+    t_gpointer x_gp;
+} t_setsize;
+
+static void *setsize_new(t_symbol *templatesym, t_symbol *fieldsym,
+    t_floatarg newsize)
+{
+    t_setsize *x = (t_setsize *)pd_new(setsize_class);
+    x->x_templatesym = canvas_makebindsym(templatesym);
+    x->x_fieldsym = fieldsym;
+    gpointer_init(&x->x_gp);
+    
+    pointerinlet_new(&x->x_obj, &x->x_gp);
+    return (x);
+}
+
+static void setsize_float(t_setsize *x, t_float f)
+{
+    int nitems, onset, type;
+    t_symbol *templatesym = x->x_templatesym, *fieldsym = x->x_fieldsym,
+    	*elemtemplatesym;
+    t_template *template = template_findbyname(templatesym);
+    t_template *elemtemplate;
+    t_word *w;
+    t_atom at;
+    t_array *array;
+    int elemsize;
+    int newsize = f;
+    t_gpointer *gp = &x->x_gp;
+    t_gstub *gs = gp->gp_stub;
+    if (!gpointer_check(&x->x_gp, 0))
+    {
+    	pd_error(x, "setsize: empty pointer");
+    	return;
+    }
+    if (gpointer_gettemplatesym(&x->x_gp) != x->x_templatesym)
+    {
+    	pd_error(x, "setsize %s: got wrong template (%s)",
+	    x->x_templatesym->s_name,
+	    	gpointer_gettemplatesym(&x->x_gp)->s_name);
+    	return;
+    }
+    if (gs->gs_which == GP_ARRAY) w = gp->gp_un.gp_w;
+    else w = gp->gp_un.gp_scalar->sc_vec;
+
+    if (!template)
+    {
+    	pd_error(x,"setsize: couldn't find template %s", templatesym->s_name);
+    	return;
+    }
+    if (!template_find_field(template, fieldsym,
+    	&onset, &type, &elemtemplatesym))
+    {
+    	pd_error(x,"setsize: couldn't find array field %s", fieldsym->s_name);
+    	return;
+    }
+    if (type != DT_ARRAY)
+    {
+    	pd_error(x,"setsize: field %s not of type array", fieldsym->s_name);
+    	return;
+    }
+
+    if (!(elemtemplate = template_findbyname(elemtemplatesym)))
+    {
+    	pd_error(x,"element: couldn't find field template %s",
+	    elemtemplatesym->s_name);
+    	return;
+    }
+
+    elemsize = elemtemplate->t_n * sizeof(t_word);
+
+    array = *(t_array **)(((char *)w) + onset);
+
+    if (elemsize != array->a_elemsize) bug("setsize_gpointer");
+
+    nitems = array->a_n;
+    if (newsize < 1) newsize = 1;
+    if (newsize == nitems) return;
+    
+    	/* erase the array before resizing it.  If we belong to a
+    	scalar it's easy, but if we belong to an element of another
+    	array we have to search back until we get to a scalar to erase.
+    	When graphics updates become queueable this may fall apart... */
+
+
+    if (gs->gs_which == GP_GLIST)
+    {
+	if (glist_isvisible(gs->gs_un.gs_glist))
+    	    gobj_vis((t_gobj *)(gp->gp_un.gp_scalar), gs->gs_un.gs_glist, 0);  
+    }
+    else
+    {
+    	t_array *owner_array = gs->gs_un.gs_array;
+    	while (owner_array->a_gp.gp_stub->gs_which == GP_ARRAY)
+    	    owner_array = owner_array->a_gp.gp_stub->gs_un.gs_array;
+	if (glist_isvisible(owner_array->a_gp.gp_stub->gs_un.gs_glist))
+    	    gobj_vis((t_gobj *)(owner_array->a_gp.gp_un.gp_scalar),
+    		owner_array->a_gp.gp_stub->gs_un.gs_glist, 0);  
+    }
+    	/* now do the resizing and, if growing, initialize new scalars */
+    array->a_vec = (char *)resizebytes(array->a_vec,
+    	elemsize * nitems, elemsize * newsize);
+    array->a_n = newsize;
+    if (newsize > nitems)
+    {
+    	char *newelem = ((char *)array->a_vec) + nitems * elemsize;
+    	int i = 0, nnew = newsize - nitems;
+    	
+    	while (nnew--)
+    	{
+    	    word_init((t_word *)newelem, elemtemplate, gp);
+    	    newelem += elemsize;
+    	    /* post("new %x %x, ntypes %d", newelem, *(int *)newelem, ntypes); */
+    	}
+    }
+
+    /* redraw again. */
+    if (gs->gs_which == GP_GLIST)
+    {
+	if (glist_isvisible(gs->gs_un.gs_glist))
+    	    gobj_vis((t_gobj *)(gp->gp_un.gp_scalar), gs->gs_un.gs_glist, 1);  
+    }
+    else
+    {
+    	t_array *owner_array = gs->gs_un.gs_array;
+    	while (owner_array->a_gp.gp_stub->gs_which == GP_ARRAY)
+    	    owner_array = owner_array->a_gp.gp_stub->gs_un.gs_array;
+	if (glist_isvisible(owner_array->a_gp.gp_stub->gs_un.gs_glist))
+    	    gobj_vis((t_gobj *)(owner_array->a_gp.gp_un.gp_scalar),
+    		owner_array->a_gp.gp_stub->gs_un.gs_glist, 1);  
+    }
+}
+
+
+static void setsize_free(t_setsize *x)
+{
+    gpointer_unset(&x->x_gp);
+}
+
+static void setsize_setup(void)
+{
+    setsize_class = class_new(gensym("setsize"), (t_newmethod)setsize_new,
+    	(t_method)setsize_free, sizeof(t_setsize), 0,
+	A_DEFSYM, A_DEFSYM, A_DEFFLOAT, 0);
+    class_addfloat(setsize_class, setsize_float);
+}
+
+/* ---------------------- append ----------------------------- */
+
+static t_class *append_class;
+
+typedef struct _appendvariable
+{
+    t_symbol *gv_sym;
+    t_float gv_f;
+} t_appendvariable;
+
+typedef struct _append
+{
+    t_object x_obj;
+    t_gpointer x_gp;
+    t_symbol *x_templatesym;
+    int x_nin;
+    t_appendvariable *x_variables;
+} t_append;
+
+static void *append_new(t_symbol *why, int argc, t_atom *argv)
+{
+    t_append *x = (t_append *)pd_new(append_class);
+    int i;
+    t_appendvariable *sp;
+    x->x_templatesym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv));
+    if (argc) argc--, argv++;
+    x->x_variables
+    	= (t_appendvariable *)getbytes(argc * sizeof (*x->x_variables));
+    x->x_nin = argc;
+    if (argc)
+    {
+	for (i = 0, sp = x->x_variables; i < argc; i++, sp++)
+	{
+    	    sp->gv_sym = atom_getsymbolarg(i, argc, argv);
+    	    sp->gv_f = 0;
+    	    if (i) floatinlet_new(&x->x_obj, &sp->gv_f);
+    	}
+    }
+    pointerinlet_new(&x->x_obj, &x->x_gp);
+    outlet_new(&x->x_obj, &s_pointer);
+    gpointer_init(&x->x_gp);
+    return (x);
+}
+
+static void append_float(t_append *x, t_float f)
+{
+    int nitems = x->x_nin, i;
+    t_symbol *templatesym = x->x_templatesym;
+    t_template *template = template_findbyname(templatesym);
+    t_appendvariable *vp;
+    t_gpointer *gp = &x->x_gp;
+    t_gstub *gs = gp->gp_stub;
+    t_word *vec;
+    t_scalar *sc, *oldsc;
+    t_glist *glist;
+    if (!template)
+    {
+    	pd_error(x, "append: couldn't find template %s", templatesym->s_name);
+    	return;
+    }
+    if (!gs)
+    {
+    	pd_error(x, "append: no current pointer");
+    	return;
+    }
+    if (gs->gs_which != GP_GLIST)
+    {
+    	pd_error(x, "append: lists only, not arrays");
+    	return;
+    }
+    glist = gs->gs_un.gs_glist;
+    if (glist->gl_valid != gp->gp_valid)
+    {
+    	pd_error(x, "append: stale pointer");
+    	return;
+    }
+    if (!nitems) return;
+    x->x_variables[0].gv_f = f;
+
+    sc = scalar_new(glist, templatesym);
+    if (!sc)
+    {
+    	pd_error(x, "%s: couldn't create scalar", templatesym->s_name);
+    	return;
+    }
+    oldsc = gp->gp_un.gp_scalar;
+    
+    if (oldsc)
+    {
+    	sc->sc_gobj.g_next = oldsc->sc_gobj.g_next;
+    	oldsc->sc_gobj.g_next = &sc->sc_gobj;
+    }
+    else
+    {
+    	sc->sc_gobj.g_next = glist->gl_list;
+    	glist->gl_list = &sc->sc_gobj;
+    }
+    if (glist_isvisible(glist_getcanvas(glist)))
+    	gobj_vis(&sc->sc_gobj, glist, 1);
+
+    gp->gp_un.gp_scalar = sc;
+    vec = sc->sc_vec;
+    for (i = 0, vp = x->x_variables; i < nitems; i++, vp++)
+    {
+    	template_setfloat(template, vp->gv_sym, vec, vp->gv_f, 1);
+    }
+ 
+    glist_redrawitem(glist, (t_gobj *)sc);  
+
+    outlet_pointer(x->x_obj.ob_outlet, gp);
+}
+
+static void append_free(t_append *x)
+{
+    freebytes(x->x_variables, x->x_nin * sizeof (*x->x_variables));
+    gpointer_unset(&x->x_gp);
+}
+
+static void append_setup(void)
+{
+    append_class = class_new(gensym("append"), (t_newmethod)append_new,
+    	(t_method)append_free, sizeof(t_append), 0, A_GIMME, 0);
+    class_addfloat(append_class, append_float); 
+}
+
+/* ---------------------- sublist ----------------------------- */
+
+static t_class *sublist_class;
+
+typedef struct _sublist
+{
+    t_object x_obj;
+    t_symbol *x_templatesym;
+    t_symbol *x_fieldsym;
+    t_gpointer x_gp;
+} t_sublist;
+
+static void *sublist_new(t_symbol *templatesym, t_symbol *fieldsym)
+{
+    t_sublist *x = (t_sublist *)pd_new(sublist_class);
+    x->x_templatesym = canvas_makebindsym(templatesym);
+    x->x_fieldsym = fieldsym;
+    gpointer_init(&x->x_gp);
+    outlet_new(&x->x_obj, &s_pointer);
+    return (x);
+}
+
+static void sublist_pointer(t_sublist *x, t_gpointer *gp)
+{
+    t_symbol *templatesym = x->x_templatesym, *dummy;
+    t_template *template = template_findbyname(templatesym);
+    t_gstub *gs = gp->gp_stub;
+    t_word *vec; 
+    t_getvariable *vp;
+    int onset, type;
+    t_word *w;
+
+    if (!template)
+    {
+    	pd_error(x, "sublist: couldn't find template %s", templatesym->s_name);
+    	return;
+    }
+    if (gpointer_ishead(gp))
+    {
+    	pd_error(x, "sublist: empty pointer");
+    	return;
+    }
+    if (!template_find_field(template, x->x_fieldsym,
+    	&onset, &type, &dummy))
+    {
+    	pd_error(x, "sublist: couldn't find field %s", x->x_fieldsym->s_name);
+    	return;
+    }
+    if (type != DT_LIST)
+    {
+    	pd_error(x, "sublist: field %s not of type list", x->x_fieldsym->s_name);
+    	return;
+    }
+    if (gs->gs_which == GP_ARRAY) w = gp->gp_un.gp_w;
+    else w = gp->gp_un.gp_scalar->sc_vec;
+    
+    gpointer_setglist(&x->x_gp, *(t_glist **)(((char *)w) + onset), 0);
+
+    outlet_pointer(x->x_obj.ob_outlet, &x->x_gp);
+}
+
+static void sublist_free(t_sublist *x, t_gpointer *gp)
+{
+    gpointer_unset(&x->x_gp);
+}
+
+static void sublist_setup(void)
+{
+    sublist_class = class_new(gensym("sublist"), (t_newmethod)sublist_new,
+    	(t_method)sublist_free, sizeof(t_sublist), 0, A_DEFSYM, A_DEFSYM, 0);
+    class_addpointer(sublist_class, sublist_pointer); 
+}
+
+/* ----------------- setup function ------------------- */
+
+void g_traversal_setup(void)
+{
+    ptrobj_setup();
+    get_setup();
+    set_setup();
+    elem_setup();
+    getsize_setup();
+    setsize_setup();
+    append_setup();
+    sublist_setup();
+}
-- 
cgit v1.2.1