diff options
Diffstat (limited to 'pd/src/x_connective.c')
| -rw-r--r-- | pd/src/x_connective.c | 1452 |
1 files changed, 1452 insertions, 0 deletions
diff --git a/pd/src/x_connective.c b/pd/src/x_connective.c new file mode 100644 index 00000000..2b28f052 --- /dev/null +++ b/pd/src/x_connective.c @@ -0,0 +1,1452 @@ +/* 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. */ + +/* connective objects */ + +#include "m_pd.h" + +#include <string.h> +#include <stdio.h> +extern t_pd *newest; + +/* -------------------------- int ------------------------------ */ +static t_class *pdint_class; + +typedef struct _pdint +{ + t_object x_obj; + t_float x_f; +} t_pdint; + +static void *pdint_new(t_floatarg f) +{ + t_pdint *x = (t_pdint *)pd_new(pdint_class); + x->x_f = f; + outlet_new(&x->x_obj, &s_float); + floatinlet_new(&x->x_obj, &x->x_f); + return (x); +} + +static void pdint_bang(t_pdint *x) +{ + outlet_float(x->x_obj.ob_outlet, (t_float)(int)(x->x_f)); +} + +static void pdint_float(t_pdint *x, t_float f) +{ + outlet_float(x->x_obj.ob_outlet, (t_float)(int)(x->x_f = f)); +} + +void pdint_setup(void) +{ + pdint_class = class_new(gensym("int"), (t_newmethod)pdint_new, 0, + sizeof(t_pdint), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)pdint_new, gensym("i"), A_DEFFLOAT, 0); + class_addbang(pdint_class, pdint_bang); + class_addfloat(pdint_class, pdint_float); +} + +/* -------------------------- float ------------------------------ */ +static t_class *pdfloat_class; + +typedef struct _pdfloat +{ + t_object x_obj; + t_float x_f; +} t_pdfloat; + + /* "float," "symbol," and "bang" are special because + they're created by short-circuited messages to the "new" + object which are handled specially in pd_typedmess(). */ + +static void *pdfloat_new(t_pd *dummy, t_float f) +{ + t_pdfloat *x = (t_pdfloat *)pd_new(pdfloat_class); + x->x_f = f; + outlet_new(&x->x_obj, &s_float); + floatinlet_new(&x->x_obj, &x->x_f); + newest = &x->x_obj.ob_pd; + return (x); +} + +static void *pdfloat_new2(t_floatarg f) +{ + return (pdfloat_new(0, f)); +} + +static void pdfloat_bang(t_pdfloat *x) +{ + outlet_float(x->x_obj.ob_outlet, x->x_f); +} + +static void pdfloat_float(t_pdfloat *x, t_float f) +{ + outlet_float(x->x_obj.ob_outlet, x->x_f = f); +} + +void pdfloat_setup(void) +{ + pdfloat_class = class_new(gensym("float"), (t_newmethod)pdfloat_new, 0, + sizeof(t_pdfloat), 0, A_FLOAT, 0); + class_addcreator((t_newmethod)pdfloat_new2, gensym("f"), A_DEFFLOAT, 0); + class_addbang(pdfloat_class, pdfloat_bang); + class_addfloat(pdfloat_class, (t_method)pdfloat_float); +} + +/* -------------------------- symbol ------------------------------ */ +static t_class *pdsymbol_class; + +typedef struct _pdsymbol +{ + t_object x_obj; + t_symbol *x_s; +} t_pdsymbol; + +static void *pdsymbol_new(t_pd *dummy, t_symbol *s) +{ + t_pdsymbol *x = (t_pdsymbol *)pd_new(pdsymbol_class); + x->x_s = s; + outlet_new(&x->x_obj, &s_symbol); + symbolinlet_new(&x->x_obj, &x->x_s); + newest = &x->x_obj.ob_pd; + return (x); +} + +static void pdsymbol_bang(t_pdsymbol *x) +{ + outlet_symbol(x->x_obj.ob_outlet, x->x_s); +} + +static void pdsymbol_symbol(t_pdsymbol *x, t_symbol *s) +{ + outlet_symbol(x->x_obj.ob_outlet, x->x_s = s); +} + +static void pdsymbol_anything(t_pdsymbol *x, t_symbol *s, int ac, t_atom *av) +{ + outlet_symbol(x->x_obj.ob_outlet, x->x_s = s); +} + +void pdsymbol_setup(void) +{ + pdsymbol_class = class_new(gensym("symbol"), (t_newmethod)pdsymbol_new, 0, + sizeof(t_pdsymbol), 0, A_SYMBOL, 0); + class_addbang(pdsymbol_class, pdsymbol_bang); + class_addsymbol(pdsymbol_class, pdsymbol_symbol); + class_addanything(pdsymbol_class, pdsymbol_anything); +} + +/* -------------------------- bang ------------------------------ */ +static t_class *bang_class; + +typedef struct _bang +{ + t_object x_obj; +} t_bang; + +static void *bang_new(t_pd *dummy) +{ + t_bang *x = (t_bang *)pd_new(bang_class); + outlet_new(&x->x_obj, &s_bang); + newest = &x->x_obj.ob_pd; + return (x); +} + +static void *bang_new2(t_bang f) +{ + return (bang_new(0)); +} + +static void bang_bang(t_bang *x) +{ + outlet_bang(x->x_obj.ob_outlet); +} + +void bang_setup(void) +{ + bang_class = class_new(gensym("bang"), (t_newmethod)bang_new, 0, + sizeof(t_bang), 0, 0); + class_addcreator((t_newmethod)bang_new2, gensym("b"), 0); + class_addbang(bang_class, bang_bang); + class_addfloat(bang_class, bang_bang); + class_addsymbol(bang_class, bang_bang); + class_addlist(bang_class, bang_bang); + class_addanything(bang_class, bang_bang); +} + +/* -------------------- send ------------------------------ */ + +static t_class *send_class; + +typedef struct _send +{ + t_object x_obj; + t_symbol *x_sym; +} t_send; + +static void send_bang(t_send *x) +{ + if (x->x_sym->s_thing) pd_bang(x->x_sym->s_thing); +} + +static void send_float(t_send *x, t_float f) +{ + if (x->x_sym->s_thing) pd_float(x->x_sym->s_thing, f); +} + +static void send_symbol(t_send *x, t_symbol *s) +{ + if (x->x_sym->s_thing) pd_symbol(x->x_sym->s_thing, s); +} + +static void send_pointer(t_send *x, t_gpointer *gp) +{ + if (x->x_sym->s_thing) pd_pointer(x->x_sym->s_thing, gp); +} + +static void send_list(t_send *x, t_symbol *s, int argc, t_atom *argv) +{ + if (x->x_sym->s_thing) pd_list(x->x_sym->s_thing, s, argc, argv); +} + +static void send_anything(t_send *x, t_symbol *s, int argc, t_atom *argv) +{ + if (x->x_sym->s_thing) typedmess(x->x_sym->s_thing, s, argc, argv); +} + +static void *send_new(t_symbol *s) +{ + t_send *x = (t_send *)pd_new(send_class); + x->x_sym = s; + return (x); +} + +static void send_setup(void) +{ + send_class = class_new(gensym("send"), (t_newmethod)send_new, 0, + sizeof(t_send), 0, A_DEFSYM, 0); + class_addcreator((t_newmethod)send_new, gensym("s"), A_DEFSYM, 0); + class_addbang(send_class, send_bang); + class_addfloat(send_class, send_float); + class_addsymbol(send_class, send_symbol); + class_addpointer(send_class, send_pointer); + class_addlist(send_class, send_list); + class_addanything(send_class, send_anything); +} +/* -------------------- receive ------------------------------ */ + +static t_class *receive_class; + +typedef struct _receive +{ + t_object x_obj; + t_symbol *x_sym; +} t_receive; + +static void receive_bang(t_receive *x) +{ + outlet_bang(x->x_obj.ob_outlet); +} + +static void receive_float(t_receive *x, t_float f) +{ + outlet_float(x->x_obj.ob_outlet, f); +} + +static void receive_symbol(t_receive *x, t_symbol *s) +{ + outlet_symbol(x->x_obj.ob_outlet, s); +} + +static void receive_pointer(t_receive *x, t_gpointer *gp) +{ + outlet_pointer(x->x_obj.ob_outlet, gp); +} + +static void receive_list(t_receive *x, t_symbol *s, int argc, t_atom *argv) +{ + outlet_list(x->x_obj.ob_outlet, s, argc, argv); +} + +static void receive_anything(t_receive *x, t_symbol *s, int argc, t_atom *argv) +{ + outlet_anything(x->x_obj.ob_outlet, s, argc, argv); +} + +static void *receive_new(t_symbol *s) +{ + t_receive *x = (t_receive *)pd_new(receive_class); + x->x_sym = s; + pd_bind(&x->x_obj.ob_pd, s); + outlet_new(&x->x_obj, 0); + return (x); +} + +static void receive_free(t_receive *x) +{ + pd_unbind(&x->x_obj.ob_pd, x->x_sym); +} + +static void receive_setup(void) +{ + receive_class = class_new(gensym("receive"), (t_newmethod)receive_new, + (t_method)receive_free, sizeof(t_receive), CLASS_NOINLET, A_DEFSYM, 0); + class_addcreator((t_newmethod)receive_new, gensym("r"), A_DEFSYM, 0); + class_addbang(receive_class, receive_bang); + class_addfloat(receive_class, (t_method)receive_float); + class_addsymbol(receive_class, receive_symbol); + class_addpointer(receive_class, receive_pointer); + class_addlist(receive_class, receive_list); + class_addanything(receive_class, receive_anything); +} + +/* -------------------------- select ------------------------------ */ + +static t_class *sel1_class; + +typedef struct _sel1 +{ + t_object x_obj; + t_atom x_atom; + t_outlet *x_outlet1; + t_outlet *x_outlet2; +} t_sel1; + +static void sel1_float(t_sel1 *x, t_float f) +{ + if (x->x_atom.a_type == A_FLOAT && f == x->x_atom.a_w.w_float) + outlet_bang(x->x_outlet1); + else outlet_float(x->x_outlet2, f); +} + +static void sel1_symbol(t_sel1 *x, t_symbol *s) +{ + if (x->x_atom.a_type == A_SYMBOL && s == x->x_atom.a_w.w_symbol) + outlet_bang(x->x_outlet1); + else outlet_symbol(x->x_outlet2, s); +} + +static t_class *sel2_class; + +typedef struct _selectelement +{ + t_word e_w; + t_outlet *e_outlet; +} t_selectelement; + +typedef struct _sel2 +{ + t_object x_obj; + t_atomtype x_type; + t_int x_nelement; + t_selectelement *x_vec; + t_outlet *x_rejectout; +} t_sel2; + +static void sel2_float(t_sel2 *x, t_float f) +{ + t_selectelement *e; + int nelement; + if (x->x_type == A_FLOAT) + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + if (e->e_w.w_float == f) + { + outlet_bang(e->e_outlet); + return; + } + } + outlet_float(x->x_rejectout, f); +} + +static void sel2_symbol(t_sel2 *x, t_symbol *s) +{ + t_selectelement *e; + int nelement; + if (x->x_type == A_SYMBOL) + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + if (e->e_w.w_symbol == s) + { + outlet_bang(e->e_outlet); + return; + } + } + outlet_symbol(x->x_rejectout, s); +} + +static void sel2_free(t_sel2 *x) +{ + freebytes(x->x_vec, x->x_nelement * sizeof(*x->x_vec)); +} + +static void *select_new(t_symbol *s, int argc, t_atom *argv) +{ + t_atom a; + if (argc == 0) + { + argc = 1; + SETFLOAT(&a, 0); + argv = &a; + } + if (argc == 1) + { + t_sel1 *x = (t_sel1 *)pd_new(sel1_class); + x->x_atom = *argv; + x->x_outlet1 = outlet_new(&x->x_obj, &s_bang); + if (argv->a_type == A_FLOAT) + { + floatinlet_new(&x->x_obj, &x->x_atom.a_w.w_float); + x->x_outlet2 = outlet_new(&x->x_obj, &s_float); + } + else + { + symbolinlet_new(&x->x_obj, &x->x_atom.a_w.w_symbol); + x->x_outlet2 = outlet_new(&x->x_obj, &s_symbol); + } + return (x); + } + else + { + int n; + t_selectelement *e; + t_sel2 *x = (t_sel2 *)pd_new(sel2_class); + x->x_nelement = argc; + x->x_vec = (t_selectelement *)getbytes(argc * sizeof(*x->x_vec)); + x->x_type = argv[0].a_type; + for (n = 0, e = x->x_vec; n < argc; n++, e++) + { + e->e_outlet = outlet_new(&x->x_obj, &s_bang); + if ((x->x_type = argv->a_type) == A_FLOAT) + e->e_w.w_float = atom_getfloatarg(n, argc, argv); + else e->e_w.w_symbol = atom_getsymbolarg(n, argc, argv); + } + x->x_rejectout = outlet_new(&x->x_obj, &s_float); + return (x); + } + +} + +void select_setup(void) +{ + sel1_class = class_new(gensym("select"), 0, 0, + sizeof(t_sel1), 0, 0); + class_addfloat(sel1_class, sel1_float); + class_addsymbol(sel1_class, sel1_symbol); + + sel2_class = class_new(gensym("select"), 0, (t_method)sel2_free, + sizeof(t_sel2), 0, 0); + class_addfloat(sel2_class, sel2_float); + class_addsymbol(sel2_class, sel2_symbol); + + class_addcreator((t_newmethod)select_new, gensym("select"), A_GIMME, 0); + class_addcreator((t_newmethod)select_new, gensym("sel"), A_GIMME, 0); +} + +/* -------------------------- route ------------------------------ */ + +static t_class *route_class; + +typedef struct _routeelement +{ + t_word e_w; + t_outlet *e_outlet; +} t_routeelement; + +typedef struct _route +{ + t_object x_obj; + t_atomtype x_type; + t_int x_nelement; + t_routeelement *x_vec; + t_outlet *x_rejectout; +} t_route; + +static void route_anything(t_route *x, t_symbol *sel, int argc, t_atom *argv) +{ + t_routeelement *e; + int nelement; + if (x->x_type == A_SYMBOL) + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + if (e->e_w.w_symbol == sel) + { + if (argc > 0 && argv[0].a_type == A_SYMBOL) + outlet_anything(e->e_outlet, argv[0].a_w.w_symbol, + argc-1, argv+1); + else outlet_list(e->e_outlet, 0, argc, argv); + return; + } + } + outlet_anything(x->x_rejectout, sel, argc, argv); +} + +static void route_list(t_route *x, t_symbol *sel, int argc, t_atom *argv) +{ + t_routeelement *e; + int nelement; + if (x->x_type == A_FLOAT) + { + float f; + if (!argc) return; + f = atom_getfloat(argv); + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + if (e->e_w.w_float == f) + { + if (argc > 1 && argv[1].a_type == A_SYMBOL) + outlet_anything(e->e_outlet, argv[1].a_w.w_symbol, + argc-2, argv+2); + else outlet_list(e->e_outlet, 0, argc-1, argv+1); + return; + } + } + else /* symbol arguments */ + { + if (argc > 1) /* 2 or more args: treat as "list" */ + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if (e->e_w.w_symbol == &s_list) + { + if (argc > 0 && argv[0].a_type == A_SYMBOL) + outlet_anything(e->e_outlet, argv[0].a_w.w_symbol, + argc-1, argv+1); + else outlet_list(e->e_outlet, 0, argc, argv); + return; + } + } + } + else if (argc == 0) /* no args: treat as "bang" */ + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if (e->e_w.w_symbol == &s_bang) + { + outlet_bang(e->e_outlet); + return; + } + } + } + else if (argv[0].a_type == A_FLOAT) /* one float arg */ + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if (e->e_w.w_symbol == &s_float) + { + outlet_float(e->e_outlet, argv[0].a_w.w_float); + return; + } + } + } + else + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if (e->e_w.w_symbol == &s_symbol) + { + outlet_symbol(e->e_outlet, argv[0].a_w.w_symbol); + return; + } + } + } + } + outlet_list(x->x_rejectout, 0, argc, argv); +} + + +static void route_free(t_route *x) +{ + freebytes(x->x_vec, x->x_nelement * sizeof(*x->x_vec)); +} + +static void *route_new(t_symbol *s, int argc, t_atom *argv) +{ + int n; + t_routeelement *e; + t_route *x = (t_route *)pd_new(route_class); + t_atom a; + if (argc == 0) + { + argc = 1; + SETFLOAT(&a, 0); + argv = &a; + } + x->x_type = argv[0].a_type; + x->x_nelement = argc; + x->x_vec = (t_routeelement *)getbytes(argc * sizeof(*x->x_vec)); + for (n = 0, e = x->x_vec; n < argc; n++, e++) + { + e->e_outlet = outlet_new(&x->x_obj, &s_list); + if (x->x_type == A_FLOAT) + e->e_w.w_float = atom_getfloatarg(n, argc, argv); + else e->e_w.w_symbol = atom_getsymbolarg(n, argc, argv); + } + x->x_rejectout = outlet_new(&x->x_obj, &s_list); + return (x); +} + +void route_setup(void) +{ + route_class = class_new(gensym("route"), (t_newmethod)route_new, + (t_method)route_free, sizeof(t_route), 0, A_GIMME, 0); + class_addlist(route_class, route_list); + class_addanything(route_class, route_anything); +} + +/* -------------------------- pack ------------------------------ */ + +static t_class *pack_class; + +typedef struct _pack +{ + t_object x_obj; + t_int x_n; /* number of args */ + t_atom *x_vec; /* input values */ + t_int x_nptr; /* number of pointers */ + t_gpointer *x_gpointer; /* the pointers */ + t_atom *x_outvec; /* space for output values */ +} t_pack; + +static void *pack_new(t_symbol *s, int argc, t_atom *argv) +{ + t_pack *x = (t_pack *)pd_new(pack_class); + t_atom defarg[2], *ap, *vec, *vp; + t_gpointer *gp; + int nptr = 0; + int i; + if (!argc) + { + argv = defarg; + argc = 2; + SETFLOAT(&defarg[0], 0); + SETFLOAT(&defarg[1], 0); + } + + x->x_n = argc; + vec = x->x_vec = (t_atom *)getbytes(argc * sizeof(*x->x_vec)); + x->x_outvec = (t_atom *)getbytes(argc * sizeof(*x->x_outvec)); + + for (i = argc, ap = argv; i--; ap++) + if (ap->a_type == A_SYMBOL && *ap->a_w.w_symbol->s_name == 'p') + nptr++; + + gp = x->x_gpointer = (t_gpointer *)t_getbytes(nptr * sizeof (*gp)); + x->x_nptr = nptr; + + for (i = 0, vp = x->x_vec, ap = argv; i < argc; i++, ap++, vp++) + { + if (ap->a_type == A_FLOAT) + { + *vp = *ap; + if (i) floatinlet_new(&x->x_obj, &vp->a_w.w_float); + } + else if (ap->a_type == A_SYMBOL) + { + char c = *ap->a_w.w_symbol->s_name; + if (c == 's') + { + SETSYMBOL(vp, &s_symbol); + if (i) symbolinlet_new(&x->x_obj, &vp->a_w.w_symbol); + } + else if (c == 'p') + { + vp->a_type = A_POINTER; + vp->a_w.w_gpointer = gp; + gpointer_init(gp); + if (i) pointerinlet_new(&x->x_obj, gp); + gp++; + } + else + { + if (c != 'f') pd_error(x, "pack: %s: bad type", + ap->a_w.w_symbol->s_name); + SETFLOAT(vp, 0); + if (i) floatinlet_new(&x->x_obj, &vp->a_w.w_float); + } + } + } + outlet_new(&x->x_obj, &s_list); + return (x); +} + +static void pack_bang(t_pack *x) +{ + int i, reentered = 0, size = x->x_n * sizeof (t_atom); + t_gpointer *gp; + t_atom *outvec; + for (i = x->x_nptr, gp = x->x_gpointer; i--; gp++) + if (!gpointer_check(gp, 1)) + { + pd_error(x, "pack: stale pointer"); + return; + } + /* reentrancy protection. The first time through use the pre-allocated + x_outvec; if we're reentered we have to allocate new memory. */ + if (!x->x_outvec) + { + /* LATER figure out how to deal with reentrancy and pointers... */ + if (x->x_nptr) + post("pack_bang: warning: reentry with pointers unprotected"); + outvec = t_getbytes(size); + reentered = 1; + } + else + { + outvec = x->x_outvec; + x->x_outvec = 0; + } + memcpy(outvec, x->x_vec, size); + outlet_list(x->x_obj.ob_outlet, &s_list, x->x_n, outvec); + if (reentered) + t_freebytes(outvec, size); + else x->x_outvec = outvec; +} + +static void pack_pointer(t_pack *x, t_gpointer *gp) +{ + if (x->x_vec->a_type == A_POINTER) + { + gpointer_unset(x->x_gpointer); + *x->x_gpointer = *gp; + if (gp->gp_stub) gp->gp_stub->gs_refcount++; + pack_bang(x); + } + else pd_error(x, "pack_pointer: wrong type"); +} + +static void pack_float(t_pack *x, t_float f) +{ + if (x->x_vec->a_type == A_FLOAT) + { + x->x_vec->a_w.w_float = f; + pack_bang(x); + } + else pd_error(x, "pack_float: wrong type"); +} + +static void pack_symbol(t_pack *x, t_symbol *s) +{ + if (x->x_vec->a_type == A_SYMBOL) + { + x->x_vec->a_w.w_symbol = s; + pack_bang(x); + } + else pd_error(x, "pack_symbol: wrong type"); +} + +static void pack_list(t_pack *x, t_symbol *s, int ac, t_atom *av) +{ + obj_list(&x->x_obj, 0, ac, av); +} + +static void pack_anything(t_pack *x, t_symbol *s, int ac, t_atom *av) +{ + t_atom *av2 = (t_atom *)getbytes((ac + 1) * sizeof(t_atom)); + int i; + for (i = 0; i < ac; i++) + av2[i + 1] = av[i]; + SETSYMBOL(av2, s); + obj_list(&x->x_obj, 0, ac+1, av2); + freebytes(av2, (ac + 1) * sizeof(t_atom)); +} + +static void pack_free(t_pack *x) +{ + t_gpointer *gp; + int i; + for (gp = x->x_gpointer, i = x->x_nptr; i--; gp++) + gpointer_unset(gp); + freebytes(x->x_vec, x->x_n * sizeof(*x->x_vec)); + freebytes(x->x_outvec, x->x_n * sizeof(*x->x_outvec)); + freebytes(x->x_gpointer, x->x_nptr * sizeof(*x->x_gpointer)); +} + +static void pack_setup(void) +{ + pack_class = class_new(gensym("pack"), (t_newmethod)pack_new, + (t_method)pack_free, sizeof(t_pack), 0, A_GIMME, 0); + class_addbang(pack_class, pack_bang); + class_addpointer(pack_class, pack_pointer); + class_addfloat(pack_class, pack_float); + class_addsymbol(pack_class, pack_symbol); + class_addlist(pack_class, pack_list); + class_addanything(pack_class, pack_anything); +} + +/* -------------------------- unpack ------------------------------ */ + +static t_class *unpack_class; + +typedef struct unpackout +{ + t_atomtype u_type; + t_outlet *u_outlet; +} t_unpackout; + +typedef struct _unpack +{ + t_object x_obj; + t_int x_n; + t_unpackout *x_vec; +} t_unpack; + +static void *unpack_new(t_symbol *s, int argc, t_atom *argv) +{ + t_unpack *x = (t_unpack *)pd_new(unpack_class); + t_atom defarg[2], *ap; + t_unpackout *u; + int i; + if (!argc) + { + argv = defarg; + argc = 2; + SETFLOAT(&defarg[0], 0); + SETFLOAT(&defarg[1], 0); + } + x->x_n = argc; + x->x_vec = (t_unpackout *)getbytes(argc * sizeof(*x->x_vec)); + for (i = 0, ap = argv, u = x->x_vec; i < argc; u++, ap++, i++) + { + t_atomtype type = ap->a_type; + if (type == A_SYMBOL) + { + char c = *ap->a_w.w_symbol->s_name; + if (c == 's') + { + u->u_type = A_SYMBOL; + u->u_outlet = outlet_new(&x->x_obj, &s_symbol); + } + else if (c == 'p') + { + u->u_type = A_POINTER; + u->u_outlet = outlet_new(&x->x_obj, &s_pointer); + } + else + { + if (c != 'f') pd_error(x, "unpack: %s: bad type", + ap->a_w.w_symbol->s_name); + u->u_type = A_FLOAT; + u->u_outlet = outlet_new(&x->x_obj, &s_float); + } + } + else + { + u->u_type = A_FLOAT; + u->u_outlet = outlet_new(&x->x_obj, &s_float); + } + } + return (x); +} + +static void unpack_list(t_unpack *x, t_symbol *s, int argc, t_atom *argv) +{ + t_atom *ap; + t_unpackout *u; + int i; + if (argc > x->x_n) argc = x->x_n; + for (i = argc, u = x->x_vec + i, ap = argv + i; u--, ap--, i--;) + { + t_atomtype type = u->u_type; + if (type != ap->a_type) + pd_error(x, "unpack: type mismatch"); + else if (type == A_FLOAT) + outlet_float(u->u_outlet, ap->a_w.w_float); + else if (type == A_SYMBOL) + outlet_symbol(u->u_outlet, ap->a_w.w_symbol); + else outlet_pointer(u->u_outlet, ap->a_w.w_gpointer); + } +} + +static void unpack_anything(t_unpack *x, t_symbol *s, int ac, t_atom *av) +{ + t_atom *av2 = (t_atom *)getbytes((ac + 1) * sizeof(t_atom)); + int i; + for (i = 0; i < ac; i++) + av2[i + 1] = av[i]; + SETSYMBOL(av2, s); + unpack_list(x, 0, ac+1, av2); + freebytes(av2, (ac + 1) * sizeof(t_atom)); +} + +static void unpack_free(t_unpack *x) +{ + freebytes(x->x_vec, x->x_n * sizeof(*x->x_vec)); +} + +static void unpack_setup(void) +{ + unpack_class = class_new(gensym("unpack"), (t_newmethod)unpack_new, + (t_method)unpack_free, sizeof(t_unpack), 0, A_GIMME, 0); + class_addlist(unpack_class, unpack_list); + class_addanything(unpack_class, unpack_anything); +} + +/* -------------------------- trigger ------------------------------ */ + +static t_class *trigger_class; +#define TR_BANG 0 +#define TR_FLOAT 1 +#define TR_SYMBOL 2 +#define TR_POINTER 3 +#define TR_LIST 4 +#define TR_ANYTHING 5 + +typedef struct triggerout +{ + int u_type; /* outlet type from above */ + t_outlet *u_outlet; +} t_triggerout; + +typedef struct _trigger +{ + t_object x_obj; + t_int x_n; + t_triggerout *x_vec; +} t_trigger; + +static void *trigger_new(t_symbol *s, int argc, t_atom *argv) +{ + t_trigger *x = (t_trigger *)pd_new(trigger_class); + t_atom defarg[2], *ap; + t_triggerout *u; + int i; + if (!argc) + { + argv = defarg; + argc = 2; + SETSYMBOL(&defarg[0], &s_bang); + SETSYMBOL(&defarg[1], &s_bang); + } + x->x_n = argc; + x->x_vec = (t_triggerout *)getbytes(argc * sizeof(*x->x_vec)); + for (i = 0, ap = argv, u = x->x_vec; i < argc; u++, ap++, i++) + { + t_atomtype thistype = ap->a_type; + char c; + if (thistype == TR_SYMBOL) c = ap->a_w.w_symbol->s_name[0]; + else if (thistype == TR_FLOAT) c = 'f'; + else c = 0; + if (c == 'p') + u->u_type = TR_POINTER, + u->u_outlet = outlet_new(&x->x_obj, &s_pointer); + else if (c == 'f') + u->u_type = TR_FLOAT, u->u_outlet = outlet_new(&x->x_obj, &s_float); + else if (c == 'b') + u->u_type = TR_BANG, u->u_outlet = outlet_new(&x->x_obj, &s_bang); + else if (c == 'l') + u->u_type = TR_LIST, u->u_outlet = outlet_new(&x->x_obj, &s_list); + else if (c == 's') + u->u_type = TR_SYMBOL, + u->u_outlet = outlet_new(&x->x_obj, &s_symbol); + else if (c == 'a') + u->u_type = TR_ANYTHING, + u->u_outlet = outlet_new(&x->x_obj, &s_symbol); + else + { + pd_error(x, "trigger: %s: bad type", ap->a_w.w_symbol->s_name); + u->u_type = TR_FLOAT, u->u_outlet = outlet_new(&x->x_obj, &s_float); + } + } + return (x); +} + +static void trigger_list(t_trigger *x, t_symbol *s, int argc, t_atom *argv) +{ + t_triggerout *u; + int i; + t_atom at; + if (!argc) + { + argc = 1; + SETFLOAT(&at, 0); + argv = &at; + } + for (i = x->x_n, u = x->x_vec + i; u--, i--;) + { + if (u->u_type == TR_FLOAT) + outlet_float(u->u_outlet, atom_getfloat(argv)); + else if (u->u_type == TR_BANG) + outlet_bang(u->u_outlet); + else if (u->u_type == TR_SYMBOL) + outlet_symbol(u->u_outlet, atom_getsymbol(argv)); + else if (u->u_type == TR_POINTER) + { + if (argv->a_type != TR_POINTER) + pd_error(x, "unpack: bad pointer"); + else outlet_pointer(u->u_outlet, argv->a_w.w_gpointer); + } + else outlet_list(u->u_outlet, &s_list, argc, argv); + } +} + +static void trigger_anything(t_trigger *x, t_symbol *s, int argc, t_atom *argv) +{ + t_triggerout *u; + int i; + for (i = x->x_n, u = x->x_vec + i; u--, i--;) + { + if (u->u_type == TR_BANG) + outlet_bang(u->u_outlet); + else if (u->u_type == TR_ANYTHING) + outlet_anything(u->u_outlet, s, argc, argv); + else pd_error(x, "trigger: can only convert 's' to 'b' or 'a'", + s->s_name); + } +} + +static void trigger_bang(t_trigger *x) +{ + trigger_list(x, 0, 0, 0); +} + +static void trigger_pointer(t_trigger *x, t_gpointer *gp) +{ + t_atom at; + SETPOINTER(&at, gp); + trigger_list(x, 0, 1, &at); +} + +static void trigger_float(t_trigger *x, t_float f) +{ + t_atom at; + SETFLOAT(&at, f); + trigger_list(x, 0, 1, &at); +} + +static void trigger_symbol(t_trigger *x, t_symbol *s) +{ + t_atom at; + SETSYMBOL(&at, s); + trigger_list(x, 0, 1, &at); +} + +static void trigger_free(t_trigger *x) +{ + freebytes(x->x_vec, x->x_n * sizeof(*x->x_vec)); +} + +static void trigger_setup(void) +{ + trigger_class = class_new(gensym("trigger"), (t_newmethod)trigger_new, + (t_method)trigger_free, sizeof(t_trigger), 0, A_GIMME, 0); + class_addcreator((t_newmethod)trigger_new, gensym("t"), A_GIMME, 0); + class_addlist(trigger_class, trigger_list); + class_addbang(trigger_class, trigger_bang); + class_addpointer(trigger_class, trigger_pointer); + class_addfloat(trigger_class, (t_method)trigger_float); + class_addsymbol(trigger_class, trigger_symbol); + class_addanything(trigger_class, trigger_anything); +} + +/* -------------------------- spigot ------------------------------ */ +static t_class *spigot_class; + +typedef struct _spigot +{ + t_object x_obj; + float x_state; +} t_spigot; + +static void *spigot_new(void) +{ + t_spigot *x = (t_spigot *)pd_new(spigot_class); + floatinlet_new(&x->x_obj, &x->x_state); + outlet_new(&x->x_obj, 0); + x->x_state = 0; + return (x); +} + +static void spigot_bang(t_spigot *x) +{ + if (x->x_state != 0) outlet_bang(x->x_obj.ob_outlet); +} + +static void spigot_pointer(t_spigot *x, t_gpointer *gp) +{ + if (x->x_state != 0) outlet_pointer(x->x_obj.ob_outlet, gp); +} + +static void spigot_float(t_spigot *x, t_float f) +{ + if (x->x_state != 0) outlet_float(x->x_obj.ob_outlet, f); +} + +static void spigot_symbol(t_spigot *x, t_symbol *s) +{ + if (x->x_state != 0) outlet_symbol(x->x_obj.ob_outlet, s); +} + +static void spigot_list(t_spigot *x, t_symbol *s, int argc, t_atom *argv) +{ + if (x->x_state != 0) outlet_list(x->x_obj.ob_outlet, s, argc, argv); +} + +static void spigot_anything(t_spigot *x, t_symbol *s, int argc, t_atom *argv) +{ + if (x->x_state != 0) outlet_anything(x->x_obj.ob_outlet, s, argc, argv); +} + +static void spigot_setup(void) +{ + spigot_class = class_new(gensym("spigot"), (t_newmethod)spigot_new, 0, + sizeof(t_spigot), 0, A_DEFSYM, 0); + class_addbang(spigot_class, spigot_bang); + class_addpointer(spigot_class, spigot_pointer); + class_addfloat(spigot_class, spigot_float); + class_addsymbol(spigot_class, spigot_symbol); + class_addlist(spigot_class, spigot_list); + class_addanything(spigot_class, spigot_anything); +} + +/* --------------------------- moses ----------------------------- */ +static t_class *moses_class; + +typedef struct _moses +{ + t_object x_ob; + t_outlet *x_out2; + float x_y; +} t_moses; + +static void *moses_new(t_floatarg f) +{ + t_moses *x = (t_moses *)pd_new(moses_class); + floatinlet_new(&x->x_ob, &x->x_y); + outlet_new(&x->x_ob, &s_float); + x->x_out2 = outlet_new(&x->x_ob, &s_float); + x->x_y = f; + return (x); +} + +static void moses_float(t_moses *x, t_float f) +{ + if (f < x->x_y) outlet_float(x->x_ob.ob_outlet, f); + else outlet_float(x->x_out2, f); +} + +static void moses_setup(void) +{ + moses_class = class_new(gensym("moses"), (t_newmethod)moses_new, 0, + sizeof(t_moses), 0, A_DEFFLOAT, 0); + class_addfloat(moses_class, moses_float); +} + +/* ----------------------- until --------------------- */ + +static t_class *until_class; + +typedef struct _until +{ + t_object x_obj; + int x_run; + int x_count; +} t_until; + +static void *until_new(void) +{ + t_until *x = (t_until *)pd_new(until_class); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("bang"), gensym("bang2")); + outlet_new(&x->x_obj, &s_bang); + x->x_run = 0; + return (x); +} + +static void until_bang(t_until *x) +{ + x->x_run = 1; + x->x_count = -1; + while (x->x_run && x->x_count) + x->x_count--, outlet_bang(x->x_obj.ob_outlet); +} + +static void until_float(t_until *x, t_float f) +{ + x->x_run = 1; + x->x_count = f; + while (x->x_run && x->x_count) + x->x_count--, outlet_bang(x->x_obj.ob_outlet); +} + +static void until_bang2(t_until *x) +{ + x->x_run = 0; +} + +static void until_setup(void) +{ + until_class = class_new(gensym("until"), (t_newmethod)until_new, 0, + sizeof(t_until), 0, 0); + class_addbang(until_class, until_bang); + class_addfloat(until_class, until_float); + class_addmethod(until_class, (t_method)until_bang2, gensym("bang2"), 0); +} + +/* ----------------------- makefilename --------------------- */ + +static t_class *makefilename_class; + +typedef struct _makefilename +{ + t_object x_obj; + t_symbol *x_format; +} t_makefilename; + +static void *makefilename_new(t_symbol *s) +{ + t_makefilename *x = (t_makefilename *)pd_new(makefilename_class); + if (!s->s_name) s = gensym("file.%d"); + outlet_new(&x->x_obj, &s_symbol); + x->x_format = s; + return (x); +} + +static void makefilename_float(t_makefilename *x, t_floatarg f) +{ + char buf[MAXPDSTRING]; + sprintf(buf, x->x_format->s_name, (int)f); + outlet_symbol(x->x_obj.ob_outlet, gensym(buf)); +} + +static void makefilename_symbol(t_makefilename *x, t_symbol *s) +{ + char buf[MAXPDSTRING]; + sprintf(buf, x->x_format->s_name, s->s_name); + outlet_symbol(x->x_obj.ob_outlet, gensym(buf)); +} + +static void makefilename_setup(void) +{ + makefilename_class = class_new(gensym("makefilename"), + (t_newmethod)makefilename_new, 0, + sizeof(t_makefilename), 0, A_DEFSYM, 0); + class_addfloat(makefilename_class, makefilename_float); + class_addsymbol(makefilename_class, makefilename_symbol); +} + +/* -------------------------- swap ------------------------------ */ +static t_class *swap_class; + +typedef struct _swap +{ + t_object x_obj; + t_outlet *x_out2; + t_float x_f1; + t_float x_f2; +} t_swap; + +static void *swap_new(t_floatarg f) +{ + t_swap *x = (t_swap *)pd_new(swap_class); + x->x_f2 = f; + x->x_f1 = 0; + outlet_new(&x->x_obj, &s_float); + x->x_out2 = outlet_new(&x->x_obj, &s_float); + floatinlet_new(&x->x_obj, &x->x_f2); + return (x); +} + +static void swap_bang(t_swap *x) +{ + outlet_float(x->x_out2, x->x_f1); + outlet_float(x->x_obj.ob_outlet, x->x_f2); +} + +static void swap_float(t_swap *x, t_float f) +{ + x->x_f1 = f; + swap_bang(x); +} + +void swap_setup(void) +{ + swap_class = class_new(gensym("swap"), (t_newmethod)swap_new, 0, + sizeof(t_swap), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)swap_new, gensym("fswap"), A_DEFFLOAT, 0); + class_addbang(swap_class, swap_bang); + class_addfloat(swap_class, swap_float); +} + +/* -------------------------- change ------------------------------ */ +static t_class *change_class; + +typedef struct _change +{ + t_object x_obj; + t_float x_f; +} t_change; + +static void *change_new(t_floatarg f) +{ + t_change *x = (t_change *)pd_new(change_class); + x->x_f = f; + outlet_new(&x->x_obj, &s_float); + return (x); +} + +static void change_bang(t_change *x) +{ + outlet_float(x->x_obj.ob_outlet, x->x_f); +} + +static void change_float(t_change *x, t_float f) +{ + if (f != x->x_f) + { + x->x_f = f; + outlet_float(x->x_obj.ob_outlet, x->x_f); + } +} + +static void change_set(t_change *x, t_float f) +{ + x->x_f = f; +} + +void change_setup(void) +{ + change_class = class_new(gensym("change"), (t_newmethod)change_new, 0, + sizeof(t_change), 0, A_DEFFLOAT, 0); + class_addbang(change_class, change_bang); + class_addfloat(change_class, change_float); + class_addmethod(change_class, (t_method)change_set, gensym("set"), + A_DEFFLOAT, 0); +} + +/* -------------------- value ------------------------------ */ + +static t_class *value_class, *vcommon_class; + +typedef struct vcommon +{ + t_pd c_pd; + int c_refcount; + t_float c_f; +} t_vcommon; + +typedef struct _value +{ + t_object x_obj; + t_symbol *x_sym; + t_float *x_floatstar; +} t_value; + + /* get a pointer to a named floating-point variable. The variable + belongs to a "vcommon" object, which is created if necessary. */ +t_float *value_get(t_symbol *s) +{ + t_vcommon *c = (t_vcommon *)pd_findbyclass(s, vcommon_class); + if (!c) + { + c = (t_vcommon *)pd_new(vcommon_class); + c->c_f = 0; + c->c_refcount = 0; + pd_bind(&c->c_pd, s); + } + c->c_refcount++; + return (&c->c_f); +} + + /* release a variable. This only frees the "vcommon" resource when the + last interested party releases it. */ +void value_release(t_symbol *s) +{ + t_vcommon *c = (t_vcommon *)pd_findbyclass(s, vcommon_class); + if (c) + { + if (!--c->c_refcount) + { + pd_unbind(&c->c_pd, s); + pd_free(&c->c_pd); + } + } + else bug("value_release"); +} + +/* + * value_getfloat -- obtain the float value of a "value" object + * return 0 on success, 1 otherwise + */ +int +value_getfloat(t_symbol *s, t_float *f) +{ + t_vcommon *c = (t_vcommon *)pd_findbyclass(s, vcommon_class); + if (!c) + return (1); + *f = c->c_f; + return (0); +} + +/* + * value_setfloat -- set the float value of a "value" object + * return 0 on success, 1 otherwise + */ +int +value_setfloat(t_symbol *s, t_float f) +{ + t_vcommon *c = (t_vcommon *)pd_findbyclass(s, vcommon_class); + if (!c) + return (1); + c->c_f = f; + return (0); +} + +static void *value_new(t_symbol *s) +{ + t_value *x = (t_value *)pd_new(value_class); + x->x_sym = s; + x->x_floatstar = value_get(s); + outlet_new(&x->x_obj, &s_float); + return (x); +} + +static void value_bang(t_value *x) +{ + outlet_float(x->x_obj.ob_outlet, *x->x_floatstar); +} + +static void value_float(t_value *x, t_float f) +{ + *x->x_floatstar = f; +} + +static void value_ff(t_value *x) +{ + value_release(x->x_sym); +} + +static void value_setup(void) +{ + value_class = class_new(gensym("value"), (t_newmethod)value_new, + (t_method)value_ff, + sizeof(t_value), 0, A_DEFSYM, 0); + class_addcreator((t_newmethod)value_new, gensym("v"), A_DEFSYM, 0); + class_addbang(value_class, value_bang); + class_addfloat(value_class, value_float); + vcommon_class = class_new(gensym("value"), 0, 0, + sizeof(t_vcommon), CLASS_PD, 0); +} + +/* -------------- overall setup routine for this file ----------------- */ + +void x_connective_setup(void) +{ + pdint_setup(); + pdfloat_setup(); + pdsymbol_setup(); + bang_setup(); + send_setup(); + receive_setup(); + select_setup(); + route_setup(); + pack_setup(); + unpack_setup(); + trigger_setup(); + spigot_setup(); + moses_setup(); + until_setup(); + makefilename_setup(); + swap_setup(); + change_setup(); + value_setup(); +} |