static void pd_defaultpointer(t_pd *x, t_gpointer *gp)
{
if (*(*x)->c_listmethod != pd_defaultlist)
{
t_atom at;
SETPOINTER(&at, gp);
(*(*x)->c_listmethod)(x, 0, 1, &at);
}
else
{
t_atom at;
SETPOINTER(&at, gp);
(*(*x)->c_anymethod)(x, &s_pointer, 1, &at);
}
}
static void repack_pointer(t_repack *x, t_gpointer *p)
{
/* add a pointer-atom to the list */
SETPOINTER(&x->buffer[x->current], p);
x->current++;
if (x->current >= x->outputsize) repack_bang(x);
}
static void iem_append_kernel_pointer(t_iem_append_kernel *x, t_gpointer *gp)
{
if(x->x_inlet_select) /* if 2nd inlet */
{
x->x_ac2 = 1;
x->x_type2 = A_POINTER;
SETPOINTER(x->x_at2, gp);
x->x_sym2 = &s_list;
}
else /* if 1st inlet */
{
x->x_ac1 = 1;
x->x_type1 = A_POINTER;
SETPOINTER(x->x_at12, gp);
iem_append_kernel_out(x);
}
}
static void inlet_pointer(t_inlet *x, t_gpointer *gp)
{
if (x->i_symfrom == &s_pointer)
pd_vmess(x->i_dest, x->i_symto, "p", gp);
else if (!x->i_symfrom) pd_pointer(x->i_dest, gp);
else if (x->i_symfrom == &s_list)
{
t_atom a;
SETPOINTER(&a, gp);
inlet_list(x, &s_pointer, 1, &a);
}
else inlet_wrong(x, &s_pointer);
}
static void h_multimap_value(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
{
t_h_multimap *x = (t_h_multimap *)(p->x);
// symbol without selector "symbol":
if(argc == 0)
{
t_atom tmp;
SETSYMBOL(&tmp, s);
x->value.setAtoms(1, &tmp);
x->event_set = true;
return;
}
// input is a list without selector "list":
// input is a list without selector "list":
if ( argc && (strcmp(s->s_name,"list")!=0)
&& (strcmp(s->s_name,"float")!=0)
&& (strcmp(s->s_name,"symbol")!=0)
&& (strcmp(s->s_name,"pointer")!=0) )
{
t_atom *atoms = (t_atom*)getbytes( (argc+1)*sizeof(t_atom) );
// add the selector symbol to the list:
SETSYMBOL(atoms, s);
for(int i=0; i<argc; i++)
{
if(argv[i].a_type == A_FLOAT)
SETFLOAT(&atoms[i+1],argv[i].a_w.w_float);
if(argv[i].a_type == A_SYMBOL)
SETSYMBOL(&atoms[i+1],argv[i].a_w.w_symbol);
if(argv[i].a_type == A_POINTER)
SETPOINTER(&atoms[i+1],argv[i].a_w.w_gpointer);
}
x->value.setAtoms(argc+1, atoms);
x->event_set = true;
freebytes(atoms, (argc+1)*sizeof(t_atom));
return;
}
// "normal" input (list, float, symbol or pointer):
if (argc)
{
x->value.setAtoms(argc, argv);
x->event_set = true;
return;
}
}
static void new_inlet_pointer(t_inlet *x, t_gpointer *gp)
{
if (x->i_symfrom == &s_pointer)
pd_vmess(x->i_dest, x->i_un.iu_symto, "p", gp);
else if (!x->i_symfrom)
pd_pointer(x->i_dest, gp);
else if (x->i_symfrom == &s_list)
{
t_atom a;
SETPOINTER(&a, gp);
new_inlet_list(x, &s_pointer, 1, &a);
}
else if (*x->i_dest == eproxy_class)
{
t_atom a;
t_eproxy* proxy = (t_eproxy *)x->i_dest;
t_eobj *z = (t_eobj *)proxy->p_owner;
z->o_current_proxy = proxy->p_index;
SETPOINTER(&a, gp);
pd_typedmess((t_pd *)x->i_dest, &s_pointer, 1, &a);
z->o_current_proxy = 0;
}
else inlet_wrong(x, &s_pointer);
}
/////////////////////////////////////////////////////////
// trigger
//
/////////////////////////////////////////////////////////
void pix_info :: render(GemState *state)
{
// 0 0 0 6408 5121 1 1 0 0 9.59521e+08
t_atom abuf[3];
pixBlock*img=NULL;
if(state)state->get(GemState::_PIX, img);
if (!state || !img){ //no pixblock (or even no image!)!
outlet_float(m_pixblock, (t_float)-1);
outlet_float(m_misc, (t_float)-1);
outlet_float(m_format, (t_float)-1);
outlet_float(m_c, (t_float)-1);
outlet_float(m_y, (t_float)-1);
outlet_float(m_x, (t_float)-1);
return;
}
SETFLOAT( &abuf[0], (t_float)img->newimage);
SETFLOAT( &abuf[1], (t_float)img->newfilm);
if (!&img->image){ // we have a pixblock, but no image!
outlet_list(m_pixblock, gensym("list"), 2, abuf);
outlet_float(m_misc, (t_float)-1);
outlet_float(m_format, (t_float)-1);
outlet_float(m_c, (t_float)-1);
outlet_float(m_y, (t_float)-1);
outlet_float(m_x, (t_float)-1);
return;
}
if(img->image.data){
t_gpointer*gp=(t_gpointer*)img->image.data;
SETPOINTER(&abuf[2], gp);
outlet_anything(m_data, gensym("data"), 1, abuf+2);
}
outlet_list(m_pixblock, gensym("list"), 2, abuf);
SETFLOAT (&abuf[0], (t_float)img->image.type);
SETFLOAT (&abuf[1], (t_float)img->image.upsidedown);
SETFLOAT (&abuf[2], (t_float)img->image.notowned);
outlet_list(m_misc, gensym("list"), 3, abuf);
// send out the colorspace (as integer!)
outlet_float(m_format, (t_float)img->image.format);
// send out the width/height/csize information
outlet_float(m_c, (t_float)img->image.csize);
outlet_float(m_y, (t_float)img->image.ysize);
outlet_float(m_x, (t_float)img->image.xsize);
}
static void trigger_pointer(t_trigger *x, t_gpointer *gp)
{
t_atom at;
SETPOINTER(&at, gp);
trigger_list(x, 0, 1, &at);
}
int Visit (register Object *p) {
register Object *tag;
register int t, size, reloc = 0;
again:
t = TYPE(*p);
if (!Types[t].haspointer)
return 0;
tag = (Object *)POINTER(*p);
if ((char *)tag >= Free_Start && (char *)tag < Free_End)
return 0;
if (TYPE(*tag) == T_Broken_Heart) {
SETPOINTER(*p, POINTER(*tag));
return 0;
}
ELK_ALIGN(To);
switch (t) {
case T_Bignum:
size = sizeof (struct S_Bignum) - sizeof (gran_t)
+ BIGNUM(*p)->size * sizeof (gran_t);
memcpy (To, tag, size);
break;
case T_Flonum:
size = sizeof (struct S_Flonum);
*(struct S_Flonum *)To = *(struct S_Flonum *)tag;
break;
case T_Symbol:
size = sizeof (struct S_Symbol);
*(struct S_Symbol *)To = *(struct S_Symbol *)tag;
break;
case T_Pair:
case T_Environment:
size = sizeof (struct S_Pair);
*(struct S_Pair *)To = *(struct S_Pair *)tag;
break;
case T_String:
size = sizeof (struct S_String) + STRING(*p)->size - 1;
memcpy (To, tag, size);
break;
case T_Vector:
size = sizeof (struct S_Vector) + (VECTOR(*p)->size - 1) *
sizeof (Object);
memcpy (To, tag, size);
break;
case T_Primitive:
size = sizeof (struct S_Primitive);
*(struct S_Primitive *)To = *(struct S_Primitive *)tag;
break;
case T_Compound:
size = sizeof (struct S_Compound);
*(struct S_Compound *)To = *(struct S_Compound *)tag;
break;
case T_Control_Point:
size = sizeof (struct S_Control) + CONTROL(*p)->size - 1;
reloc = To - (char *)tag;
memcpy (To, tag, size);
break;
case T_Promise:
size = sizeof (struct S_Promise);
*(struct S_Promise *)To = *(struct S_Promise *)tag;
break;
case T_Port:
size = sizeof (struct S_Port);
*(struct S_Port *)To = *(struct S_Port *)tag;
break;
case T_Autoload:
size = sizeof (struct S_Autoload);
*(struct S_Autoload *)To = *(struct S_Autoload *)tag;
break;
case T_Macro:
size = sizeof (struct S_Macro);
*(struct S_Macro *)To = *(struct S_Macro *)tag;
break;
case T_Broken_Heart:
Panic ("broken heart in GC");
default:
if (t < 0 || t >= Num_Types)
Panic ("bad type in GC");
if (Types[t].size == NOFUNC)
size = Types[t].const_size;
else
size = (Types[t].size)(*p);
memcpy (To, tag, size);
}
SETPOINTER(*p, To);
SET(*tag, T_Broken_Heart, To);
To += size;
if (To > Free_End)
Panic ("free exhausted in GC");
switch (t) {
case T_Symbol:
Recursive_Visit (&SYMBOL(*p)->next);
Recursive_Visit (&SYMBOL(*p)->name);
Recursive_Visit (&SYMBOL(*p)->value);
p = &SYMBOL(*p)->plist;
goto again;
case T_Pair:
case T_Environment:
Recursive_Visit (&PAIR(*p)->car);
p = &PAIR(*p)->cdr;
goto again;
case T_Vector: {
register int i, n;
for (i = 0, n = VECTOR(*p)->size; i < n; i++)
Recursive_Visit (&VECTOR(*p)->data[i]);
break;
}
case T_Compound:
Recursive_Visit (&COMPOUND(*p)->closure);
Recursive_Visit (&COMPOUND(*p)->env);
p = &COMPOUND(*p)->name;
goto again;
case T_Control_Point:
Recursive_Visit (&CONTROL(*p)->memsave);
CONTROL(*p)->delta += reloc;
#ifdef HAVE_ALLOCA
Visit_GC_List (CONTROL(*p)->gclist, CONTROL(*p)->delta);
#else
Recursive_Visit (&CONTROL(*p)->gcsave);
#endif
Visit_Wind (CONTROL(*p)->firstwind, CONTROL(*p)->delta);
p = &CONTROL(*p)->env;
goto again;
case T_Promise:
Recursive_Visit (&PROMISE(*p)->env);
p = &PROMISE(*p)->thunk;
goto again;
case T_Port:
p = &PORT(*p)->name;
goto again;
case T_Autoload:
Recursive_Visit (&AUTOLOAD(*p)->files);
p = &AUTOLOAD(*p)->env;
goto again;
case T_Macro:
Recursive_Visit (&MACRO(*p)->body);
p = &MACRO(*p)->name;
goto again;
default:
if (Types[t].visit)
(Types[t].visit)(p, Visit);
}
return 0;
}
static void prepend_ascii_pointer(t_prepend_ascii *x, t_gpointer *gp)
{
SETPOINTER(x->x_at+x->x_ac, gp);
outlet_anything(x->x_obj.ob_outlet, x->x_sym, x->x_ac+1, x->x_at);
}
