static void *send_new(t_symbol *s)
{
t_send *x = (t_send *)pd_new(send_class);
if (!*s->s_name)
symbolinlet_new(&x->x_obj, &x->x_sym);
x->x_sym = s;
return (x);
}
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 *strippath_new(t_symbol *s)
{
t_strippath *x = (t_strippath *)pd_new(strippath_class);
x->x_s = s;
x->x_path=gensym("./");
symbolinlet_new(&x->x_obj, &x->x_path);
outlet_new(&x->x_obj, &s_symbol);
return (x);
}
void *arraysize_new(t_symbol *s)
{
t_arraysize *x = (t_arraysize *)pd_new(arraysize_class);
symbolinlet_new(&x->x_obj, &x->array_name);
outlet_new(&x->x_obj, gensym("float"));
x->array_name = s;
return (void *)x;
}
void * str_compare_new(t_symbol *s, int argc, t_atom * argv)
{
t_str_compare * res = (t_str_compare*) pd_new(str_compare_class);
res->s2 = NULL;
if(argc > 0)
res->s2 = atom_getsymbol(argv);
res->outlet = outlet_new(&res->xobj, &s_symbol);
res->compare_inlet = symbolinlet_new(&res->xobj, &res->s2);
return (void*) res;
}
static void *select_new(t_symbol *s, int argc, t_atom *argv)
{
#ifdef ROCKBOX
(void) s;
#endif
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);
}
}
static void *pack_new(t_symbol *s, int argc, t_atom *argv)
{
#ifdef ROCKBOX
(void) s;
#endif
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 *pipe_new(t_symbol *s, int argc, t_atom *argv)
{
t_pipe *x = (t_pipe *)pd_new(pipe_class);
t_atom defarg, *ap;
t_pipeout *vec, *vp;
t_gpointer *gp;
int nptr = 0;
int i;
t_float deltime;
if (argc)
{
if (argv[argc-1].a_type != A_FLOAT)
{
char stupid[80];
atom_string(&argv[argc-1], stupid, 79);
pd_error(x, "pipe: %s: bad time delay value", stupid);
deltime = 0;
}
else deltime = argv[argc-1].a_w.w_float;
argc--;
}
else deltime = 0;
if (!argc)
{
argv = &defarg;
argc = 1;
SETFLOAT(&defarg, 0);
}
x->x_n = argc;
vec = x->x_vec = (t_pipeout *)getbytes(argc * sizeof(*x->x_vec));
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_gp = (t_gpointer *)t_getbytes(nptr * sizeof (*gp));
x->x_nptr = nptr;
for (i = 0, vp = vec, ap = argv; i < argc; i++, ap++, vp++)
{
if (ap->a_type == A_FLOAT)
{
vp->p_atom = *ap;
vp->p_outlet = outlet_new(&x->x_obj, &s_float);
if (i) floatinlet_new(&x->x_obj, &vp->p_atom.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->p_atom, &s_symbol);
vp->p_outlet = outlet_new(&x->x_obj, &s_symbol);
if (i) symbolinlet_new(&x->x_obj, &vp->p_atom.a_w.w_symbol);
}
else if (c == 'p')
{
vp->p_atom.a_type = A_POINTER;
vp->p_atom.a_w.w_gpointer = gp;
gpointer_init(gp);
vp->p_outlet = outlet_new(&x->x_obj, &s_pointer);
if (i) pointerinlet_new(&x->x_obj, gp);
gp++;
}
else
{
if (c != 'f') pd_error(x, "pipe: %s: bad type",
ap->a_w.w_symbol->s_name);
SETFLOAT(&vp->p_atom, 0);
vp->p_outlet = outlet_new(&x->x_obj, &s_float);
if (i) floatinlet_new(&x->x_obj, &vp->p_atom.a_w.w_float);
}
}
}
floatinlet_new(&x->x_obj, &x->x_deltime);
x->x_hang = 0;
x->x_deltime = deltime;
return (x);
}
/* CHANGE this will have to be taken care of */
default:
post("expr: bang: unrecognized result %ld\n", x->exp_res[i].ex_type);
}
}
}
static t_expr *
#ifdef PD
expr_new(t_symbol *s, int ac, t_atom *av)
#else /* MSP */
Nexpr_new(t_symbol *s, int ac, t_atom *av)
#endif
{
struct expr *x;
int i, ninlet;
struct ex_ex *eptr;
t_atom fakearg;
int dsp_index; /* keeping track of the dsp inlets */
/*
* SDY - we may need to call dsp_setup() in this function
*/
if (!ac)
{
ac = 1;
av = &fakearg;
SETFLOAT(&fakearg, 0);
}
#ifdef PD
/*
* figure out if we are expr, expr~, or fexpr~
*/
if (!strcmp("expr", s->s_name)) {
x = (t_expr *)pd_new(expr_class);
SET_EXPR(x);
} else if (!strcmp("expr~", s->s_name)) {
x = (t_expr *)pd_new(expr_tilde_class);
SET_EXPR_TILDE(x);
} else if (!strcmp("fexpr~", s->s_name)) {
x = (t_expr *)pd_new(fexpr_tilde_class);
SET_FEXPR_TILDE(x);
} else {
post("expr_new: bad object name '%s'", s->s_name);
/* assume expr */
x = (t_expr *)pd_new(expr_class);
SET_EXPR(x);
}
#else /* MSP */
/* for now assume an expr~ */
x = (t_expr *)pd_new(expr_tilde_class);
SET_EXPR_TILDE(x);
#endif
/*
* initialize the newly allocated object
*/
x->exp_proxy = 0;
x->exp_nivec = 0;
x->exp_nexpr = 0;
x->exp_error = 0;
for (i = 0; i < MAX_VARS; i++) {
x->exp_stack[i] = (struct ex_ex *)0;
x->exp_outlet[i] = (t_outlet *)0;
x->exp_res[i].ex_type = 0;
x->exp_res[i].ex_int = 0;
x->exp_p_res[i] = (t_float *)0;
x->exp_var[i].ex_type = 0;
x->exp_var[i].ex_int = 0;
x->exp_p_var[i] = (t_float *)0;
x->exp_tmpres[i] = (t_float *)0;
x->exp_vsize = 0;
}
x->exp_f = 0; /* save the control value to be transformed to signal */
if (expr_donew(x, ac, av))
{
pd_error(x, "expr: syntax error");
/*
SDY the following coredumps why?
pd_free(&x->exp_ob.ob_pd);
*/
return (0);
}
ninlet = 1;
for (i = 0, eptr = x->exp_var; i < MAX_VARS ; i++, eptr++)
if (eptr->ex_type) {
ninlet = i + 1;
}
/*
* create the new inlets
*/
for (i = 1, eptr = x->exp_var + 1, dsp_index=1; i<ninlet ; i++, eptr++)
{
t_exprproxy *p;
switch (eptr->ex_type)
{
case 0:
/* nothing is using this inlet */
if (i < ninlet)
#ifdef PD
floatinlet_new(&x->exp_ob, &eptr->ex_flt);
#else /* MSP */
inlet_new(&x->exp_ob, "float");
#endif
break;
case ET_II:
case ET_FI:
p = exprproxy_new(x, i);
#ifdef PD
inlet_new(&x->exp_ob, &p->p_pd, &s_float, &s_float);
#else /* MSP */
inlet_new(&x->exp_ob, "float");
#endif
break;
case ET_SI:
#ifdef PD
symbolinlet_new(&x->exp_ob, (t_symbol **)&eptr->ex_ptr);
#else /* MSP */
inlet_new(&x->exp_ob, "symbol");
#endif
break;
case ET_XI:
case ET_VI:
if (!IS_EXPR(x)) {
dsp_index++;
#ifdef PD
inlet_new(&x->exp_ob, &x->exp_ob.ob_pd,
&s_signal, &s_signal);
#else /* MSP */
inlet_new(&x->exp_ob, "signal");
#endif
break;
} else
post("expr: internal error expr_new");
default:
pd_error(x, "expr: bad type (%lx) inlet = %d\n",
eptr->ex_type, i + 1);
break;
}
}
if (IS_EXPR(x)) {
for (i = 0; i < x->exp_nexpr; i++)
x->exp_outlet[i] = outlet_new(&x->exp_ob, 0);
} else {
for (i = 0; i < x->exp_nexpr; i++)
x->exp_outlet[i] = outlet_new(&x->exp_ob,
gensym("signal"));
x->exp_nivec = dsp_index;
}
/*
* for now assume a 64 sample size block but this may change once
* expr_dsp is called
*/
x->exp_vsize = 64;
for (i = 0; i < x->exp_nexpr; i++) {
x->exp_p_res[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
x->exp_tmpres[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
}
for (i = 0; i < MAX_VARS; i++)
x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
return (x);
}
