Max 5 API Reference
Max 5 API Reference
00001 #include "jit.common.h" 00002 #include "jit.namespace.h" 00003 00004 00005 void *_jit_namespace_class; 00006 void *_jit_namespace_data_class; 00007 void *_jit_namespace_ref_class; 00008 00009 t_jit_linklist *_jit_namespace_list = NULL; 00010 00011 #define JIT_NAMESPACE_SEPARATOR '::' 00012 #define JIT_NAMESPACE_DECORATOR "%s_#%d" 00013 00014 // data struct for findfirst operations 00015 typedef struct _jit_namespace_find_data 00016 { 00017 t_cmpfn cmpfn; 00018 void *cmpdata; 00019 } t_jit_namespace_find_data; 00020 00021 00022 t_jit_namespace_data *jit_namespace_resolve_name(t_jit_namespace *x, t_symbol *name); 00023 void *jit_namespace_getlist(t_jit_namespace *x); 00024 long jit_namespace_name_parse(t_symbol *name, t_symbol **out, long which); 00025 long jit_namespace_find(t_jit_namespace *x, t_jit_namespace *o); 00026 long jit_namespace_find_reference(t_jit_namespace *x, void *ref); 00027 long jit_namespace_find_name(t_jit_namespace_data *x, t_symbol *name); 00028 long jit_namespace_getsize(t_jit_namespace *x); 00029 long jit_namespace_findsize(t_jit_namespace *x, long cmpfn(void *, void *), void *cmpdata); 00030 long jit_namespace_find_intermediate(t_jit_namespace_data *o, t_jit_namespace_find_data *ffd); 00031 void jit_namespace_findfirst(t_jit_namespace *x, void **o, long cmpfn(void *, void *), void *cmpdata); 00032 void jit_namespace_findall(t_jit_namespace *x, t_jit_linklist **o, long cmpfn(void *, void *), void *cmpdata); 00033 void jit_namespace_notify(t_jit_namespace *x, t_symbol *s, void *data); 00034 void jit_namespace_sort(t_jit_namespace *x, long cmpfn(void *, void *)); 00035 void *jit_namespace_detach(t_jit_namespace *x, t_symbol *name); 00036 void *jit_namespace_detachall(t_jit_namespace *x); 00037 void *jit_namespace_finddetach(t_jit_namespace *x, long cmpfn(void *, void *), void *cmpdata); 00038 void *jit_namespace_add(t_jit_namespace *x, t_symbol *name, void *data); 00039 void *jit_namespace_add_decorated(t_jit_namespace *x, t_symbol *name, void *data, t_symbol **out_name); 00040 void *jit_namespace_replace(t_jit_namespace *x, t_symbol *name, void *data); 00041 void *jit_namespace_iterate(t_jit_namespace *x, long *index); 00042 t_symbol *jit_namespace_ob_sym(t_jit_namespace *x, t_symbol *name); 00043 t_symbol *jit_namespace_gettype(t_jit_namespace *x, t_symbol *name); 00044 void *jit_namespace_resolve_raw(t_jit_namespace *x, t_symbol *name); 00045 t_jit_err jit_namespace_resolve_char(t_jit_namespace *x, t_symbol *name, long *size, uchar **data); 00046 t_jit_err jit_namespace_resolve_long(t_jit_namespace *x, t_symbol *name, long *size, long **data); 00047 t_jit_err jit_namespace_resolve_float(t_jit_namespace *x, t_symbol *name, long *size, float **data); 00048 t_jit_err jit_namespace_resolve_double(t_jit_namespace *x, t_symbol *name, long *size, double **data); 00049 t_jit_err jit_namespace_resolve_symbol(t_jit_namespace *x, t_symbol *name, long *size, t_symbol ***data); 00050 t_jit_err jit_namespace_resolve_atom(t_jit_namespace *x, t_symbol *name, long *size, t_atom **data); 00051 t_jit_err jit_namespace_resolve_object(t_jit_namespace *x, t_symbol *name, long *size, void ***data); 00052 t_jit_err jit_namespace_resolve_pointer(t_jit_namespace *x, t_symbol *name, long *size, void ***data); 00053 void jit_namespace_methodall(t_jit_namespace *x, t_symbol *s, ...); 00054 void *jit_namespace_new(void *reference); 00055 void jit_namespace_free(t_jit_namespace *x); 00056 void *jit_namespace_data_new(t_symbol *name, void *data); 00057 void jit_namespace_data_free(t_jit_namespace_data *x); 00058 void *jit_namespace_data_getdata(t_jit_namespace_data *x); 00059 t_symbol *jit_namespace_data_getname(t_jit_namespace_data *x); 00060 t_symbol *jit_namespace_data_gettype(t_jit_namespace_data *x); 00061 t_symbol *jit_namespace_data_ob_sym(t_jit_namespace_data *x); 00062 t_jit_err jit_namespace_data_resolve_atom(t_jit_namespace_data *x, long *size, t_atom **data); 00063 void jit_namespace_data_data_method(t_jit_namespace_data *x, t_symbol *s, ...); 00064 long jit_namespace_find_any(void *, void *); 00065 00066 void jit_namespace_init(void) 00067 { 00068 _jit_namespace_class = jit_class_new("jit_namespace", (method)jit_namespace_new, 00069 (method)jit_namespace_free, sizeof(t_jit_namespace), A_CANT, 0L); 00070 00071 jit_class_addmethod(_jit_namespace_class, (method)jit_object_register, "register", A_CANT, 0L); 00072 jit_class_addmethod(_jit_namespace_class, (method)jit_method_true, "class_jit_namespace", A_CANT, 0L); 00073 00074 // jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_getreference, "getreference", A_CANT, 0L); 00075 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_getsize, "getsize", A_CANT, 0L); 00076 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_findsize, "findsize", A_CANT, 0L); 00077 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_findfirst, "findfirst", A_CANT, 0L); 00078 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_findall, "findall", A_CANT, 0L); 00079 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_methodall, "methodall", A_CANT, 0L); 00080 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_detach, "detach", A_CANT, 0L); 00081 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_detachall, "detachall", A_CANT, 0L); 00082 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_finddetach, "finddetach", A_CANT, 0L); 00083 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_iterate, "iterate", A_CANT, 0L); 00084 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_add, "add", A_CANT, 0L); 00085 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_add_decorated, "add_decorated", A_CANT, 0L); 00086 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_replace, "replace", A_CANT, 0L); 00087 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_gettype, "gettype", A_CANT, 0L); 00088 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_getlist, "getlist", A_CANT, 0L); 00089 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_ob_sym, "ob_sym", A_CANT, 0L); 00090 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_name, "resolve_name", A_CANT, 0L); 00091 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_raw, "resolve_raw", A_CANT, 0L); 00092 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_char, "resolve_char", A_CANT, 0L); 00093 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_long, "resolve_long", A_CANT, 0L); 00094 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_float, "resolve_float", A_CANT, 0L); 00095 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_double, "resolve_double", A_CANT, 0L); 00096 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_symbol, "resolve_symbol", A_CANT, 0L); 00097 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_atom, "resolve_atom", A_CANT, 0L); 00098 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_object, "resolve_object", A_CANT, 0L); 00099 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_resolve_pointer,"resolve_pointer", A_CANT, 0L); 00100 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_sort, "sort", A_CANT, 0L); 00101 jit_class_addmethod(_jit_namespace_class, (method)jit_namespace_notify, "notifyall", A_CANT, 0L); 00102 00103 _jit_namespace_data_class = jit_class_new("jit_namespace_data", (method)jit_namespace_data_new, 00104 (method)jit_namespace_data_free, sizeof(t_jit_namespace_data), A_CANT, 0L); 00105 00106 jit_class_addmethod(_jit_namespace_data_class, (method)jit_namespace_data_getname, "getname", A_CANT, 0L); 00107 jit_class_addmethod(_jit_namespace_data_class, (method)jit_namespace_data_getdata, "getdata", A_CANT, 0L); 00108 jit_class_addmethod(_jit_namespace_data_class, (method)jit_namespace_data_gettype, "gettype", A_CANT, 0L); 00109 jit_class_addmethod(_jit_namespace_data_class, (method)jit_namespace_data_ob_sym, "ob_sym", A_CANT, 0L); 00110 jit_class_addmethod(_jit_namespace_data_class, (method)jit_namespace_data_resolve_atom, "resolve_atom", A_CANT, 0L); 00111 jit_class_addmethod(_jit_namespace_data_class, (method)jit_namespace_data_data_method, "data_method", A_CANT, 0L); 00112 00113 jit_class_register(_jit_namespace_class); 00114 jit_class_register(_jit_namespace_data_class); 00115 } 00116 00117 #pragma mark - 00118 #pragma mark find functions 00119 #pragma mark - 00120 00121 long jit_namespace_find(t_jit_namespace *x, t_jit_namespace *o) 00122 { 00123 return (x == o); 00124 } 00125 00126 long jit_namespace_find_reference(t_jit_namespace *x, void *ref) 00127 { 00128 return (x->reference == ref); 00129 } 00130 00131 long jit_namespace_find_name(t_jit_namespace_data *x, t_symbol *name) 00132 { 00133 return (x->name == name); 00134 } 00135 00136 long jit_namespace_find_any(void *x, void *y) 00137 { 00138 return 1; 00139 } 00140 00141 #pragma mark - 00142 00143 long jit_namespace_getsize(t_jit_namespace *x) 00144 { 00145 if (x) { 00146 return jit_linklist_getsize(x->list); 00147 } 00148 return 0; 00149 } 00150 00151 void *jit_namespace_iterate(t_jit_namespace *x, long *index) 00152 { 00153 if (x) { 00154 void *o; 00155 00156 if (o = jit_linklist_getindex(x->list, *index)) { 00157 (*index)++; 00158 return o; 00159 } 00160 } 00161 *index = 0; 00162 return NULL; 00163 } 00164 00165 long jit_namespace_findsize(t_jit_namespace *x, long cmpfn(void *, void *), void *cmpdata) 00166 { 00167 if (x) { 00168 return jit_linklist_findcount(x->list, cmpfn, cmpdata); 00169 } 00170 return 0; 00171 } 00172 00173 long jit_namespace_find_intermediate(t_jit_namespace_data *o, t_jit_namespace_find_data *ffd) 00174 { 00175 return ((*ffd->cmpfn)(o->data, ffd->cmpdata)); 00176 } 00177 00178 void jit_namespace_findfirst(t_jit_namespace *x, void **o, long cmpfn(void *, void *), void *cmpdata) 00179 { 00180 if (x) 00181 jit_linklist_findfirst(x->list, o, cmpfn, cmpdata); 00182 /* 00183 t_jit_namespace_find_data ffd; 00184 00185 if (x) { 00186 ffd.cmpfn = cmpfn; 00187 ffd.cmpdata = cmpdata; 00188 00189 jit_linklist_findfirst(x->list, o, jit_namespace_find_intermediate, &ffd); 00190 } */ 00191 } 00192 00193 void jit_namespace_findall(t_jit_namespace *x, t_jit_linklist **o, long cmpfn(void *, void *), void *cmpdata) 00194 { 00195 if (x) 00196 jit_linklist_findall(x->list, o, cmpfn, cmpdata); 00197 00198 /* t_jit_namespace_find_data ffd; 00199 00200 if (x) { 00201 *o = NULL; 00202 ffd.cmpfn = cmpfn; 00203 ffd.cmpdata = cmpdata; 00204 00205 jit_linklist_findall(x->list, o, jit_namespace_find_intermediate, &ffd); 00206 } */ 00207 } 00208 00209 void jit_namespace_sort(t_jit_namespace *x, long cmpfn(void *, void *)) 00210 { 00211 if (x) { 00212 jit_linklist_sort(x->list, cmpfn); 00213 } 00214 } 00215 00216 void jit_namespace_notify(t_jit_namespace *x, t_symbol *s, void *data) 00217 { 00218 jit_namespace_methodall(x, gensym("notify"), _jit_sym_nothing, s, x, data); 00219 00220 // jit_object_notify(x, s, data); 00221 /* if (x) { 00222 jit_namespace_methodall(x, gensym("notify"), s, msg, sender); 00223 } */ 00224 } 00225 00226 /* 00227 void jit_namespace_findnotify(t_jit_namespace *x, long cmpfn(void *, void *), void *cmpdata, t_symbol *s, void *msg, void *sender) 00228 { 00229 t_jit_linklist *l; 00230 00231 if (x) { 00232 jit_namespace_findall(x, &l, cmpfn, cmpdata); 00233 if (l) 00234 jit_linklist_methodall(l, gensym("data_method"), s, msg, sender); 00235 } 00236 } 00237 */ 00238 00239 void jit_namespace_methodall(t_jit_namespace *x, t_symbol *s, ...) 00240 { 00241 if (x) { 00242 jit_linklist_methodall(x->list, gensym("data_method"), s, *((t_stack_splat *)(((char *)(&s))+4))); 00243 } 00244 } 00245 00246 void *jit_namespace_getlist(t_jit_namespace *x) 00247 { 00248 return x->list; 00249 } 00250 00251 void *jit_namespace_lookup(void *reference) 00252 { 00253 t_jit_namespace *ns; 00254 00255 if (!reference || !_jit_namespace_list) 00256 return NULL; 00257 00258 jit_linklist_findfirst(_jit_namespace_list, &ns, jit_namespace_find_reference, reference); 00259 return ns; 00260 } 00261 00262 void *jit_namespace_attach(void *reference, t_symbol *name, void *data) 00263 { 00264 t_jit_namespace *ns; 00265 t_jit_namespace_data *m; 00266 00267 if (!(reference && name && data)) 00268 return NULL; 00269 00270 if (!_jit_namespace_list) { 00271 _jit_namespace_list = jit_linklist_new(); 00272 goto makenew; 00273 } 00274 00275 jit_linklist_findfirst(_jit_namespace_list, &ns, jit_namespace_find_reference, reference); 00276 if (ns) { 00277 jit_linklist_findfirst(ns->list, &m, jit_namespace_find_name, name); 00278 if (!m) { 00279 jit_namespace_add(ns, name, data); 00280 return ns; 00281 } 00282 else return NULL; 00283 } 00284 00285 makenew: 00286 ns = jit_namespace_new(reference); 00287 jit_linklist_append(_jit_namespace_list, ns); 00288 jit_namespace_add(ns, name, data); 00289 return ns; 00290 } 00291 00292 void *jit_namespace_attach_decorated(void *reference, t_symbol *name, void *data, t_symbol **out_name) 00293 { 00294 t_jit_namespace *ns; 00295 t_jit_namespace_data *m; 00296 00297 if (!(reference && name && data)) 00298 return NULL; 00299 00300 if (!_jit_namespace_list) { 00301 _jit_namespace_list = jit_linklist_new(); 00302 goto makenew; 00303 } 00304 00305 jit_linklist_findfirst(_jit_namespace_list, &ns, jit_namespace_find_reference, reference); 00306 if (ns) { 00307 jit_linklist_findfirst(ns->list, &m, jit_namespace_find_name, name); 00308 if (!m) { 00309 jit_namespace_add(ns, name, data); 00310 *out_name = name; 00311 return ns; 00312 } 00313 else { 00314 long i = 1; 00315 char tmp[256]; 00316 t_symbol *sname; 00317 00318 do { 00319 sprintf(tmp, JIT_NAMESPACE_DECORATOR, name->s_name, i++); 00320 jit_linklist_findfirst(ns->list, &m, jit_namespace_find_name, sname = gensym(tmp)); 00321 } while (m); 00322 00323 jit_namespace_add(ns, sname, data); 00324 *out_name = sname; 00325 return ns; 00326 } 00327 } 00328 00329 makenew: 00330 if (ns = jit_namespace_new(reference)) { 00331 jit_linklist_append(_jit_namespace_list, ns); 00332 jit_namespace_add(ns, name, data); 00333 *out_name = name; 00334 } 00335 return ns; 00336 } 00337 00338 void *jit_namespace_detach(t_jit_namespace *x, t_symbol *name) 00339 { 00340 t_jit_namespace_data *o; 00341 00342 if (!x) 00343 return NULL; 00344 00345 jit_linklist_findfirst(x->list, &o, jit_namespace_find_name, name); 00346 if (o) { 00347 jit_object_notify(x, _jit_sym_detach, name); 00348 jit_linklist_deleteindex(x->list, jit_linklist_objptr2index(x->list, o)); 00349 } 00350 00351 if (!jit_linklist_getsize(x->list)) { 00352 jit_linklist_deleteindex(_jit_namespace_list, jit_linklist_objptr2index(_jit_namespace_list, x)); 00353 if (!jit_linklist_getsize(_jit_namespace_list)) { 00354 jit_object_post((t_object *)x,"freed master list"); 00355 jit_object_free(_jit_namespace_list); 00356 _jit_namespace_list = NULL; 00357 } 00358 return NULL; 00359 } 00360 else return x; 00361 } 00362 00363 void *jit_namespace_detachall(t_jit_namespace *x) 00364 { 00365 t_jit_namespace_data *o; 00366 long count, i; 00367 t_jit_namespace *rv; 00368 00369 if (!x) 00370 return NULL; 00371 00372 jit_linklist_findfirst(x->list, &o, jit_namespace_find_any, NULL); 00373 while (o) { 00374 rv = jit_namespace_detach(x, jit_namespace_data_getname(o)); 00375 jit_linklist_findfirst(x->list, &o, jit_namespace_find_any, NULL); 00376 } 00377 00378 return rv; 00379 } 00380 00381 void *jit_namespace_finddetach(t_jit_namespace *x, long cmpfn(void *, void *), void *cmpdata) 00382 { 00383 void *l; 00384 long count, i; 00385 t_jit_namespace *rv; 00386 00387 if (!x) 00388 return NULL; 00389 00390 jit_namespace_findall(x, &l, cmpfn, cmpdata); 00391 if (l) { 00392 count = jit_linklist_getsize(l); 00393 for (i = 0; i < count; i++) { 00394 rv = jit_namespace_detach(x, jit_namespace_data_getname(jit_object_method(l, _jit_sym_getindex, i))); 00395 } 00396 jit_linklist_chuck(l); 00397 } 00398 00399 return rv; 00400 } 00401 00402 void *jit_namespace_add(t_jit_namespace *x, t_symbol *name, void *data) 00403 { 00404 t_jit_namespace_data *o; 00405 00406 if (x && name && data) { 00407 jit_linklist_findfirst(x->list, &o, jit_namespace_find_name, name); 00408 if (!o) { 00409 o = jit_namespace_data_new(name, data); 00410 jit_linklist_append(x->list, o); 00411 jit_object_notify(x, _jit_sym_attach, name); 00412 return x; 00413 } 00414 } 00415 return NULL; 00416 } 00417 00418 void *jit_namespace_add_decorated(t_jit_namespace *x, t_symbol *name, void *data, t_symbol **out_name) 00419 { 00420 t_jit_namespace_data *o; 00421 00422 if (x && name && data) { 00423 jit_linklist_findfirst(x->list, &o, jit_namespace_find_name, name); 00424 if (!o) { 00425 o = jit_namespace_data_new(name, data); 00426 jit_linklist_append(x->list, o); 00427 jit_object_notify(x, _jit_sym_attach, name); 00428 *out_name = name; 00429 return x; 00430 } 00431 else { 00432 long i = 1; 00433 char tmp[256]; 00434 t_symbol *sname; 00435 00436 do { 00437 sprintf(tmp, JIT_NAMESPACE_DECORATOR, name->s_name, i++); 00438 jit_linklist_findfirst(x->list, &o, jit_namespace_find_name, sname = gensym(tmp)); 00439 } while (o); 00440 00441 jit_namespace_add(x, sname, data); 00442 *out_name = sname; 00443 return x; 00444 } 00445 } 00446 return NULL; 00447 } 00448 00449 void *jit_namespace_replace(t_jit_namespace *x, t_symbol *name, void *data) 00450 { 00451 t_jit_namespace_data *o, *old; 00452 00453 if (x && name && data) { 00454 o = jit_namespace_data_new(name, data); 00455 jit_linklist_findfirst(x->list, &old, jit_namespace_find_name, name); 00456 if (old) { 00457 jit_object_notify(x, _jit_sym_detach, name); 00458 jit_linklist_deleteindex(x->list, jit_linklist_objptr2index(x->list, old)); 00459 } 00460 jit_linklist_append(x->list, o); 00461 jit_object_notify(x, _jit_sym_attach, name); 00462 return x; 00463 } 00464 return NULL; 00465 } 00466 00467 t_symbol *jit_namespace_ob_sym(t_jit_namespace *x, t_symbol *name) 00468 { 00469 t_jit_namespace_data *o; 00470 00471 if (x) { 00472 if (o = jit_namespace_resolve_name(x, name)) { 00473 if (!NOGOOD(o->data)) 00474 // if (((t_jit_object *)o->data)->o_messlist) 00475 return ob_sym(o->data); 00476 } 00477 } 00478 return _jit_sym_nothing; 00479 } 00480 00481 t_symbol *jit_namespace_gettype(t_jit_namespace *x, t_symbol *name) 00482 { 00483 t_jit_namespace_data *o; 00484 00485 if (x) { 00486 if (o = jit_namespace_resolve_name(x, name)) { 00487 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00488 return ((t_symbol *)jit_object_method(o->data, _jit_sym_gettype)); 00489 } 00490 else if (!NOGOOD(o->data)) 00491 // else if (((t_jit_object *)o->data)->o_messlist) 00492 return ob_sym(o->data); 00493 } 00494 } 00495 return _jit_sym_nothing; 00496 } 00497 00498 long jit_namespace_name_parse(t_symbol *name, t_symbol **out, long which) 00499 { 00500 long rv = 0; 00501 long len = strlen(name->s_name); 00502 long i = 0; 00503 char tmp[1024]; 00504 char *tmpp = tmp; 00505 00506 if (which == -1) { 00507 for (i = 0; i < len; i++) { 00508 if (*((short *)(name->s_name + i)) == JIT_NAMESPACE_SEPARATOR) { 00509 ++rv; 00510 i += 2; 00511 } 00512 } 00513 if (out) 00514 *out = _jit_sym_nothing; 00515 return rv; 00516 } 00517 else { 00518 if (rv == which) 00519 goto strcopy; 00520 00521 for (i = 0; i < len; i++) { 00522 if (*((short *)(name->s_name + i)) == JIT_NAMESPACE_SEPARATOR) { 00523 ++rv; 00524 i += 2; 00525 if (rv == which) 00526 goto strcopy; 00527 } 00528 } 00529 } 00530 if (out) { 00531 *out = _jit_sym_nothing; 00532 } 00533 return -1; // something went wrong 00534 00535 strcopy: 00536 for ( ; i < len; i++) { 00537 if (*((short *)(name->s_name + i)) != JIT_NAMESPACE_SEPARATOR) { 00538 *tmpp++ = name->s_name[i]; 00539 } 00540 else { 00541 break; 00542 } 00543 } 00544 *tmpp = '\0'; 00545 if (out) { 00546 *out = gensym(tmp); 00547 return 0; 00548 } 00549 else return -1; // what was the point? 00550 } 00551 00552 t_jit_namespace_data *jit_namespace_resolve_name(t_jit_namespace *x, t_symbol *name) 00553 { 00554 t_jit_namespace *ns = x; 00555 t_jit_namespace_data *o; 00556 t_symbol *newname = name; 00557 long parse, i; 00558 00559 if (x && name) { 00560 if ((parse = jit_namespace_name_parse(name, NULL, -1)) > 0) { 00561 for (i = 0; i < parse; i++) { 00562 jit_namespace_name_parse(name, &newname, i); 00563 jit_linklist_findfirst(jit_object_method(ns, gensym("getlist")), &o, jit_namespace_find_name, newname); 00564 if (o && (jit_namespace_data_ob_sym(o) == _jit_sym_jit_namespace || 00565 jit_object_method(jit_object_method(o, _jit_sym_getdata), _jit_sym_class_jit_namespace))) 00566 { 00567 ns = o->data; 00568 } 00569 else return NULL; 00570 } 00571 jit_namespace_name_parse(name, &newname, i); 00572 jit_linklist_findfirst(jit_object_method(ns, gensym("getlist")), &o, jit_namespace_find_name, newname); 00573 if (o) { 00574 return o; 00575 } 00576 } 00577 else { 00578 jit_linklist_findfirst(jit_object_method(ns, gensym("getlist")), &o, jit_namespace_find_name, newname); 00579 if (o) 00580 return o; 00581 } 00582 } 00583 00584 return NULL; 00585 } 00586 00587 void *jit_namespace_resolve_raw(t_jit_namespace *x, t_symbol *name) 00588 { 00589 t_jit_namespace_data *o; 00590 00591 if (x) { 00592 if (o = jit_namespace_resolve_name(x, name)) 00593 return o->data; 00594 } 00595 return NULL; 00596 } 00597 00598 t_jit_err jit_namespace_resolve_char(t_jit_namespace *x, t_symbol *name, long *size, uchar **data) 00599 { 00600 t_jit_namespace_data *o; 00601 t_atom *av = NULL; 00602 long ac = 0; 00603 t_jit_err err = JIT_ERR_NONE; 00604 long i; 00605 00606 if (x) { 00607 if (o = jit_namespace_resolve_name(x, name)) { 00608 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00609 method m; 00610 void *attr = o->data; 00611 00612 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 00613 if (!ac) 00614 return JIT_ERR_NONE; 00615 if (*data = jit_getbytes(sizeof(uchar) * ac)) { 00616 for (i = 0; i < ac; i++) { 00617 *(*data + i) = jit_atom_getlong(av + i); 00618 } 00619 *size = ac; 00620 jit_freebytes(av, sizeof(t_atom) * ac); 00621 } 00622 else { 00623 *size = 0; 00624 err = JIT_ERR_OUT_OF_MEM; 00625 } 00626 } 00627 else err = JIT_ERR_OUT_OF_MEM; 00628 } 00629 else { 00630 jit_object_post((t_object *)x,"error: can't resolve object"); 00631 err = JIT_ERR_GENERIC; 00632 } 00633 } 00634 else err = JIT_ERR_INVALID_PTR; 00635 } 00636 else err = JIT_ERR_INVALID_PTR; 00637 00638 return err; 00639 } 00640 00641 t_jit_err jit_namespace_resolve_long(t_jit_namespace *x, t_symbol *name, long *size, long **data) 00642 { 00643 t_jit_namespace_data *o; 00644 t_atom *av = NULL; 00645 long ac = 0; 00646 t_jit_err err = JIT_ERR_NONE; 00647 long i; 00648 00649 if (x) { 00650 if (o = jit_namespace_resolve_name(x, name)) { 00651 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00652 method m; 00653 void *attr = o->data; 00654 00655 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 00656 if (!ac) 00657 return JIT_ERR_NONE; 00658 if (*data = jit_getbytes(sizeof(long) * ac)) { 00659 for (i = 0; i < ac; i++) { 00660 *(*data + i) = jit_atom_getlong(av + i); 00661 } 00662 *size = ac; 00663 jit_freebytes(av, sizeof(t_atom) * ac); 00664 } 00665 else { 00666 *size = 0; 00667 err = JIT_ERR_OUT_OF_MEM; 00668 } 00669 } 00670 else err = JIT_ERR_OUT_OF_MEM; 00671 } 00672 else { 00673 jit_object_post((t_object *)x,"error: can't resolve object"); 00674 err = JIT_ERR_GENERIC; 00675 } 00676 } 00677 else err = JIT_ERR_INVALID_PTR; 00678 } 00679 else err = JIT_ERR_INVALID_PTR; 00680 00681 return err; 00682 } 00683 00684 t_jit_err jit_namespace_resolve_float(t_jit_namespace *x, t_symbol *name, long *size, float **data) 00685 { 00686 t_jit_namespace_data *o; 00687 t_atom *av = NULL; 00688 long ac = 0; 00689 t_jit_err err = JIT_ERR_NONE; 00690 long i; 00691 00692 if (x) { 00693 if (o = jit_namespace_resolve_name(x, name)) { 00694 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00695 method m; 00696 void *attr = o->data; 00697 00698 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 00699 if (!ac) 00700 return JIT_ERR_NONE; 00701 if (*data = jit_getbytes(sizeof(float) * ac)) { 00702 for (i = 0; i < ac; i++) { 00703 *(*data + i) = jit_atom_getfloat(av + i); 00704 } 00705 *size = ac; 00706 jit_freebytes(av, sizeof(t_atom) * ac); 00707 } 00708 else { 00709 *size = 0; 00710 err = JIT_ERR_OUT_OF_MEM; 00711 } 00712 } 00713 else err = JIT_ERR_OUT_OF_MEM; 00714 } 00715 else { 00716 jit_object_post((t_object *)x,"error: can't resolve object"); 00717 err = JIT_ERR_GENERIC; 00718 } 00719 } 00720 else err = JIT_ERR_INVALID_PTR; 00721 } 00722 else err = JIT_ERR_INVALID_PTR; 00723 00724 return err; 00725 } 00726 00727 t_jit_err jit_namespace_resolve_double(t_jit_namespace *x, t_symbol *name, long *size, double **data) 00728 { 00729 t_jit_namespace_data *o; 00730 t_atom *av = NULL; 00731 long ac = 0; 00732 t_jit_err err = JIT_ERR_NONE; 00733 long i; 00734 00735 if (x) { 00736 if (o = jit_namespace_resolve_name(x, name)) { 00737 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00738 method m; 00739 void *attr = o->data; 00740 00741 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 00742 if (!ac) 00743 return JIT_ERR_NONE; 00744 if (*data = jit_getbytes(sizeof(double) * ac)) { 00745 for (i = 0; i < ac; i++) { 00746 *(*data + i) = jit_atom_getfloat(av + i); 00747 } 00748 *size = ac; 00749 jit_freebytes(av, sizeof(t_atom) * ac); 00750 } 00751 else { 00752 *size = 0; 00753 err = JIT_ERR_OUT_OF_MEM; 00754 } 00755 } 00756 else err = JIT_ERR_OUT_OF_MEM; 00757 } 00758 else { 00759 jit_object_post((t_object *)x,"error: can't resolve object"); 00760 err = JIT_ERR_GENERIC; 00761 } 00762 } 00763 else err = JIT_ERR_INVALID_PTR; 00764 } 00765 else err = JIT_ERR_INVALID_PTR; 00766 00767 return err; 00768 } 00769 00770 t_jit_err jit_namespace_resolve_symbol(t_jit_namespace *x, t_symbol *name, long *size, t_symbol ***data) 00771 { 00772 t_jit_namespace_data *o; 00773 t_atom *av = NULL; 00774 long ac = 0; 00775 t_jit_err err = JIT_ERR_NONE; 00776 long i; 00777 00778 if (x) { 00779 if (o = jit_namespace_resolve_name(x, name)) { 00780 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00781 method m; 00782 void *attr = o->data; 00783 00784 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 00785 if (!ac) 00786 return JIT_ERR_NONE; 00787 if (*data = jit_getbytes(sizeof(t_symbol *) * ac)) { 00788 for (i = 0; i < ac; i++) { 00789 *(*data + i) = jit_atom_getsym(av + i); 00790 } 00791 *size = ac; 00792 jit_freebytes(av, sizeof(t_atom) * ac); 00793 } 00794 else { 00795 *size = 0; 00796 err = JIT_ERR_OUT_OF_MEM; 00797 } 00798 } 00799 else err = JIT_ERR_OUT_OF_MEM; 00800 } 00801 else { 00802 jit_object_post((t_object *)x,"error: can't resolve object"); 00803 err = JIT_ERR_GENERIC; 00804 } 00805 } 00806 else err = JIT_ERR_INVALID_PTR; 00807 } 00808 else err = JIT_ERR_INVALID_PTR; 00809 00810 return err; 00811 } 00812 00813 t_jit_err jit_namespace_resolve_atom(t_jit_namespace *x, t_symbol *name, long *size, t_atom **data) 00814 { 00815 t_jit_namespace_data *o; 00816 t_atom *av = NULL; 00817 long ac = 0; 00818 t_jit_err err = JIT_ERR_NONE; 00819 long i; 00820 00821 if (x) { 00822 if (o = jit_namespace_resolve_name(x, name)) { 00823 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00824 method m; 00825 void *attr = o->data; 00826 00827 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 00828 if (!ac) 00829 return JIT_ERR_NONE; 00830 if (*data = jit_getbytes(sizeof(t_atom) * ac)) { 00831 for (i = 0; i < ac; i++) { 00832 *(*data + i) = *(av + i); 00833 } 00834 *size = ac; 00835 jit_freebytes(av, sizeof(t_atom) * ac); 00836 } 00837 else { 00838 *size = 0; 00839 err = JIT_ERR_OUT_OF_MEM; 00840 } 00841 } 00842 else err = JIT_ERR_OUT_OF_MEM; 00843 } 00844 else { 00845 jit_object_post((t_object *)x,"error: can't resolve object"); 00846 err = JIT_ERR_GENERIC; 00847 } 00848 } 00849 else err = JIT_ERR_INVALID_PTR; 00850 } 00851 else err = JIT_ERR_INVALID_PTR; 00852 00853 return err; 00854 } 00855 00856 t_jit_err jit_namespace_resolve_object(t_jit_namespace *x, t_symbol *name, long *size, void ***data) 00857 { 00858 t_jit_namespace_data *o; 00859 t_atom *av = NULL; 00860 long ac = 0; 00861 t_jit_err err = JIT_ERR_NONE; 00862 long i; 00863 00864 if (x) { 00865 if (o = jit_namespace_resolve_name(x, name)) { 00866 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00867 method m; 00868 void *attr = o->data; 00869 00870 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 00871 if (!ac) 00872 return JIT_ERR_NONE; 00873 if (*data = jit_getbytes(sizeof(void *) * ac)) { 00874 for (i = 0; i < ac; i++) { 00875 *(*data + i) = jit_atom_getobj(av + i); 00876 } 00877 *size = ac; 00878 jit_freebytes(av, sizeof(t_atom) * ac); 00879 } 00880 else { 00881 *size = 0; 00882 err = JIT_ERR_OUT_OF_MEM; 00883 } 00884 } 00885 else err = JIT_ERR_OUT_OF_MEM; 00886 } 00887 else { 00888 jit_object_post((t_object *)x,"error: can't resolve object"); 00889 err = JIT_ERR_GENERIC; 00890 } 00891 } 00892 else err = JIT_ERR_INVALID_PTR; 00893 } 00894 else err = JIT_ERR_INVALID_PTR; 00895 00896 return err; 00897 } 00898 00899 t_jit_err jit_namespace_resolve_pointer(t_jit_namespace *x, t_symbol *name, long *size, void ***data) 00900 { 00901 t_jit_namespace_data *o; 00902 t_atom *av = NULL; 00903 long ac = 0; 00904 t_jit_err err = JIT_ERR_NONE; 00905 long i; 00906 00907 if (x) { 00908 if (o = jit_namespace_resolve_name(x, name)) { 00909 if (jit_object_method(o->data, _jit_sym_class_jit_attribute)) { 00910 method m; 00911 void *attr = o->data; 00912 00913 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 00914 if (!ac) 00915 return JIT_ERR_NONE; 00916 if (*data = jit_getbytes(sizeof(void *) * ac)) { 00917 for (i = 0; i < ac; i++) { 00918 *(*data + i) = jit_atom_getobj(av + i); 00919 } 00920 *size = ac; 00921 jit_freebytes(av, sizeof(t_atom) * ac); 00922 } 00923 else { 00924 *size = 0; 00925 err = JIT_ERR_OUT_OF_MEM; 00926 } 00927 } 00928 else err = JIT_ERR_OUT_OF_MEM; 00929 } 00930 else { 00931 jit_object_post((t_object *)x,"error: can't resolve object"); 00932 err = JIT_ERR_GENERIC; 00933 } 00934 } 00935 else err = JIT_ERR_INVALID_PTR; 00936 } 00937 else err = JIT_ERR_INVALID_PTR; 00938 00939 return err; 00940 } 00941 00942 void *jit_namespace_new(void *reference) 00943 { 00944 t_jit_namespace *x; 00945 00946 if (x = (t_jit_namespace *)jit_object_alloc(_jit_namespace_class)) { 00947 x->reference = reference; 00948 x->list = jit_linklist_new(); 00949 } 00950 return x; 00951 } 00952 00953 void jit_namespace_free(t_jit_namespace *x) 00954 { 00955 jit_object_notify(x, _jit_sym_free, NULL); 00956 jit_object_free(x->list); 00957 } 00958 00959 #pragma mark - 00960 #pragma mark namespace_data 00961 #pragma mark - 00962 00963 void *jit_namespace_data_getdata(t_jit_namespace_data *x) 00964 { 00965 if (x) 00966 return x->data; 00967 return NULL; 00968 } 00969 00970 t_symbol *jit_namespace_data_getname(t_jit_namespace_data *x) 00971 { 00972 if (x) 00973 return x->name; 00974 return _jit_sym_nothing; 00975 } 00976 00977 t_symbol *jit_namespace_data_gettype(t_jit_namespace_data *x) 00978 { 00979 if (x) { 00980 if (jit_object_method(x->data, _jit_sym_class_jit_attribute)) { 00981 return ((t_symbol *)jit_object_method(x->data, _jit_sym_gettype)); 00982 } 00983 else if (((t_jit_object *)x->data)->o_messlist) 00984 return ob_sym(x->data); 00985 } 00986 return _jit_sym_nothing; 00987 } 00988 00989 t_symbol *jit_namespace_data_ob_sym(t_jit_namespace_data *x) 00990 { 00991 if (x) { 00992 if (((t_jit_object *)x->data)->o_messlist) 00993 return ob_sym(x->data); 00994 } 00995 return _jit_sym_nothing; 00996 } 00997 00998 t_jit_err jit_namespace_data_resolve_atom(t_jit_namespace_data *x, long *size, t_atom **data) 00999 { 01000 t_jit_namespace_data *o; 01001 t_atom *av = NULL; 01002 long ac = 0; 01003 t_jit_err err = JIT_ERR_NONE; 01004 long i; 01005 01006 if (x) { 01007 if (jit_object_method(x->data, _jit_sym_class_jit_attribute)) { 01008 method m; 01009 void *attr = x->data; 01010 01011 if (((t_jit_err)jit_object_method(attr, _jit_sym_get, x, &ac, &av)) == JIT_ERR_NONE) { 01012 if (!ac) 01013 return JIT_ERR_NONE; 01014 if (*data = jit_getbytes(sizeof(t_atom) * ac)) { 01015 for (i = 0; i < ac; i++) { 01016 *(*data + i) = *(av + i); 01017 } 01018 *size = ac; 01019 jit_freebytes(av, sizeof(t_atom) * ac); 01020 } 01021 else { 01022 *size = 0; 01023 err = JIT_ERR_OUT_OF_MEM; 01024 } 01025 } 01026 else err = JIT_ERR_OUT_OF_MEM; 01027 } 01028 else { 01029 jit_object_post((t_object *)x,"error: can't resolve object"); 01030 err = JIT_ERR_GENERIC; 01031 } 01032 } 01033 else err = JIT_ERR_INVALID_PTR; 01034 01035 return err; 01036 } 01037 01038 void jit_namespace_data_data_method(t_jit_namespace_data *x, t_symbol *s, ...) 01039 { 01040 if (((t_jit_object *)x->data)->o_messlist) { 01041 jit_object_method(x->data, s, *((t_stack_splat *)(((char *)(&s))+4))); 01042 } 01043 } 01044 01045 void *jit_namespace_data_new(t_symbol *name, void *data) 01046 { 01047 t_jit_namespace_data *x; 01048 01049 if (x = (t_jit_namespace_data *)jit_object_alloc(_jit_namespace_data_class)) { 01050 x->name = name; 01051 x->data = data; 01052 } 01053 return x; 01054 } 01055 01056 void jit_namespace_data_free(t_jit_namespace_data *x) 01057 { 01058 ; // nada 01059 }
Copyright © 2008, Cycling '74