diff options
Diffstat (limited to 'sarray.c')
| -rw-r--r-- | sarray.c | 264 |
1 files changed, 264 insertions, 0 deletions
diff --git a/sarray.c b/sarray.c new file mode 100644 index 0000000..d44f7ce --- /dev/null +++ b/sarray.c @@ -0,0 +1,264 @@ +/* +Copyright (C) 2003 Antoine Rousseau + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ + +/* a shared symbol array, ala "value" .*/ + +#include "m_pd.h" +#include <stdlib.h> +#include <string.h> + +static t_class *sarray_class, *scommon_class; +static t_symbol *s__; + +typedef struct scommon +{ + t_pd c_pd; + t_symbol *c_sym; + int c_refcount; + int c_len; + t_symbol **c_array; +} t_scommon; + +typedef struct _sarray +{ + t_object x_obj; + t_symbol *x_sym; + t_scommon *x_c; + //t_outlet *x_symout; + //t_outlet *x_lenout; +} t_sarray; + +/*static int scommon_find(t_scommon *x, t_symbol *s) +{ + t_sitem *si=x->first; + t_int i=1; + + while(si) { + if(!strcmp(si->s->s_name,s->s_name)) return i; + si=si->next; + i++; + } + return 0; +}*/ + +static t_symbol *scommon_get(t_scommon *x, t_float f) +{ + int i=(int)f; + + if(i<0) i=0; + if(i>=x->c_len) i=x->c_len-1; + return x->c_array[i]; +} + +static void scommon_set(t_scommon *x, t_float f, t_symbol *s) +{ + int i=(int)f; + + if((i<0)||(i>=x->c_len)) return; + x->c_array[i]=s; + //x->c_array[i]=gensym(strdup(s->s_name)); + //x->c_array[i]=gensym("ok"); +} + +static void scommon_setlen(t_scommon *x, t_float flen) +{ + int i,oldlen=x->c_len,len=flen; + + if(len<1) len=1; + x->c_len=len; + + x->c_array=realloc(x->c_array,sizeof(t_symbol *)*len); + + if(len>oldlen) for(i=oldlen;i<len;i++) x->c_array[i]=&s_; +} + +static void scommon_reset(t_scommon *x) +{ + int i; + + for(i=0;i<x->c_len;i++) x->c_array[i]=&s_; +} + +static t_atom *scommon_dump(t_scommon *x,t_symbol *s) +{ + int i; + t_atom *atombuf; + + atombuf = (t_atom *)getbytes(sizeof(t_atom)*x->c_len); + + for(i=0;i<x->c_len;i++) { + if(x->c_array[i]==&s_) SETSYMBOL(&atombuf[i],s); + else SETSYMBOL(&atombuf[i],x->c_array[i]); + } + + return atombuf; +} + +static void scommon_ff(t_scommon *x) +{ + //scommon_reset(x); + pd_unbind((t_pd*)x, x->c_sym); +} + +static void *scommon_new(t_symbol *s) +{ + t_scommon *x = (t_scommon *)pd_new(scommon_class); + + x->c_refcount = 0; + x->c_sym=s; + pd_bind((t_pd*)x, s); + + x->c_len=1; + x->c_array=malloc(sizeof(t_symbol *)*1); + scommon_reset(x); + + return (x); +} + + + /* get a pointer to a named symbol list (a "scommon" object), + which is created if necessary. */ +t_scommon *sarray_scget(t_symbol *s) +{ + t_scommon *c = (t_scommon *)pd_findbyclass(s, scommon_class); + + if (!c) c = (t_scommon *)scommon_new(s); + c->c_refcount++; + return (c); +} + + /* release a variable. This only frees the "scommon" resource when the + last interested party releases it. */ +void sarray_release(t_scommon *c) +{ + if (!--c->c_refcount) scommon_ff(c); +} + + +static void *sarray_new(t_symbol *s,t_float len) +{ + t_sarray *x = (t_sarray *)pd_new(sarray_class); + + x->x_sym = s; + x->x_c = sarray_scget(s); + if(len) scommon_setlen(x->x_c,len); + + outlet_new(&x->x_obj, &s_anything); + //x->x_symout=outlet_new(&x->x_obj, &s_anything); + //x->x_lenout=outlet_new(&x->x_obj, &s_float); + return (x); +} + +static void sarray_ff(t_sarray *x) +{ + sarray_release(x->x_c); +} + +static void sarray_print(t_sarray *x) +{ + int i; + + for(i=0;i<x->x_c->c_len;i++){ + post("item %d: %s",i,x->x_c->c_array[i]->s_name); + } +} + +static void sarray_reset(t_sarray *x) +{ + scommon_reset(x->x_c); +} + +static void sarray_set(t_sarray *x, t_symbol *sfoo,int argc, t_atom *argv) +{ + int i,j=0; + t_symbol *snull=&s_,*s; + + /*if((argc<2)||(argv[0].a_type!=A_FLOAT)) + { + error("Bad arguments for message 'set' to object 'sarray'"); + return ; + }*/ + if(argv[0].a_type==A_SYMBOL) { + snull=atom_getsymbol(&argv[0]); + j=1; + } + + if(argv[j].a_type!=A_FLOAT){ + error("Bad arguments for message 'set' to object 'sarray'"); + return ; + } + + i=atom_getfloat(&argv[j++]); + + while((j<argc)&&(argv[j].a_type==A_SYMBOL)){ + s=atom_getsymbol(&argv[j++]); + if(s==snull) s=&s_; + scommon_set(x->x_c,i++,s); + } +} + +static void sarray_get(t_sarray *x,t_float i) +{ + t_symbol *s=scommon_get(x->x_c,i); + + if(s==&s_) outlet_bang(x->x_obj.ob_outlet); + else outlet_symbol(x->x_obj.ob_outlet,scommon_get(x->x_c,i)); +} + +static void sarray_dump(t_sarray *x,t_symbol *s) +{ + t_atom *l=scommon_dump(x->x_c,s); + + outlet_list(x->x_obj.ob_outlet, &s_list, x->x_c->c_len, l); + free(l); +} + +static void sarray_setarray(t_sarray *x,t_symbol *s) +{ + sarray_release(x->x_c); + x->x_c = sarray_scget(s); + x->x_sym = s; +} + +static void sarray_setlen(t_sarray *x,t_float len) +{ + scommon_setlen(x->x_c,len); +} + + +void sarray_setup(void) +{ + s__=gensym("_"); + sarray_class = class_new(gensym("sarray"), (t_newmethod)sarray_new, + (t_method)sarray_ff, + sizeof(t_sarray), 0, A_DEFSYM, A_DEFFLOAT,0); + + //class_addbang(sarray_class, sarray_bang); + //class_addfloat(sarray_class, sarray_float); + class_addmethod(sarray_class,(t_method)sarray_set, gensym("set"),A_GIMME,0); + class_addmethod(sarray_class,(t_method)sarray_get, gensym("get"),A_FLOAT,0); + class_addmethod(sarray_class,(t_method)sarray_reset, gensym("reset"),0); + class_addmethod(sarray_class,(t_method)sarray_print, gensym("print"),0); + class_addmethod(sarray_class,(t_method)sarray_setlen, gensym("setlen"),A_FLOAT,0); + class_addmethod(sarray_class,(t_method)sarray_dump, gensym("dump"),A_DEFSYM,0); + class_addmethod(sarray_class,(t_method)sarray_setarray, gensym("setarray"),A_SYMBOL,0); + scommon_class = class_new(gensym("sarray"), 0, 0, + sizeof(t_scommon), CLASS_PD, 0); +} + |