/* CHECKED c74's refman and help patch are wrong about int pairs -- the actual syntax is "[dis]connect indx ondx1 [ondx2 [ondx3..." */ static void matrix_connect(t_matrix *x, t_symbol *s, int ac, t_atom *av) { int onoff = (s == gensym("connect")), indx, celloffset; if (ac < 2) return; /* CHECKED */ /* CHECKED floats silently clipped, symbols converted to 0 */ indx = (av->a_type == A_FLOAT ? (int)av->a_w.w_float : 0); if (indx < 0 || indx >= x->x_ninlets) { /* CHECKED */ loud_error((t_pd *)x, "invalid inlet number %d", indx); return; } celloffset = indx * x->x_noutlets; ac--; av++; while (ac) { /* CHECKED floats silently clipped, symbols converted to 0 */ int cellndx, ondx = (av->a_type == A_FLOAT ? (int)av->a_w.w_float : 0); if (ondx < 0 || ondx >= x->x_noutlets) { /* CHECKED */ loud_error((t_pd *)x, "invalid outlet number %d", ondx); return; } cellndx = celloffset + ondx; x->x_cells[cellndx] = onoff; if (x->x_gains) matrix_retarget(x, cellndx); ac--; av++; } }
static void funbuff_set(t_funbuff *x, t_symbol *s, int ac, t_atom *av) { /* CHECKED symbols somehow bashed to zeros, decreasing x coords corrupt the funbuff -- not emulated here... */ int i = ac; t_atom *ap = av; while (i--) if (ap++->a_type != A_FLOAT) { loud_error((t_pd *)x, "bad input (not a number) -- no data to set"); return; } if (!ac || (ac % 2)) { /* CHECKED odd/null ac loudly rejected, current contents preserved */ loud_error((t_pd *)x, "bad input (%s) -- no data to set", (ac ? "odd arg count" : "no input")); return; } funbuff_clear(x); /* CHECKED the contents is replaced */ while (ac--) { int ndx = (int)av++->a_w.w_float; if (!hammertree_insertfloat(&x->x_tree, ndx, av++->a_w.w_float, 1)) return; ac--; } }
void *plustot_var_new(t_symbol *s, int ac, t_atom *av) { t_plustot_var *x = 0; t_glist *glist = canvas_getcurrent(); t_plustin *tin = 0; t_plusvar *var = 0; if (ac && av->a_type == A_SYMBOL && (tin = plustin_glistprovide(glist, PLUSTIN_GLIST_ANY, 0)) && (var = plusvar_new(av->a_w.w_symbol->s_name, 0, tin))) { x = (t_plustot_var *)plusobject_new(plustot_var_class, s, ac, av, 0); plusbob_preserve((t_plusbob *)var); plusbob_setowner((t_plusbob *)var, (t_pd *)x); plusvar_setlist(var, ac - 1, av + 1, 1); x->x_glist = glist; x->x_var = var; x->x_proxy = plusproxy_var_new((t_pd *)x); plusinlet_new(&x->x_plusobject, (t_pd *)x->x_proxy, 0, 0); plusoutlet_new(&x->x_plusobject, &s_symbol); } else { if (!ac || av->a_type != A_SYMBOL) loud_error(0, "+var: missing name of a variable"); else loud_error(0, "+var: cannot initialize"); if (tin) { plusbob_preserve((t_plusbob *)tin); plusbob_release((t_plusbob *)tin); } } return (x); }
/* LATER rethink the remote case */ void riddle_setsourceblock(t_riddle *rd, int siginno, int newblock) { int slotno = (siginno < 0 ? rd->rd_nsiginlets - siginno - 1 : siginno); #ifdef RIDDLE_DEBUG riddlebug_post(rd, "setsourceblock", "%d (%d) %d", siginno, slotno, newblock); #endif if (siginno >= rd->rd_nsiginlets || -siginno > rd->rd_nremoteslots) loudbug_bug("riddle_setsourceblock"); else if (newblock <= 0) loud_error((t_pd *)rd, "invalid source block on inlet %d: %d", siginno, newblock); else { t_rdsource *so = rd->rd_inslots + slotno; /* LATER if (so->so_newpattern) complain */ if (newblock == so->so_newblock) so->so_sourcecount++; else if (so->so_sourcecount > 0) loud_error((t_pd *)rd, "source block mismatch on inlet %d: %d != %d", siginno, newblock, so->so_newblock); else { so->so_newblock = newblock; so->so_sourcecount = 1; } } }
static void widgettype_map(t_widgettype *wt, char *cls, char *req) { wt->wt_tkclass = (cls ? gensym(cls) : 0); if (wt->wt_requirements) freebytes(wt->wt_requirements, strlen(wt->wt_requirements) + 1); if (req && *req) { char *opt = 0; wt->wt_requirements = getbytes(strlen(req) + 1); strcpy(wt->wt_requirements, req); while (req) { char *w1 = scriptlet_nextword(req); opt = (*req == '-' ? req : (w1 && *w1 == '-' ? w1 : 0)); if (opt) { if (strcmp(opt + 1, "exact")) { loud_error (0, "unknown option \"%s\" in widget type header", opt); opt = 0; } if (*req == '-') { req = w1; continue; } else w1 = scriptlet_nextword(w1); } if (*req >= '0' && *req <= '9') { loud_error (0, "invalid base widget name \"%s\" in widget type header", req); req = w1; } else { t_widgettype *base; char *ver = (w1 && *w1 >= '0' && *w1 <= '9' ? w1 : 0); char *w2 = (ver ? scriptlet_nextword(ver) : w1); #if 1 loudbug_post("require %s (version %s %s)", req, (opt ? opt : ">="), (ver ? ver : "any")); #endif base = widgettype_get(gensym(req), ver, opt, wt->wt_glist); if (!base->wt_tkclass) loud_error(0, "missing base widget file \"%s.wid\"", req); req = w2; } } } else wt->wt_requirements = 0; }
void loud_syserror(t_pd *x, char *fmt, ...) { if (fmt) { char buf[MAXPDSTRING]; va_list ap; va_start(ap, fmt); vsprintf(buf, fmt, ap); loud_error(x, "%s (%s)", buf, strerror(errno)); va_end(ap); } else loud_error(x, strerror(errno)); }
/* returns tagged +bob if valid, null otherwise (silent if caller is empty) */ t_plusbob *plustag_isvalid(t_symbol *tag, t_pd *caller) { if (tag->s_name == plustag_name) return (((t_plusstub *)tag)->sb_bob); else if (caller) { if (strcmp(tag->s_name, plustag_name)) loud_error((caller == PLUSBOB_OWNER ? 0 : caller), "does not understand '%s' (check object connections)", tag->s_name); else loud_error((caller == PLUSBOB_OWNER ? 0 : caller), "confused..."); } return (0); }
void tow_setup(void) { int result = LOADER_OK; if (zgetfn(&pd_objectmaker, gensym("widget"))) loud_warning(0, "tow", "widget is already loaded"); else result = unstable_load_lib("", "widget"); if (result == LOADER_NOFILE) loud_error(0, "widget library is missing"); else if (!zgetfn(&pd_objectmaker, gensym("widget"))) { loud_error(0, "version mismatch"); loud_errand(0, "use a more recent Pd release (or recompile toxy)."); } }
static t_pd *grab_next(t_grab *x) { nextremote: if (x->x_tograbbed) { int inno; x->x_tograbbed = fragile_outlet_nextconnection(x->x_tograbbed, &x->x_grabbed, &inno); if (x->x_grabbed) { if (inno) { if (x->x_target) loud_error((t_pd *)x, "right outlet must feed leftmost inlet"); else loud_error((t_pd *)x, "remote proxy must feed leftmost inlet"); } else { t_outlet *op; t_outlet *goutp; int goutno = x->x_noutlets; x->x_ngrabout = obj_noutlets(x->x_grabbed); if (goutno > x->x_ngrabout) goutno = x->x_ngrabout; while (goutno--) { x->x_grabcons[goutno] = obj_starttraverseoutlet(x->x_grabbed, &goutp, goutno); goutp->o_connections = obj_starttraverseoutlet((t_object *)x, &op, goutno); } return ((t_pd *)x->x_grabbed); } } } if (x->x_bindelem) while (x->x_bindelem = x->x_bindelem->e_next) { t_object *ob; if (ob = pd_checkobject(x->x_bindelem->e_who)) { x->x_tograbbed = fragile_outlet_connections(ob->ob_outlet); goto nextremote; } } return (0); }
static void plustot_env_evalfile(t_plustot_env *x, t_symbol *fname) { char buf1[MAXPDSTRING], buf2[MAXPDSTRING], *nameptr, *dir; int fd; dir = canvas_getdir(x->x_glist)->s_name; if ((fd = open_via_path(dir, fname->s_name, "", buf1, &nameptr, MAXPDSTRING, 0)) < 0) { loud_error((t_pd *)x, "file '%s' not found", fname->s_name); } else { Tcl_Interp *interp = plustin_getinterp(x->x_tin); FILE *fp; close(fd); strcpy(buf2, buf1); strcat(buf2, "/"); strcat(buf2, nameptr); sys_bashfilename(buf2, buf2); Tcl_Preserve(interp); if (Tcl_EvalFile(interp, buf2) != TCL_OK) { strcpy(buf1, "evaluation failed ("); strncat(buf1, buf2, MAXPDSTRING - strlen(buf1) - 2); strcat(buf1, ")"); plusloud_tclerror((t_pd *)x, interp, buf1); } Tcl_Release(interp); } }
/* CHECKED empty sequence stored as an empty file */ static void mtr_dowrite(t_mtr *x, t_mtrack *source, t_symbol *fname) { int failed = 0; char path[MAXPDSTRING]; FILE *fp; if (x->x_glist) canvas_makefilename(x->x_glist, fname->s_name, path, MAXPDSTRING); else { strncpy(path, fname->s_name, MAXPDSTRING); path[MAXPDSTRING-1] = 0; } /* CHECKED no global message */ if (fp = sys_fopen(path, "w")) { /* CHECKED single-track writing does not seem to work (a bug?) */ if (source) failed = mtr_writetrack(x, source, fp); else { int id; t_mtrack **tpp; for (id = 0, tpp = x->x_tracks; id < x->x_ntracks; id++, tpp++) if (failed = mtr_writetrack(x, *tpp, fp)) break; } if (failed) sys_unixerror(path); /* LATER rethink */ fclose(fp); } else { sys_unixerror(path); /* LATER rethink */ failed = 1; } if (failed) loud_error((t_pd *)x, "writing text file \"%s\" failed", path); }
t_canvas *riddle_nextgraph(t_riddle *rd) { while (rd->rd_private->pr_oc) { t_object *dst; t_inlet *ip; int inno; rd->rd_private->pr_oc = obj_nexttraverseoutlet(rd->rd_private->pr_oc, &dst, &ip, &inno); if (dst) { int siginno = obj_siginletindex(dst, inno); if (siginno < 0) { /* should not happen, LATER rethink */ break; } else if (pd_class((t_pd *)dst) != canvas_class) { loud_error((t_pd *)rd, "invalid connection (not to a canvas)"); break; } else return ((t_canvas *)dst); } } return (0); }
void *plustot_qlist_new(t_symbol *s, int ac, t_atom *av) { t_plustot_qlist *x = 0; t_glist *glist = canvas_getcurrent(); t_plustin *tin = 0; t_plustob *tob = 0; if ((tin = plustin_glistprovide(glist, PLUSTIN_GLIST_ANY, 0)) && (tob = plustob_new(tin, 0))) { x = (t_plustot_qlist *) plusobject_new(plustot_qlist_class, s, ac, av, 0); plusbob_preserve((t_plusbob *)tob); plusbob_setowner((t_plusbob *)tob, (t_pd *)x); plustob_setlist(tob, ac, av); x->x_glist = glist; x->x_tob = tob; x->x_proxy = plusproxy_qlist_new(x); plusinlet_new(&x->x_plusobject, (t_pd *)x->x_proxy, 0, 0); plusoutlet_new(&x->x_plusobject, &s_anything); x->x_rightout = outlet_new((t_object *)x, &s_symbol); } else { loud_error(0, "+qlist: cannot initialize"); if (tin) { plusbob_preserve((t_plusbob *)tin); plusbob_release((t_plusbob *)tin); } } return (x); }
int loud_floatarg(t_class *c, int which, int ac, t_atom *av, t_float *vp, t_float minval, t_float maxval, int underaction, int overaction, char *what) { int result = LOUD_ARGOK; if (which < ac) { av += which; if (av->a_type == A_FLOAT) { t_float f = av->a_w.w_float; if (f < minval) { *vp = (underaction & LOUD_CLIP ? minval : f); if (underaction) result = LOUD_ARGUNDER; } else if (f > maxval) { *vp = (overaction & LOUD_CLIP ? maxval : f); if (overaction) result = LOUD_ARGOVER; } else *vp = f; } else result = LOUD_ARGTYPE; } else result = LOUD_ARGMISSING; if (what) { switch (result) { case LOUD_ARGUNDER: if (underaction & LOUD_WARN) { if (underaction & LOUD_CLIP) loud_warning(&c, 0, "%s rounded up to %g", what, minval); else loud_warning(&c, 0, "less than %g %s requested", minval, what); } break; case LOUD_ARGOVER: if (overaction & LOUD_WARN) { if (overaction & LOUD_CLIP) loud_warning(&c, 0, "%s truncated to %g", what, maxval); else loud_warning(&c, 0, "more than %g %s requested", maxval, what); } break; case LOUD_ARGTYPE: loud_error(0, "bad argument %d (%s)", which, class_getname(c)); break; default:; } } return (result); }
static t_probtrans *prob_findstate(t_prob *x, int value, int complain) { t_probtrans *state; for (state = x->x_translist; state; state = state->tr_nextstate) if (state->tr_value == value) break; if (!state && complain && !x->x_silent) loud_error((t_pd *)x, "no state %d", value); /* CHECKED */ return (state); }
static void riddle__reblock(t_riddle *rd, t_symbol *pattern, t_floatarg f1, t_floatarg f2, t_floatarg f3) { riddle_setsourceflags(rd, (int)f1, (int)f3); if (pattern == rdps__) riddle_setsourceblock(rd, (int)f1, (int)f2); else if (pattern) riddle_setsourcelayout(rd, (int)f1, pattern, (int)f2); else loud_error((t_pd *)rd, "bad arguments to '_reblock'"); }
static void matrix_list(t_matrix *x, t_symbol *s, int ac, t_atom *av) { int indx, ondx, cellndx, onoff; float gain; if (ac < 3) return; /* CHECKED list silently ignored if ac < 3 */ /* CHECKED floats silently clipped, symbols converted to 0 */ indx = (av->a_type == A_FLOAT ? (int)av->a_w.w_float : 0); if (indx < 0 || indx >= x->x_ninlets) { /* CHECKED */ loud_error((t_pd *)x, "invalid inlet number %d", indx); return; } ac--; av++; /* CHECKED floats silently clipped, symbols converted to 0 */ ondx = (av->a_type == A_FLOAT ? (int)av->a_w.w_float : 0); if (ondx < 0 || ondx >= x->x_noutlets) { /* CHECKED */ loud_error((t_pd *)x, "invalid outlet number %d", ondx); return; } cellndx = indx * x->x_noutlets + ondx; ac--; av++; /* CHECKED negative gain used in nonbinary mode, accepted as 1 in binary */ gain = (av->a_type == A_FLOAT ? av->a_w.w_float : 0.); onoff = (gain < -MATRIX_GAINEPSILON || gain > MATRIX_GAINEPSILON); x->x_cells[cellndx] = onoff; if (x->x_gains) { if (onoff) /* CHECKME */ x->x_gains[cellndx] = gain; ac--; av++; if (ac) { float ramp = (av->a_type == A_FLOAT ? av->a_w.w_float : 0.); x->x_ramps[cellndx] = (ramp < MATRIX_MINRAMP ? 0. : ramp); } matrix_retarget(x, cellndx); } }
void riddle_setsourcelayout(t_riddle *rd, int siginno, t_symbol *newpattern, int maxblock) { int slotno = (siginno < 0 ? rd->rd_nsiginlets - siginno - 1 : siginno); #ifdef RIDDLE_DEBUG riddlebug_post(rd, "setsourcelayout", "%d (%d) %s %d", siginno, slotno, newpattern->s_name, maxblock); #endif if (siginno >= rd->rd_nsiginlets || -siginno > rd->rd_nremoteslots) loudbug_bug("riddle_setsourcelayout"); else { t_rdsource *so = rd->rd_inslots + slotno; if (newpattern == so->so_newpattern) so->so_sourcecount++; else if (so->so_sourcecount > 0) { if (so->so_newpattern) loud_error((t_pd *)rd, "source layout mismatch on inlet %d: %s != %s", siginno, newpattern->s_name, so->so_newpattern->s_name); else loud_error((t_pd *)rd, "source layout/block mismatch on inlet %d"); } else if (newpattern = riddle_validatepattern(newpattern)) { so->so_newpattern = newpattern; if (maxblock) { if (maxblock > so->so_newblock) so->so_newblock = maxblock; } else so->so_newblock = rd->rd_graphblock; so->so_sourcecount = 1; } } }
void hammer_setup(void) { if (canvas_getcurrent()) { /* Loading the library by object creation is banned, because of a danger of having some of the classes already loaded. LATER rethink. */ loud_error(0, "apparently an attempt to create a 'hammer' object"); loud_errand(0, "without having hammer library preloaded"); return; } if (zgetfn(&pd_objectmaker, gensym("hammer"))) { loud_error(0, "hammer is already loaded"); return; } if (!zgetfn(&pd_objectmaker, gensym("cyclone"))) post("this is hammer %s, %s %s build", CYCLONE_VERSION, loud_ordinal(CYCLONE_BUILD), CYCLONE_RELEASE); hammer_class = class_new(gensym("hammer"), (t_newmethod)hammer_new, (t_method)hammer_free, sizeof(t_hammer), 0, 0); class_addbang(hammer_class, hammer_bang); class_addmethod(hammer_class, (t_method)hammer_cd, gensym("cd"), A_DEFSYM, 0); class_addmethod(hammer_class, (t_method)hammer_pwd, gensym("pwd"), A_SYMBOL, 0); class_addmethod(hammer_class, (t_method)hammer_import, gensym("import"), A_DEFSYM, 0); class_addmethod(hammer_class, (t_method)hammer_click, gensym("click"), A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, 0); hammerfile_setup(hammer_class, 0); hammer_firstndx = fragile_class_count(); allhammers_setup(); hammer_lastndx = fragile_class_count() - 1; }
int riddle_checksourceblock(t_riddle *rd, int siginno, int reqblock) { int block = riddle_getsourceblock(rd, siginno); if (block == reqblock) return (1); else { if (!rd->rd_wasdisabled && rd->rd_inslots[siginno].so_sourcecount) loud_error((t_pd *)rd, "invalid source block on inlet %d: %d (%d expected)", siginno, block, reqblock); rd->rd_disabled = 1; return (0); } }
int riddle_checksourcelayout(t_riddle *rd, int siginno, t_symbol *reqpattern, int *maxblockp) { t_symbol *pattern = riddle_getsourcelayout(rd, siginno, maxblockp); if (reqpattern == pattern || riddle_validatepattern(reqpattern) == pattern) return (1); else { if (!rd->rd_wasdisabled && rd->rd_inslots[siginno].so_sourcecount) { if (pattern) loud_error((t_pd *)rd, "wrong source layout on inlet %d: %s (%s expected)", siginno, pattern->s_name, reqpattern->s_name); else loud_error((t_pd *)rd, "invalid source on inlet %d: layout %s expected", siginno, reqpattern->s_name); } rd->rd_disabled = 1; return (0); } }
static void funbuff_find(t_funbuff *x, t_floatarg f) { t_hammernode *np; if (np = x->x_tree.t_first) { do { /* CHECKED lastdelta preserved */ if (HAMMERNODE_GETFLOAT(np) == f) funbuff_dooutput(x, np->n_key, x->x_lastdelta); } while (np = np->n_next); /* CHECKED no bangout, no complaint if nothing found */ } else loud_error((t_pd *)x, "nothing to find"); /* CHECKED */ }
static void funbuff_dump(t_funbuff *x) { t_hammernode *np; if (np = x->x_tree.t_first) { do { x->x_lastdelta = HAMMERNODE_GETFLOAT(np); /* CHECKED */ /* float value preserved (this is incompatible) */ funbuff_dooutput(x, np->n_key, x->x_lastdelta); } while (np = np->n_next); /* CHECKED no bangout */ } else loud_error((t_pd *)x, "nothing to dump"); /* CHECKED */ }
int loud_checkint(t_pd *x, t_float f, int *valuep, t_symbol *mess) { if ((*valuep = (int)f) == f) return (1); else { static t_symbol *floatsym = 0; if (!floatsym) floatsym = gensym("noninteger float"); if (mess == &s_float) loud_nomethod(x, floatsym); else if (mess) loud_error(x, "\"%s\" argument invalid for message \"%s\"", floatsym->s_name, mess->s_name); return (0); } }
/* returns tagged +bob if valid, null otherwise (silent if caller is empty) */ t_plusbob *plustag_validroot(t_symbol *tag, t_symbol *rname, t_pd *caller) { if (tag->s_name == plustag_name) { t_plusbob *bob = ((t_plusstub *)tag)->sb_bob; if (bob->bob_root->tp_name == rname) return (bob); else if (caller) { t_symbol *s = bob->bob_root->tp_name; loud_error((caller == PLUSBOB_OWNER ? bob->bob_owner : caller), "invalid base type '%s' ('%s' expected)", (s ? s->s_name : "<unknown>"), (rname ? rname->s_name : "<unknown>")); } } else if (plustag_isvalid(tag, caller)) /* print the error there */ loudbug_bug("plustag_validroot"); return (0); }
static void funbuff_doread(t_funbuff *x, t_symbol *fn) { t_binbuf *bb = binbuf_new(); int ac; t_atom *av; char buf[MAXPDSTRING]; /* FIXME use open_via_path() */ canvas_makefilename(x->x_canvas, fn->s_name, buf, MAXPDSTRING); binbuf_read(bb, buf, "", 0); if ((ac = binbuf_getnatom(bb)) && (av = binbuf_getvec(bb)) && av->a_type == A_SYMBOL && av->a_w.w_symbol == gensym("funbuff")) { post("funbuff_read: %s read successful", fn->s_name); /* CHECKED */ funbuff_set(x, 0, ac-1, av+1); } else /* CHECKED no complaints... */ loud_error((t_pd *)x, "invalid file %s", fn->s_name); binbuf_free(bb); }
void *plustot_env_new(t_symbol *s, int ac, t_atom *av) { t_plustot_env *x = 0; t_glist *gl = canvas_getcurrent(); t_plustin *oldtin = plustin_glistfind(gl, PLUSTIN_GLIST_THIS); t_plustin *deftin = (oldtin ? 0 : plustin_glistfind(gl, PLUSTIN_GLIST_ANY)); t_plustin *tin = 0; if ((tin = oldtin) || (tin = plustin_glistprovide(gl, PLUSTIN_GLIST_THIS, 1))) { int warned = 0; x = (t_plustot_env *)plusobject_new(plustot_env_class, s, ac, av, 0); x->x_tin = tin; plusbob_preserve((t_plusbob *)tin); x->x_glist = gl; plusoutlet_new(&x->x_plusobject, &s_symbol); if (deftin) /* true if both oldtin == 0 (we are first in this glist) and plustin_default != 0 (bobs exist already) */ plustot_env_takeover(x->x_glist, (t_plusbob *)deftin, (t_plusbob *)tin); x->x_filehandle = hammerfile_new((t_pd *)x, 0, plustot_env_evalfilehook, 0, 0); while (ac--) { if (av->a_type == A_SYMBOL) plustot_env_evalfile(x, av->a_w.w_symbol); else if (!warned) { loud_warning((t_pd *)x, 0, "bad atom"); warned = 1; } av++; } } else loud_error(0, "+env: cannot initialize"); return (x); }
void loud_classarg(t_class *c) { loud_error(0, "missing or bad arguments in \"%s\"", class_getname(c)); }
void loud_messarg(t_pd *x, t_symbol *s) { loud_error(x, "bad arguments for message \"%s\"", s->s_name); }
void loud_nomethod(t_pd *x, t_symbol *s) { loud_error(x, "doesn't understand \"%s\"", s->s_name); }