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); }