Max 5 API Reference

jit.max.c

/* 
    jit.max.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
        
*/
#include "jit.common.h"
#include "jit.class.h"
#include "ext_obex.h"

#define JIT_USURP_FLAGS_LOW     0x00000001
#define JIT_USURP_FLAGS_MAX     0x00000002

char *get_data_from_macho_fptr(UInt32   *mfp);
char *get_data_from_macho_fptr(UInt32   *mfp)
{
    char *p=0;
    static long mv=0;
    
    if (!mv) {
        mv = maxversion();
    }
        
    // maxversion hack for improper maxversion reporting in maxmsp 4.6beta      
    if (((mv>=0x0460)||(mv<0x0300)) && (mfp[0]&0xFFFF0000)==0x3D800000)
        p = (char *)(((mfp[0]<<16)&0xFFFF0000) | (mfp[1]&0xFFFF));
    else 
        p = (char *)mfp;
    
    return p;
}

#if TARGET_RT_MAC_MACHO || defined(WIN_VERSION)
#define FCHECK(x) (x)
#else
#define FCHECK(x) ((method)get_data_from_macho_fptr((UInt32 *)x))
#endif

/**
 * @defgroup maxwrapmod Max Wrapper Module
    @ingroup jitter
 */


//re: proxies - 
//need to add the concept of recording inlet number to usurp + defer methods
//this might mean having to allocate additional memory for the defer methods

typedef struct _jit_usurp 
{
    t_jit_object    ob;         //needs to be an object for linklist
    void            *parent;    
    method          m;
    t_symbol        *sym;
    long            flags;
    void            *qelem;
    long            argc;
    t_atom          *argv;
} t_jit_usurp;

typedef struct _max_jit_classex
{
    long            oboffset; //instance byte offset to the obex struct.
    t_jit_linklist  *attrlist;
    t_jit_linklist  *adornmentlist;
} t_max_jit_classex;

typedef struct _max_jit_obex
{
    void        *jitob;
    void        *usurplist;
    void        *proxylist;
    long        inletnumber; //for proxies
    void        *dumpout;
    void        *adornmentlist;
    t_box       *b; // containing box
} t_max_jit_obex;

static long _max_jit_queuestate=0;

long max_jit_queuestate(long state);
long max_jit_getqueuestate(void);

void max_jit_init(void);
void jit_usurp_init(void);
void *jit_usurp_new(void *parent, method m, t_symbol *s, long flags);
void jit_usurp_free(t_jit_usurp *x);
void jit_usurp_method(t_jit_usurp *u, t_symbol *s, short argc, t_atom *argv);
long jit_usurp_symcompare(t_jit_usurp *x, t_symbol *name);
void max_jit_usurp_qfn(void *x);
long max_jit_obex_attr_usercanset(void *x, t_symbol *s);
void *max_jit_obex_attr_method_direct(void *x, t_symbol *s, long ac, t_atom *av);
void max_jit_attrindex(void *x, t_symbol *s, long argc, t_atom *argv);

long jit_attr_symcompare(void *x, t_symbol *name);
long jit_object_attr_usercanset(void *x,t_symbol *s);
void max_jit_defer_method_doit(void *x, t_symbol *s, short argc, t_atom *argv);
void max_jit_object_state_dump(void *x);
void max_jit_object_summary(void *x, t_symbol *s);
void max_jit_object_quickref(void *x, long *numitems, t_symbol **items);

void max_jit_obex_box_set(void *x, void *b);
t_box *max_jit_obex_box_get(void *x);

static void *_jit_usurp_class;

//proxy compatibility
#define proxy_compat_getinlet(x,id) ((fp_proxy_getinlet)?(long)fp_proxy_getinlet(x):(id))
#define proxy_compat_init   (fp_proxy_getinlet = (method)gensym("__proxy_getinlet__")->s_thing)
method fp_proxy_getinlet=0;

// for new max obex/pattr comptibility
void *max_jit_obex_attr_getobject(void *x, t_symbol *s);
void *max_jit_obex_attr_gettarget(void *x, t_symbol *s);
long max_jit_obex_attr_getnames(void *x, long *argc, t_symbol ***argv);

static t_symbol *ps_usercanset,*ps_usercanget,*ps_importattrs,*ps_exportattrs,*ps_exportsummary;
static t_symbol *ps_attr_modified,*ps__Box,*ps_dumpout;
static t_symbol *ps_int,*ps_float;
static t_symbol *ps_attrindex,*ps_getmethodtype,*ps_attributes,*ps_objectname;
static t_symbol *ps_matrixinputcount,*ps_matrixinput,*ps_inmode;
static t_symbol *ps_gettypes,*ps_matrixoutputcount,*ps_matrixoutput;
static t_symbol *ps_array,*ps_message;
static t_symbol *_max_jit_ignorelist[256];
static long _max_jit_ignorecount = 0;

#if TARGET_RT_MAC_MACHO
extern long initialize();
#endif

void jit_max_init(void)
{
    ps_usercanset       = gensym("usercanset");
    ps_usercanget       = gensym("usercanget");
    ps_importattrs      = gensym("importattrs");
    ps_exportattrs      = gensym("exportattrs");
    ps_exportsummary    = gensym("exportsummary");
    
    ps_attr_modified    = gensym("attr_modified");
    ps__Box             = gensym("#B");
    ps_dumpout          = gensym("dumpout");
    ps_int              = gensym("int");
    ps_float            = gensym("float");

    ps_attrindex = gensym("attrindex");
    ps_getmethodtype = gensym("getmethodtype");
    ps_attributes = gensym("attributes");
    ps_objectname = gensym("objectname");
    ps_matrixinputcount = gensym("matrixinputcount");
    ps_matrixinput = gensym("matrixinput");
    ps_inmode = gensym("inmode");

    ps_gettypes = gensym("gettypes");
    ps_matrixoutputcount = gensym("matrixoutputcount");
    ps_matrixoutput = gensym("matrixoutput");

    ps_array = gensym("array");
    ps_message = gensym("message");

    _max_jit_ignorecount = 0;
    _max_jit_ignorelist[_max_jit_ignorecount++] = ps_importattrs;
    _max_jit_ignorelist[_max_jit_ignorecount++] = ps_exportattrs;
    _max_jit_ignorelist[_max_jit_ignorecount++] = ps_exportsummary;
    
    jit_usurp_init();
    proxy_compat_init;
}

void jit_usurp_init(void)
{
    _jit_usurp_class = jit_class_new("jit_usurp",(method)jit_usurp_new,(method)jit_usurp_free,
        sizeof(t_jit_usurp),A_CANT,0L);
        
    if (!_jit_usurp_class) post("couldn't allocate memory for class jit_usurp");
    
    jit_class_addmethod(_jit_usurp_class, (method)jit_usurp_method, "usurp_method", A_CANT, 0L);
    jit_class_register(_jit_usurp_class);
}

void *jit_usurp_new(void *parent, method m, t_symbol *s, long flags)
{
    t_jit_usurp *x;
    
    if (x=(t_jit_usurp *)jit_object_alloc(_jit_usurp_class)) {
        x->parent       = parent;       
        x->m            = m;        
        x->sym          = s;    
        x->flags        = flags;    
        x->qelem        = qelem_new(x,(method)max_jit_usurp_qfn);   
        x->argc         = 0;
        x->argv         = NULL;
    }
    
    return x;
}

void jit_usurp_free(t_jit_usurp *x)
{
    if (x) {
        if (x->qelem) qelem_free(x->qelem); 
        if (x->argc&&x->argv) jit_freebytes(x->argv,sizeof(t_atom)*x->argc);
    }
}

void jit_usurp_method(t_jit_usurp *u, t_symbol *s, short argc, t_atom *argv)
{
    if (u) {
        long i;
        
        //copy args, replacing
        jit_global_critical_enter();
        if (argc&&argv) {
            if ((argc==u->argc)&&u->argv) { //use existing memory
                for (i=0;i<argc;i++) {
                    u->argv[i] = argv[i];
                }
            } else {
                if (u->argc&&u->argv)
                    jit_freebytes(u->argv,sizeof(t_atom)*u->argc);
                if (u->argv=jit_getbytes(sizeof(t_atom)*argc)) {
                    u->argc = argc;
                    for (i=0;i<argc;i++) {
                        u->argv[i] = argv[i];
                    }
                } else {
                    u->argc = 0;
                }
            }
        } else {
            if (u->argc&&u->argv)
                jit_freebytes(u->argv,sizeof(t_atom)*u->argc);
            u->argc = 0;
            u->argv = NULL;
        }
        
        if (max_jit_getqueuestate()==0) {
            if (u->flags&JIT_USURP_FLAGS_LOW) qelem_set(u->qelem);
            else qelem_front(u->qelem);
            jit_global_critical_exit();
        } else {
            jit_global_critical_exit();
            max_jit_usurp_qfn(u);
            //qelem_unset(u->qelem); moved into usurp_qfn
        }
    }
    return;
}

long jit_usurp_symcompare(t_jit_usurp *x, t_symbol *name)
{
    return (name&&(x->sym==name));
}

#pragma mark -
// --------------------------------------------------------------------------------
//

long max_jit_queuestate(long state) 
{
    long rv=_max_jit_queuestate;
    
    _max_jit_queuestate = (state!=0);
    
    return rv;
}

long max_jit_getqueuestate(void)
{
    static char *p_max_preempt = NULL;
    
    if (p_max_preempt == NULL) 
    {
        t_object *max = gensym("max")->s_thing;
        t_class *mclass = object_class(max);
        t_object *attr = class_attr_get(mclass,gensym("overdrive"));
        p_max_preempt = (char *)object_attr_getobj(attr,gensym("optionpointer"));
        //post("p_max_preempt is %x, and set to %d",p_max_preempt,p_max_preempt?*p_max_preempt:0);
    }
    
    // always return true if faking
    if (_max_jit_queuestate) return 1;
    
    // move execution to the queue even if overdrive is off
    if (p_max_preempt&&(!(*p_max_preempt)))
        return !sched_isinpoll();           
    else
        return systhread_ismainthread();
}

#pragma mark -
// --------------------------------------------------------------------------------
//

/**
 * Sets attribute value.
 *
 * @ingroup maxwrapmod
 *
 * @param   x       Max wrapper object pointer
 * @param   s       attribute name
 * @param   ac      atom count
 * @param   av      atom vector
 *
 */
void max_jit_attr_set(void *x, t_symbol *s, short ac, t_atom *av)
{
    t_jit_object *o = max_jit_obex_jitob_get(x);
    t_box *b;
    void *attr;
    
    jit_object_method(o,s,ac,av);
    if (attr = object_attr_get(o,s)) {
        object_notify(x, ps_attr_modified, attr);
        
/*      
        // jb removed; this is redundant and already handled in object_notify()
        if ((b = max_jit_obex_box_get(x)) && ((void *)b != x)) {
            object_notify(b, ps_attr_modified, object_attr_get(o,s));
        }
 */
    }
}


/**
 * Retrieves attribute value.
 *
 * @ingroup maxwrapmod
 *
 * @param   x       Max wrapper object pointer
 * @param   s       attribute name
 * @param   ac      pointer atom count
 * @param   av      pointer atom vector
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_attr_get(void *x, t_symbol *s, long *ac, t_atom **av)
{
    t_jit_err err;
    char tmpstr[256];
    
    sprintf(tmpstr,"%s%s","get",s->s_name); //add get   
    jit_object_method(max_jit_obex_jitob_get(x),gensym(tmpstr),ac,av);

    return JIT_ERR_NONE;
}

/**
 * Retrieves attribute value and sends out dump outlet.
 *
 * @ingroup maxwrapmod
 *
 * @param   x       Max wrapper object pointer
 * @param   s       attribute name
 * @param   argc    argument count (ignored)
 * @param   argv    argument vector (ignored)
 *
 */
void max_jit_attr_getdump(void *x, t_symbol *s, short argc, t_atom *argv)
{
    long ac=0;
    t_atom *av=NULL;
    method f;
    t_jit_err err;
    
    s = gensym(s->s_name+3); //strip get
    if ((err = max_jit_attr_get(x,s,&ac,&av))) {
        jit_error_code(x, err);
    } else {
        if (f=zgetfn(x,ps_dumpout))
            (*f)(x,s,(short)ac,av);
    }
    freebytes(av,sizeof(t_atom)*ac);
}

/**
 * Determines argument offset to first attribute argument.
 *
 * @ingroup maxwrapmod
 *
 * @param   ac  argument count
 * @param   av  argument vector
 *
 * @return  argument offset
 *
 */
long max_jit_attr_args_offset(short ac, t_atom *av)
{
    long i,offset=ac;//no args
    
    if (av) {
        for (i=0;i<ac;i++) {
            if ((av[i].a_type==A_SYM)&&(av[i].a_w.w_sym->s_name[0]=='@')) { 
                offset=i;
                goto out;
            }
        }
    }
out:
    return offset;
}

/**
 * Processes attribtue arguments.
 *
 * @ingroup maxwrapmod
 *
 * @param   x   Max wrapper object pointer
 * @param   ac  argument count
 * @param   av  argument vector
 *
 */
void max_jit_attr_args(void *x, short ac, t_atom *av)
{
    t_symbol *s,*s2 = _jit_sym_nothing,*as;
    long i,j;
    void *o;

    if (av) { //find first
        for (i=0;i<ac;i++) {
            if ((av[i].a_type==A_SYM)&&((s=av[i].a_w.w_sym)->s_name[0]=='@')) { 
                s = gensym(s->s_name+1);
                i++;
                goto pikka;
            }
        }
pikka:  
        j = i;
        while (j<ac) {
            for (;j<ac;j++) {
                if ((av[j].a_type==A_SYM)&&((s2=av[j].a_w.w_sym)->s_name[0]=='@')) {    
                    s2 = gensym(s2->s_name+1);
                    goto pakka;
                }
            }
pakka:
            //try max object first, then jit object if it is a wrapper
            o=max_jit_obex_jitob_get(x);
            if (max_jit_obex_attr_usercanset(x,s)) {
                max_jit_obex_attr_method_direct(x,s,j-i,av+i);
            } else if (o&&jit_object_attr_usercanset(o,s)) {
                jit_object_method(o,s,j-i,av+i);
            } else if (o&&(as=jit_object_method_argsafe_get(o,s))) {
                object_method_typed(o,as,j-i,av+i,NULL);
            } else if (s==ps_attrindex) {
                max_jit_attrindex(x,s,j-i,av+i); 
            } else {
                jit_object_error((t_object *)x,"%s: \"%s\" is not a valid attribute argument",ob_name(x),s->s_name);
            }
            
            i = ++j;
            s = s2;
        }
    }
}

#pragma mark -
// --------------------------------------------------------------------------------
//

void max_jit_defer_method(void *x, t_symbol *s, short argc, t_atom *argv)
{
    //x is a max object ptr
    defer(x,(method)max_jit_defer_method_doit,s,argc,argv);
}

void max_jit_defer_low_method(void *x, t_symbol *s, short argc, t_atom *argv)
{
    //x is a max object ptr
    if (max_jit_getqueuestate()==0)
        defer_low(x,(method)max_jit_defer_method_doit,s,argc,argv);
    else
        max_jit_defer_method_doit(x,s,argc,argv);
}

void max_jit_defer_method_doit(void *x, t_symbol *s, short argc, t_atom *argv)
{
    t_jit_object *o;
        
    //x is a max object ptr
    if (x&&(o=max_jit_obex_jitob_get(x))) {
        jit_object_method(o,s,s,(long)argc,argv);
    }
}

void max_jit_gimme_method(void *x, t_symbol *s, short argc, t_atom *argv)
{
    t_jit_object *o;
    //x is a max object ptr 
    //drat this is not as fast as it could be. won't be as fast for jit_vector
    //need to look into a different caching solution
    if (x&&(o=max_jit_obex_jitob_get(x))) {
        jit_object_method(o,s,s,(long)argc,argv);
    }
}

void max_jit_typed_method(void *x, t_symbol *s, short argc, t_atom *argv)
{
    t_jit_object *o;
        
    //x is a max object ptr
    if (x&&(o=max_jit_obex_jitob_get(x))) {
        typedmess(o,s,argc,argv);
    }
}

void max_jit_usurp_method(void *x, t_symbol *s, short argc, t_atom *argv)
{
    t_jit_usurp *u=NULL;
    long i,savelock;
    extern char inISR;
    t_jit_linklist *usurplist;
    
    //x is a max object ptr
    if (x&&(usurplist=max_jit_obex_usurplist_get(x))) {
        jit_linklist_findfirst(usurplist,(void **)&u,(t_cmpfn)jit_usurp_symcompare,s);
        if (u) {
            jit_usurp_method(u, s, argc, argv);
        } 
    }
    return;
}

void max_jit_usurp_qfn(void *x) 
{ 
    t_jit_usurp *u=x;
    long argc,savelock,i;
    t_atom *argv;

    jit_global_critical_enter();            
    argc = u->argc;
    argv = u->argv;
    u->argc = 0;
    u->argv = NULL;
    //unset incase this was set in the instant between sched dequeue loops
    qelem_unset(u->qelem); 
    jit_global_critical_exit();
    if (u->flags&JIT_USURP_FLAGS_MAX)
        (*(u->m))(u->parent,u->sym,argc,argv);
    else 
        (*(u->m))(max_jit_obex_jitob_get(u->parent),u->sym,argc,argv);
    
    if (argc&&argv)
        jit_freebytes(argv,sizeof(t_atom)*argc);    
}

// could move to another place if needed anywhere else
t_jit_err jit_class_attr_getnames(t_jit_class *x,long *symcount,t_symbol ***symarray);
t_jit_err jit_class_attr_getnames(t_jit_class *x,long *symcount,t_symbol ***symarray)
{
    t_jit_err err=JIT_ERR_GENERIC;
    if (x&&((t_jit_class *)x)->c_attributes) {
        if (!hashtab_getkeys((t_hashtab *)x->c_attributes,symcount,symarray))
            err = JIT_ERR_NONE;
    }
    return err;
}

void max_jit_class_attrlist2methods(void *x)
{
    long i;
    void *o;
    method m;
    t_symbol *s;
    char tmpstr[256];
    long type;
    long symcount=0;
    t_symbol **symarray=NULL;
        
    //x is a t_jit_class ptr
    if (!x)
        return;

    jit_class_attr_getnames(x,&symcount,&symarray);
    
    if (symcount) {
        //symbolarray_sort(symcount,symarray);
        for (i=0;i<symcount;i++) {
            o=class_attr_get(x,symarray[i]);
            s = jit_object_method(o,_jit_sym_getname);
            if (jit_object_method(o,ps_usercanset)) {
                m = jit_object_method(o,_jit_sym_getmethod,_jit_sym_set);
                type = (long) jit_object_method(o,ps_getmethodtype,_jit_sym_set);
                switch (type) {
                case A_DEFER:
                    max_addmethod_defer((method)max_jit_attr_set, s->s_name);
                    break;
                case A_DEFER_LOW:
                    max_addmethod_defer_low((method)max_jit_attr_set, s->s_name);
                    break;
                case A_USURP:
                    max_addmethod_usurp((method)max_jit_attr_set, s->s_name);
                    break;
                case A_USURP_LOW:
                    max_addmethod_usurp_low((method)max_jit_attr_set, s->s_name);
                    break;
                case A_GIMME:
                    addmess((method)max_jit_attr_set, s->s_name, A_GIMME, 0);
                    break;
                }               
            }
            if (jit_object_method(o,ps_usercanget)) {
                m = jit_object_method(o,_jit_sym_getmethod,_jit_sym_get);
                type = (long) jit_object_method(o,ps_getmethodtype,_jit_sym_get);
                sprintf(tmpstr,"%s%s","get",s->s_name);
                switch (type) {
                case A_DEFER:
                    max_addmethod_defer((method)max_jit_attr_getdump, tmpstr);
                    break;
                case A_DEFER_LOW:
                    max_addmethod_defer_low((method)max_jit_attr_getdump, tmpstr);
                    break;
                case A_USURP:
                    max_addmethod_usurp((method)max_jit_attr_getdump, tmpstr);
                    break;
                case A_USURP_LOW:
                    max_addmethod_usurp_low((method)max_jit_attr_getdump, tmpstr);
                    break;
                case A_GIMME:
                    addmess((method)max_jit_attr_getdump, tmpstr, A_GIMME, 0);
                    break;
                }
            }
        }
        if (symarray)
            freebytes((char *)symarray,symcount*sizeof(t_symbol *));
    }
}

void max_jit_class_addmethods(void *x)
{
    t_messlist *m;
    t_symbol *s;
    long type,i,ignore;
        
    //x is a t_jit_class ptr
    if (x) {
        m = (((t_jit_class *)x)->c_messlist)+1; 
        while (m->m_sym){
            ignore = FALSE;
            for (i=0;!ignore&&i<_max_jit_ignorecount;i++) {
                if (m->m_sym==_max_jit_ignorelist[i])
                    ignore = TRUE;
            }
            if (!ignore) {
                type = m->m_type[0];
                switch (type) {
                case A_CANT:
                    break;
                case A_DEFER:
                    addmess((method)max_jit_defer_method, m->m_sym->s_name, A_GIMME, 0);
                    break;
                case A_DEFER_LOW:
                    addmess((method)max_jit_defer_low_method, m->m_sym->s_name, A_GIMME, 0);
                    break;
                case A_USURP:
                    addmess((method)max_jit_usurp_method, m->m_sym->s_name, A_GIMME, 0);
                    break;
                case A_USURP_LOW:
                    addmess((method)max_jit_usurp_method, m->m_sym->s_name, A_GIMME, 0);
                    break;
                case A_GIMME:
                    addmess((method)max_jit_gimme_method, m->m_sym->s_name, A_GIMME, 0);
                    break;
                default: 
                    addmess((method)max_jit_typed_method, m->m_sym->s_name, A_GIMME, 0);
                    break;
                }
            }
            m++;
        }
        max_jit_class_attrlist2methods(x);
    }
}

/**
 * Adds standard Jitter methods, as well as public methods and attributes of the specified Jitter class.
 * This includes the following public methods: getattributes, getstate, summary, 
 * importattrs, exportattrs; and the following private methods: dumpout, quickref,
 * attr_getnames, attr_get, attr_gettarget, and attrindex. 
 * 
 * @ingroup maxwrapmod
 *
 * @param   mclass  Max wrapper class pointer
 * @param   jclass  jitter class pointer
 * @param   flags   reserved for future use (currently ignored)
 *
 */
void max_jit_classex_standard_wrap(void *mclass, void *jclass, long flags)
{
    if (jclass)
        max_jit_class_addmethods(jclass);
    max_addmethod_defer_low((method)max_jit_object_attr_dump,   "getattributes");
    max_addmethod_defer_low((method)max_jit_object_state_dump,  "getstate");
    max_addmethod_defer_low((method)max_jit_object_summary,     "summary");
    max_addmethod_defer_low((method)jit_object_importattrs,     "importattrs");
    max_addmethod_defer_low((method)jit_object_exportattrs,     "exportattrs");
    max_addmethod_defer_low((method)jit_object_exportsummary,   "exportsummary");
    
    addmess((method)max_jit_obex_dumpout,           "dumpout",          A_CANT,0);
    addmess((method)max_jit_object_quickref,        "quickref",         A_CANT,0);
    addmess((method)max_jit_obex_attr_getnames,     "attr_getnames",    A_CANT,0);
    addmess((method)max_jit_obex_attr_getobject,    "attr_get",         A_CANT,0);
    addmess((method)max_jit_obex_attr_gettarget,    "attr_gettarget",   A_CANT,0);
    addmess((method)max_jit_attrindex,              "attrindex",        A_CANT,0);
    
}

void max_jit_attrindex(void *x, t_symbol *s, long argc, t_atom *argv)
{
    t_atom *av=NULL,*av2=NULL;
    long i,ac=0;
    t_symbol *attrname=_jit_sym_nothing;
    long index=0;
    t_atom val;
        
    jit_atom_arg_getsym(&attrname,0,argc,argv);
    jit_atom_arg_getlong(&index,1,argc,argv);
    if (argc>2)
        val = argv[2];
    else 
        jit_atom_setlong(&val,0);
    
    if (max_jit_obex_attr_get(x,attrname,&ac,&av)) {
        if (max_jit_attr_get(x,attrname,&ac,&av))
            goto out;
    }
    if (index>(ac-1)) {
        //allocate new args to increase size, padding with zeros?
        av2=jit_getbytes(sizeof(t_atom)*index+1);
        for (i=0;i<ac;i++)
            av2[i] = av[i];
        for (;i<index+1;i++)
            jit_atom_setlong(av+i,0);
        if (ac&&av)
            jit_freebytes(av,sizeof(t_atom)*ac);
        ac = index+1;
        av = av2;
    }   
    if (ac&&av) 
        av[index] = val;
    typedmess(x,attrname,ac,av);
out:    
    if (ac&&av)
        jit_freebytes(av,sizeof(t_atom)*ac);
}

//some functions for adding usurp stuff to max(not jit) objects(sort of a hack)
void max_defer_method(void *x, t_symbol *s, long argc, t_atom *argv)
{
    char    tmpstr[256];
    method  m;
    
    sprintf(tmpstr,"%s_defer",s->s_name);
    if (m=zgetfn(x,gensym(tmpstr))) defer(x,(method)m,s,argc,argv); 
//  else jit_object_error((t_object *)x,"%s: defer method not present", ob_sym(x)->s_name);
}

/**
 * Adds method to Max class that calls defer rather than the method directly.
 * To prevent sequencing problems which arize through the use of defer, rather than defer_low,
 * you should instead use the max_addmethod_defer_low function.
 *
 * @ingroup maxwrapmod
 *
 * @param   m   method (function pointer)
 * @param   s   method name
 *
 */
void max_addmethod_defer(method m, char *s)
{
    char     tmpstr[256];
    
    sprintf(tmpstr,"%s_defer",s);
    addmess((method)max_defer_method, s, A_GIMME, 0);
    addmess((method)m, tmpstr, A_CANT, 0);
}

void max_defer_low_method(void *x, t_symbol *s, long argc, t_atom *argv)
{
    char    tmpstr[256];
    method  m;
    
    sprintf(tmpstr,"%s_defer",s->s_name);
    if (m=zgetfn(x,gensym(tmpstr))) {
        if (max_jit_getqueuestate()==0)
            defer_low(x,(method)m,s,argc,argv); 
        else
            (*m)(x,s,argc,argv);
    }
    //else jit_object_error((t_object *)x,"%s: defer method not present", ob_sym(x)->s_name);
}

/**
 * Adds method to Max class that calls defer_low rather than the method directly.
 * 
 * @ingroup maxwrapmod
 *
 * @param   m   method (function pointer)
 * @param   s   method name
 *
 */
void max_addmethod_defer_low(method m, char *s)
{
    char     tmpstr[256];

    sprintf(tmpstr,"%s_defer",s);
    addmess((method)max_defer_low_method, s, A_GIMME, 0);
    addmess((method)m, tmpstr, A_CANT, 0);
}

/**
 * Adds method to Max class that uses the usurp mechanism to execute method at low priority without backlog.
 * Equivalent to max_addmethod_usurp_low function.
 * 
 * @ingroup maxwrapmod
 *
 * @param   m   method (function pointer)
 * @param   s   method name
 *
 */
void max_addmethod_usurp(method m, char *s)
{
    char     tmpstr[256];
    
    sprintf(tmpstr,"%s_usurp",s);
    addmess((method)max_jit_usurp_method, s, A_GIMME, 0);
    addmess((method)m, tmpstr, A_CANT, 0);
}

/**
 * Adds method to Max class that uses the usurp mechanism to execute method at low priority without backlog.
 * 
 * @ingroup maxwrapmod
 *
 * @param   m   method (function pointer)
 * @param   s   method name
 *
 */
void max_addmethod_usurp_low(method m, char *s)
{
    char     tmpstr[256];
    
    sprintf(tmpstr,"%s_usurp_low",s);
    addmess((method)max_jit_usurp_method, s, A_GIMME, 0);
    addmess((method)m, tmpstr, A_CANT, 0);
}

void max_jit_object_attr_dump(void *x)
{
    t_jit_linklist *attrlist;
    short size,i,j = 0;
    t_symbol *name;
    t_jit_object *o,*jitob;
    t_atom  a[256]; 
    method f;
    long symcount=0;
    t_symbol **symarray=NULL;
        
    if (!x)
        return;

    if (attrlist = max_jit_obex_attrlist_get(x)){
        size = (long) jit_object_method(attrlist,_jit_sym_getsize);
        for (i=0;i<size;i++) {
            if (o=jit_object_method(attrlist,_jit_sym_getindex,i)) {
                
                if (jit_object_method(o,ps_usercanset) ||
                    jit_object_method(o,ps_usercanget)) 
                {
                    if (name = jit_object_method(o,_jit_sym_getname)) {
                        a[j].a_type    = A_SYM;
                        a[j].a_w.w_sym = name;
                        j++;
                    }
                }
            } 
        }
    }
    jitob = max_jit_obex_jitob_get(x);
    if (jitob&&!object_attr_getnames(jitob,&symcount,&symarray)) 
    {
        symbolarray_sort(symcount,symarray);
        for (i=0;i<symcount;i++) {
            if (o=object_attr_get(jitob,symarray[i])) {         
                if (jit_object_method(o,ps_usercanset) ||
                    jit_object_method(o,ps_usercanget)) 
                {
                    if (name = jit_object_method(o,_jit_sym_getname)) {
                        a[j].a_type    = A_SYM;
                        a[j].a_w.w_sym = name;
                        j++;
                    }
                }
            } 
        }
    }
    if (symarray)
        freebytes((char *)symarray,symcount*sizeof(t_symbol *));

    max_jit_obex_dumpout(x, ps_attributes, j, a);
}

void max_jit_object_state_dump(void *x)
{
    t_jit_linklist *attrlist;
    short size,i;
    t_symbol *name;
    t_jit_object *o,*jitob;
    t_atom  *av = NULL;
    long ac = 0;
    long symcount=0;
    t_symbol **symarray=NULL;
    
    if (attrlist = max_jit_obex_attrlist_get(x)){
        size = (long) jit_object_method(attrlist,_jit_sym_getsize);
        for (i=0;i<size;i++) {
            if (o=jit_object_method(attrlist,_jit_sym_getindex,i)) {
                
                if (jit_object_method(o,ps_usercanget)) {
                    if (name = jit_object_method(o,_jit_sym_getname)) {
                        max_jit_obex_attr_get(x,name,&ac,&av);
                        max_jit_obex_dumpout(x,name,ac,av);
                        freebytes(av,sizeof(t_atom)*ac);
                        ac=0;av=NULL;
                    }
                }
            } 
        }
    }
    jitob = max_jit_obex_jitob_get(x);
    if (jitob&&!object_attr_getnames(jitob,&symcount,&symarray)) 
    {
        symbolarray_sort(symcount,symarray);
        for (i=0;i<symcount;i++) {
            if (o=object_attr_get(jitob,symarray[i])) {         
                if  (jit_object_method(o,ps_usercanget)) { 
                    if (name = jit_object_method(o,_jit_sym_getname)) {
                        max_jit_attr_get(x,name,&ac,&av);
                        max_jit_obex_dumpout(x,name,ac,av);
                        freebytes(av,sizeof(t_atom)*ac);
                        ac=0;av=NULL;
                    }
                }
            } 
        }
    }
    if (symarray)
        freebytes((char *)symarray,symcount*sizeof(t_symbol *));
}

t_symbol *jit2maxtype(t_symbol *s);
t_symbol *jit2maxtype(t_symbol *s)
{
    if (s==_jit_sym_char) {
        return ps_int;
    } else  if (s==_jit_sym_long) {
        return ps_int;
    } else if (s==_jit_sym_float32) {
        return ps_float;
    } else if (s==_jit_sym_float64) {
        return ps_float;
    } else {
        return s;
    }
}

long max_jit_method_is_attr(void *x, t_symbol *s)
{
    t_jit_linklist *attrlist;
    t_jit_object *attr,*o;
    
    if (x) {
        if ((s->s_name[0]=='g')&&
            (s->s_name[1]=='e')&&
            (s->s_name[2]=='t'))
        {
            s = gensym(s->s_name+3); //strip get    
            if (attrlist=max_jit_obex_attrlist_get(x)) {
                jit_linklist_findfirst(attrlist,(void **)&attr,(t_cmpfn)jit_attr_symcompare,s);
                if (attr) return TRUE;
            }
            if ((o=max_jit_obex_jitob_get(x))&&(attr=jit_object_attr_get(o,s))) {
                return TRUE;
            }
        } else {
            if (attrlist=max_jit_obex_attrlist_get(x)) {
                jit_linklist_findfirst(attrlist,(void **)&attr,(t_cmpfn)jit_attr_symcompare,s);
                if (attr) return TRUE;
            }
            if ((o=max_jit_obex_jitob_get(x))&&(attr=jit_object_attr_get(o,s))) {
                return TRUE;
            }
        }   
    }
    return FALSE;
}

void max_jit_object_summary(void *x, t_symbol *s)
{
    t_jit_linklist *attrlist;
    short size,i,j;
    t_symbol *tmpsym;
    t_jit_object *o,*jitob;
    t_atom  a[256],*av;
    long ac,ac2=0;
    t_jit_class *jclass;
    t_messlist *mess;
    void *mop,*ioproc;
    long inputcount,outputcount;
    long symcount=0;
    t_symbol **symarray=NULL;

    //object name
    ac = 2;
    jit_atom_setsym(a,ps_objectname);
    jit_atom_setsym(a+1,ob_sym(x));
    max_jit_obex_dumpout(x,s,ac,a);

    jclass = jit_object_class(max_jit_obex_jitob_get(x));
    
    //mop info
    if (jclass&&(mop=jit_class_adornment_get(jclass,_jit_sym_jit_mop))) {
        ac = 2;
        jit_atom_setsym(a,ps_matrixinputcount);
        jit_atom_setlong(a+1,inputcount=jit_attr_getlong(mop,_jit_sym_inputcount));
        max_jit_obex_dumpout(x,s,ac,a);     
        if (inputcount>=2) {
            for (i=2;i<=inputcount;i++) {
                if (o=jit_object_method(mop,_jit_sym_getinput,i)) {
                    ac = 11;
                    jit_atom_setsym(a,ps_matrixinput);
                    jit_atom_setsym(a+1,jit_attr_getsym(o,_jit_sym_ioname));
                    jit_atom_setsym(a+2,_jit_sym_planelink);
                    jit_atom_setlong(a+3,jit_attr_getlong(o,_jit_sym_planelink));
                    jit_atom_setsym(a+4,_jit_sym_typelink);
                    jit_atom_setlong(a+5,jit_attr_getlong(o,_jit_sym_typelink));
                    jit_atom_setsym(a+6,_jit_sym_dimlink);
                    jit_atom_setlong(a+7,jit_attr_getlong(o,_jit_sym_dimlink));
                    jit_atom_setsym(a+8,ps_inmode);
                    ioproc = jit_object_method(o,_jit_sym_getioproc);
                    tmpsym = jit_mop_ioproc_tosym(ioproc);
                    jit_atom_setsym(a+9,tmpsym);
                    jit_atom_setsym(a+10,_jit_sym_types);
                    jit_object_method(o,ps_gettypes,&ac2,&av);
                    for (j=0;j<ac2;j++) {
                        *(a+11+j) = av[j];
                    }
                    ac += ac2;
                    max_jit_obex_dumpout(x,s,ac,a); 
                    freebytes(av,sizeof(t_atom)*ac2);
                    ac2=0;av=NULL;
                }
            }
        }
        ac = 2;
        jit_atom_setsym(a,ps_matrixoutputcount);
        jit_atom_setlong(a+1,outputcount=jit_attr_getlong(mop,_jit_sym_outputcount));
        max_jit_obex_dumpout(x,s,ac,a);
        if (outputcount>=1) {
            for (i=1;i<=outputcount;i++) {
                if (o=jit_object_method(mop,_jit_sym_getoutput,i)) {
                    ac = 9;
                    jit_atom_setsym(a,ps_matrixoutput);
                    jit_atom_setsym(a+1,jit_attr_getsym(o,_jit_sym_ioname));
                    jit_atom_setsym(a+2,_jit_sym_planelink);
                    jit_atom_setlong(a+3,jit_attr_getlong(o,_jit_sym_planelink));
                    jit_atom_setsym(a+4,_jit_sym_typelink);
                    jit_atom_setlong(a+5,jit_attr_getlong(o,_jit_sym_typelink));
                    jit_atom_setsym(a+6,_jit_sym_dimlink);
                    jit_atom_setlong(a+7,jit_attr_getlong(o,_jit_sym_dimlink));
                    jit_object_method(o,ps_gettypes,&ac2,&av);
                    jit_atom_setsym(a+8,_jit_sym_types);
                    for (j=0;j<ac2;j++) {
                        *(a+9+j) = av[j];
                    }
                    ac += ac2;
                    max_jit_obex_dumpout(x,s,ac,a); 
                    freebytes(av,sizeof(t_atom)*ac2);
                    ac2=0;av=NULL;
                }
            }
        }       
    }

    //attributes:
    //max object
    if (attrlist = max_jit_obex_attrlist_get(x)){
        size = (long) jit_object_method(attrlist,_jit_sym_getsize);
        for (i=0;i<size;i++) {
            if (o=jit_object_method(attrlist,_jit_sym_getindex,i)) {
                if ((long)jit_object_method(o,ps_usercanget)||
                    (long)jit_object_method(o,ps_usercanset))
                {
                    ac = 7;
                    jit_atom_setsym(a,_jit_sym_jit_attribute);
                    jit_atom_setsym(a+1,jit_object_method(o,_jit_sym_getname));
                    jit_atom_setsym(a+2,_jit_sym_get);
                    jit_atom_setlong(a+3,(long)jit_object_method(o,ps_usercanget));
                    jit_atom_setsym(a+4,_jit_sym_set);
                    jit_atom_setlong(a+5,(long)jit_object_method(o,ps_usercanset));
                    jit_atom_setsym(a+6,jit2maxtype(jit_object_method(o,_jit_sym_gettype)));
                    if (jit_object_classname(o)==_jit_sym_jit_attr_offset_array) {              
                        jit_atom_setsym(a+7,ps_array);
                        jit_atom_setlong(a+8,(long)jit_object_method(o,_jit_sym_getsize));
                        ac = 9;
                    }
                    max_jit_obex_dumpout(x,s,ac,a);     
                }
            } 
        }
    }
    //jit object
    jitob = max_jit_obex_jitob_get(x);
    if (jitob&&!object_attr_getnames(jitob,&symcount,&symarray)) 
    {
        symbolarray_sort(symcount,symarray);
        for (i=0;i<symcount;i++) {
            if (o=object_attr_get(jitob,symarray[i])) {         
                if ((long)jit_object_method(o,ps_usercanget)||
                    (long)jit_object_method(o,ps_usercanset))
                {
                    ac = 7;
                    jit_atom_setsym(a,_jit_sym_jit_attribute);
                    jit_atom_setsym(a+1,jit_object_method(o,_jit_sym_getname));
                    jit_atom_setsym(a+2,_jit_sym_get);
                    jit_atom_setlong(a+3,(long)jit_object_method(o,ps_usercanget));
                    jit_atom_setsym(a+4,_jit_sym_set);
                    jit_atom_setlong(a+5,(long)jit_object_method(o,ps_usercanset));
                    jit_atom_setsym(a+6,jit2maxtype(jit_object_method(o,_jit_sym_gettype)));
                    if (jit_object_classname(o)==_jit_sym_jit_attr_offset_array) {              
                        jit_atom_setsym(a+7,ps_array);
                        jit_atom_setlong(a+8,(long)jit_object_method(o,_jit_sym_getsize));
                        ac = 9;
                    }
                    max_jit_obex_dumpout(x,s,ac,a);     
                }
            } 
        }
    }
    if (symarray)
        freebytes((char *)symarray,symcount*sizeof(t_symbol *));
    
    //methods
    //max object, but first check if attribute
    if (mess = ob_messlist(x)) {
        mess++;
        while (mess->m_sym) {
            if (!max_jit_method_is_attr(x,mess->m_sym)) {
                if (mess->m_type[0]!=A_CANT) {  
                    ac = 2;
                    jit_atom_setsym(a,ps_message);
                    jit_atom_setsym(a+1,mess->m_sym);
                    max_jit_obex_dumpout(x,s,ac,a);     
                }
            }
            mess++;
        } 
    }
}


static char *messlist_argstring(char *types);
static char *messlist_argstring(char *types)
{
    static char args[100];
    short out,i,comma;
    
    if (types[0] == A_NOTHING) {
        args[0] = 0;
        return (args);
    }
    args[0] = '[';
    out = 1;
    for (i=0; types[i]; i++) {
        comma = 1;
        switch (types[i]) {
            case A_LONG:
                strcpy(args+out,"int");
                break;
            case A_DEFLONG:
                strcpy(args+out,"int (0)");
                break;
            case A_FLOAT:
                strcpy(args+out,"float");
                break;
            case A_DEFFLOAT:
                strcpy(args+out,"float (0.0)");
                break;
            case A_SYM:
            case A_DEFSYM:
                strcpy(args+out,"symbol");
                break;
            case A_GIMME:
                strcpy(args+out,"variable");
                break;
            default:
                comma = 0;
                break;
        }
        out = strlen(args);
        if (comma && types[i+1]) {
            strcpy(args+out,", ");
            out = strlen(args);
        }
    }
    args[out++] = ']';
    args[out] = 0;
    return (args);
}

long quickref_symcompare(t_symbol *s1,t_symbol *s2);
long quickref_symcompare(t_symbol *s1,t_symbol *s2)
{
    return strcmp(s1->s_name,s2->s_name)<=0;
}

#define QUICKREF_MAXMENU 256
#define QUICKREF_ATTR_VALUE 

void max_jit_object_quickref(void *x, long *numitems, t_symbol **items)
{
    t_jit_linklist *attrlist;
    long size,i,j,canget,canset;
    t_symbol *namesym,*typesym;
    t_jit_object *o,*jitob;
    char s[256],s2[256];
    t_jit_class *jclass;
    t_messlist *mess;
    t_jit_object *sortlist=NULL;
    t_symbol *ps_assist=gensym("assist");
    t_symbol *ps_preset=gensym("preset");
    t_symbol *ps_usercanset=gensym("usercanset");
    t_symbol *ps_usercanget=gensym("usercanget");
    long symcount=0;
    t_symbol **symarray=NULL;
        
    jitob = max_jit_obex_jitob_get(x);
    jclass = jit_object_class(jitob);
    sortlist = jit_object_new(_jit_sym_jit_linklist);
        
    //attributes:
    //max object
    if (attrlist = max_jit_obex_attrlist_get(x)){
        size = (long) jit_object_method(attrlist,_jit_sym_getsize);
        for (i=0;i<size;i++) {
            if (o=jit_object_method(attrlist,_jit_sym_getindex,i)) {
                canget = (long)jit_object_method(o,ps_usercanget);
                canset = (long)jit_object_method(o,ps_usercanset);
                if (canget||canset)
                {
                    namesym = jit_object_method(o,_jit_sym_getname);
                    typesym = jit_object_method(o,_jit_sym_gettype);
                    sprintf(s,"    %s [%s",namesym->s_name, typesym->s_name);
                    if (jit_object_classname(o)==_jit_sym_jit_attr_offset_array) {              
                        sprintf(s2," array[%d]]",(long)jit_object_method(o,_jit_sym_getsize));
                        strcat(s,s2);
                    } else {
                        strcat(s,"]");
                    }
#ifdef QUICKREF_ATTR_VALUE
                    if (canget)
                    {
                        long ac=0,k;
                        t_atom *av=NULL;

                        max_jit_obex_attr_get(x,namesym,&ac,&av);
                        if ((typesym==_jit_sym_long)||(typesym==_jit_sym_char))  {
                            sprintf(s2," (val =");
                            strcat(s,s2);
                            for (k=0;k<MIN(ac,4);k++) {
                                sprintf(s2, " %d", jit_atom_getlong(av+k));
                                strcat(s,s2);
                            }
                            if (ac>4)
                                strcat(s," ...)");
                            else
                                strcat(s,")");
                        } else if ((typesym==_jit_sym_float32)||(typesym==_jit_sym_float64))  {
                            sprintf(s2," (val =");
                            strcat(s,s2);
                            for (k=0;k<MIN(ac,4);k++) {
                                sprintf(s2, " %.2f", jit_atom_getfloat(av+k));
                                strcat(s,s2);
                            }
                            if (ac>4)
                                strcat(s," ...)");
                            else
                                strcat(s,")");
                        } else if (typesym==_jit_sym_symbol) {
                            t_symbol *tmpsym;
                            sprintf(s2," (val =");
                            strcat(s,s2);
                            tmpsym = jit_atom_getsym(av);
                            if (tmpsym==_jit_sym_nothing)
                                sprintf(s2," <none>");
                            else
                                sprintf(s2," %s",tmpsym->s_name);
                            strcat(s,s2);
                            if (ac>1)
                                strcat(s," ...)");
                            else
                                strcat(s,")");
                        } 
                        freebytes(av,sizeof(t_atom)*ac);
                    }
#endif
                    if (!(canget&&canset)) {
                        if (canset)
                            strcat(s," (set)");
                        else
                            strcat(s," (get)");
                    }
                    jit_object_method(sortlist,_jit_sym_append,gensym(s)); //hack, this is a symbol not an object               
                }
            } 
        }
    }
    //jit object
    if (jitob&&!object_attr_getnames(jitob,&symcount,&symarray)) 
    {
        symbolarray_sort(symcount,symarray);
        for (i=0;i<symcount;i++) {
            if (o=object_attr_get(jitob,symarray[i])) {         
                canget = (long)jit_object_method(o,ps_usercanget);
                canset = (long)jit_object_method(o,ps_usercanset);
                if (canget||canset)
                {
                    namesym = jit_object_method(o,_jit_sym_getname);
                    typesym = jit_object_method(o,_jit_sym_gettype);
                    sprintf(s,"    %s [%s",namesym->s_name, typesym->s_name);
                    if (jit_object_classname(o)==_jit_sym_jit_attr_offset_array) {              
                        sprintf(s2," array[%d]]",(long)jit_object_method(o,_jit_sym_getsize));
                        strcat(s,s2);
                    } else {
                        strcat(s,"]");
                    }
#ifdef QUICKREF_ATTR_VALUE
                    if (canget)
                    {
                        long ac=0,k;
                        t_atom *av=NULL;
                        char getstr[128];
                        
                        sprintf(getstr,"get%s",namesym->s_name);
        
                        jit_object_method(jitob,gensym(getstr),&ac,&av);
                        if ((typesym==_jit_sym_long)||(typesym==_jit_sym_char))  {
                            sprintf(s2," (val =");
                            strcat(s,s2);
                            for (k=0;k<MIN(ac,4);k++) {
                                sprintf(s2, " %d", jit_atom_getlong(av+k));
                                strcat(s,s2);
                            }
                            if (ac>4)
                                strcat(s," ...)");
                            else
                                strcat(s,")");
                        } else if ((typesym==_jit_sym_float32)||(typesym==_jit_sym_float64))  {
                            sprintf(s2," (val =");
                            strcat(s,s2);
                            for (k=0;k<MIN(ac,4);k++) {
                                sprintf(s2, " %.2f", jit_atom_getfloat(av+k));
                                strcat(s,s2);
                            }
                            if (ac>4)
                                strcat(s," ...)");
                            else
                                strcat(s,")");
                        } else if (typesym==_jit_sym_symbol) {
                            t_symbol *tmpsym;
                            sprintf(s2," (val =");
                            strcat(s,s2);
                            tmpsym = jit_atom_getsym(av);
                            if (tmpsym==_jit_sym_nothing)
                                sprintf(s2," <none>");
                            else
                                sprintf(s2," %s",tmpsym->s_name);
                            strcat(s,s2);
                            if (ac>1)
                                strcat(s," ...)");
                            else
                                strcat(s,")");
                        } 
                        freebytes(av,sizeof(t_atom)*ac);
                    }
#endif
                    if (!(canget&&canset)) {
                        if (canset)
                            strcat(s," (set)");
                        else
                            strcat(s," (get)");
                    }
                    jit_object_method(sortlist,_jit_sym_append,gensym(s)); //hack, this is a symbol not an object               
                }
            } 
        }
    }
    if (symarray)
        freebytes((char *)symarray,symcount*sizeof(t_symbol *));

    items[0] = _jit_sym_nothing; //separator
    items[1] = gensym("Attributes:");
    j=2;
    jit_object_method(sortlist,_jit_sym_sort,quickref_symcompare);
    size = (long) jit_object_method(sortlist,_jit_sym_getsize);
    for (i=0;(i<size)&&(j<QUICKREF_MAXMENU);i++,j++)
        items[j] = jit_object_method(sortlist,_jit_sym_getindex,i);
    jit_object_method(sortlist,_jit_sym_chuck);
    
    //methods
    //max object, but first check if attribute
    //all public jit methods are exposed by max object 
    sortlist = jit_object_new(_jit_sym_jit_linklist);
    if (mess = ob_messlist(x)) {
        mess++;
        while (mess->m_sym) {
            if (!max_jit_method_is_attr(x,mess->m_sym)) {
                if ((mess->m_type[0]!=A_CANT)&&(mess->m_sym!=ps_assist)&&(mess->m_sym!=ps_preset))
                {   
                    //later on show method argument types
                    sprintf(s,"    %s ",mess->m_sym->s_name);
                    sprintf(s2,"%s%s",s,messlist_argstring(mess->m_type));
                    jit_object_method(sortlist,_jit_sym_append,gensym(s2)); //hack, this is a symbol not an object
                }
            }
            mess++;
        } 
    }
    if (j<QUICKREF_MAXMENU-1) {
        items[j] = _jit_sym_nothing; //separator
        j++;
        items[j] = gensym("Messages:");
        j++;
    }
        
    jit_object_method(sortlist,_jit_sym_sort,quickref_symcompare);
    size = (long) jit_object_method(sortlist,_jit_sym_getsize);
    for (i=0;(i<size)&&(j<QUICKREF_MAXMENU);i++,j++)
        items[j] = jit_object_method(sortlist,_jit_sym_getindex,i);
    jit_object_method(sortlist,_jit_sym_chuck);
    
    *numitems = j;
}

t_jit_linklist *jit_usurplist_build(void *parent, t_symbol *classname)
{
    t_jit_linklist *x=NULL;
    t_jit_class *c;
    t_messlist *m;
    t_jit_usurp *u;
    long type;
    char tmpstr[256];
    

    //first deal with max object usurp methods(this handles attributes)
    if (!parent) goto out;
    if (!(m=((t_max_object *)parent)->o_messlist)) goto out;
    while (m->m_sym){
        if ((FCHECK(m->m_fun)==(method)max_jit_usurp_method)&&(m[1].m_type[0]==A_CANT)){
            sprintf(tmpstr,"%s_usurp",m->m_sym->s_name);
            if (m[1].m_sym==gensym(tmpstr)) {
                if (!x) { if (!(x = jit_linklist_new())) goto out; }
                if (!(u=jit_usurp_new(parent,FCHECK(m[1].m_fun),m->m_sym,JIT_USURP_FLAGS_MAX))) goto out; //out of mem
                jit_linklist_append(x,u);
            } else {
                sprintf(tmpstr+strlen(tmpstr),"_low");
                if (m[1].m_sym==gensym(tmpstr)) {
                    if (!x) { if (!(x = jit_linklist_new())) goto out; }
                    if (!(u=jit_usurp_new(parent,FCHECK(m[1].m_fun),m->m_sym,JIT_USURP_FLAGS_MAX|JIT_USURP_FLAGS_LOW))) goto out; //out of mem
                    jit_linklist_append(x,u);
                }
            }                       
        }
        m++;
    }       
    //now add jit object usurp methods  
    if (c=jit_class_findbyname(classname)) {
        m = (((t_jit_class *)c)->c_messlist)+1;
        while (m->m_sym){
            type = m->m_type[0];
            switch (type) {
            case A_USURP:
                if (!x) { if (!(x = jit_linklist_new())) goto out; }
                if (!(u=jit_usurp_new(parent,FCHECK(m->m_fun),m->m_sym,0))) goto out; //out of mem
                jit_linklist_append(x,u);
                break;
            case A_USURP_LOW:
                if (!x) { if (!(x = jit_linklist_new())) goto out; }
                if (!(u=jit_usurp_new(parent,FCHECK(m->m_fun),m->m_sym,JIT_USURP_FLAGS_LOW))) goto out; //out of mem
                jit_linklist_append(x,u);
                break;
            }
            m++;
        }
    }
out:
    return x;
}

#pragma mark -
// --------------------------------------------------------------------------------
// max_jit_classex functions

/**
 * Allocates and initializes special t_max_jit_classex data, used by the Max wrapper class.
 * 
 * @ingroup maxwrapmod
 *
 * @param   oboffset    object struct byte offset to obex pointer
 *
 * @return  pointer to t_max_jit_classex data (opaque)
 *
 */
void *max_jit_classex_setup(long oboffset)
{
    t_max_jit_classex *x;
    
#if TARGET_RT_MAC_MACHO
    initialize();
#endif
    if (x=(t_max_jit_classex *)jit_getbytes(sizeof(t_max_jit_classex))) {
        x->oboffset = oboffset;
        x->attrlist = NULL;
        x->adornmentlist = NULL;
        addmess((method)x, "max_jit_classex", A_CANT,0);
    }
    
    return x;
}

/**
 * Adds an attribute to the Max wrapper class.
 * 
 * @ingroup maxwrapmod
 *
 * @param   x       pointer to t_max_jit_classex data (opaque)
 * @param   attr    attribute object pointer
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_classex_addattr(void *x, void *attr)
{
    t_symbol *s;
    method  *m;
    long type;
    char tmpstr[256];
    
    if (x&&attr) {
        if (!((t_max_jit_classex *)x)->attrlist) {
            if (!(((t_max_jit_classex *)x)->attrlist=jit_linklist_new())){
                return JIT_ERR_OUT_OF_MEM;
            }
        }
        jit_linklist_append(((t_max_jit_classex *)x)->attrlist,attr);           
        //add the method to the messlist
        s = jit_object_method(attr,_jit_sym_getname);
        if (jit_object_method(attr,ps_usercanset)) {
            m = jit_object_method(attr,_jit_sym_getmethod,_jit_sym_set);
            type = (long) jit_object_method(attr,ps_getmethodtype,_jit_sym_set);
            switch (type) {
            case A_DEFER:
                max_addmethod_defer((method)max_jit_obex_attr_set, s->s_name);
                break;
            case A_DEFER_LOW:
                max_addmethod_defer_low((method)max_jit_obex_attr_set, s->s_name);
                break;
            case A_USURP:
                max_addmethod_usurp((method)max_jit_obex_attr_set, s->s_name);
                break;
            case A_USURP_LOW:
                max_addmethod_usurp_low((method)max_jit_obex_attr_set, s->s_name);
                break;
            case A_GIMME:
                addmess((method)max_jit_obex_attr_set, s->s_name, A_GIMME, 0);
                break;
            }               
        }
        if (jit_object_method(attr,ps_usercanget)) {
            m = jit_object_method(attr,_jit_sym_getmethod,_jit_sym_get);
            type = (long) jit_object_method(attr,ps_getmethodtype,_jit_sym_get);
            sprintf(tmpstr,"%s%s","get",s->s_name);
            switch (type) {
            case A_DEFER:
                max_addmethod_defer((method)max_jit_obex_attr_getdump, tmpstr);
                break;
            case A_DEFER_LOW:
                max_addmethod_defer_low((method)max_jit_obex_attr_getdump, tmpstr);
                break;
            case A_USURP:
                max_addmethod_usurp((method)max_jit_obex_attr_getdump, tmpstr);
                break;
            case A_USURP_LOW:
                max_addmethod_usurp_low((method)max_jit_obex_attr_getdump, tmpstr);
                break;
            case A_GIMME:
                addmess((method)max_jit_obex_attr_getdump, tmpstr, A_GIMME, 0);
                break;
            }
        }
        
        return JIT_ERR_NONE;
    }       
    return JIT_ERR_INVALID_PTR;
}

t_max_jit_classex *max_jit_classex_get(void *x)
{
    t_messlist *m=NULL;
    if (x) {
        if (!(m=((t_max_object *)x)->o_messlist)) goto out;
        while (m->m_sym){
            if ((m->m_sym==_jit_sym_max_jit_classex)){
#ifdef WIN_VERSION
                return (t_max_jit_classex *)m->m_fun;
#else
// temporary, only here for Jitter 1.5.7 with MaxMSP 4.6 (NOT SAFE IN CFM)
                return (t_max_jit_classex *)FCHECK((UInt32 *)m->m_fun);
#endif
            }
            m++;
        }
    }
out:
    return NULL;
}

#pragma mark -
// --------------------------------------------------------------------------------
// max_jit_obex functions

/**
 * Allocates an initializes a new Max wrapper object instance.
 * This is used in place of the newobject function.
 * 
 * @ingroup maxwrapmod
 *
 * @param   mc          Max class pointer
 * @param   classname   Jitter class name to wrap
 *
 * @return  pointer to new Max wrapper object instance
 *
 */
void *max_jit_obex_new(void *mc, t_symbol *classname)
{
    void *x;
    t_class *c;
    
    if (x=newobject(mc)) {
        // HACK for oldschool objects to have attributes
        c = object_class(x);
        c->c_flags &= ~CLASS_FLAG_NOATTRIBUTES; 
        c->c_flags |= CLASS_FLAG_OWNATTRIBUTES;
        max_jit_obex_set(x,jit_getbytes(sizeof(t_max_jit_obex)));   
        max_jit_obex_jitob_set(x,NULL);
        max_jit_obex_usurplist_set(x,jit_usurplist_build(x,classname));
        max_jit_obex_proxylist_set(x,NULL);
        max_jit_obex_inletnumber_set(x,0);  
        max_jit_obex_dumpout_set(x,NULL);
        max_jit_obex_adornmentlist_set(x,NULL);
        max_jit_obex_box_set(x, ps__Box->s_thing);
    }
    return x;
}

/**
 * Frees additional resources for the Max wrapper object instance.
 * 
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 *
 */
void max_jit_obex_free(void *x)
{
    void *p;
    t_max_jit_obex *obex;
    
    if (x) {
        if (p=max_jit_obex_usurplist_get(x))
            jit_object_free(p);
        if (p=max_jit_obex_proxylist_get(x))
            jit_object_free(p);
        if (p=max_jit_obex_adornmentlist_get(x))
            jit_object_free(p);
        if (obex=max_jit_obex_get(x))   
            jit_freebytes(obex,sizeof(t_max_jit_obex));
        //should we also free the jitob automatically?
    }
}

// for new max obex/pattr comptibility
void *max_jit_obex_attr_getobject(void *x, t_symbol *s)
{
    t_jit_linklist *attrlist;   
    void *attr=NULL;
        
    if (attrlist=max_jit_obex_attrlist_get(x)) {
        jit_linklist_findfirst(attrlist,&attr,(t_cmpfn)jit_attr_symcompare,s);
        if (attr)
            return attr;
    }
    if (attr=jit_object_attr_get(max_jit_obex_jitob_get(x),s)) {
        return attr;
    }

    return attr;
}


// for new max obex/pattr comptibility
void *max_jit_obex_attr_gettarget(void *x, t_symbol *s)
{
    t_jit_linklist *attrlist;   
    void *attr=NULL;
        
    if (attrlist=max_jit_obex_attrlist_get(x)) {
        jit_linklist_findfirst(attrlist,&attr,(t_cmpfn)jit_attr_symcompare,s);
        if (attr)
            return x;
    }
    if (attr=jit_object_attr_get(max_jit_obex_jitob_get(x),s)) {
        return max_jit_obex_jitob_get(x);
    }
    return attr;
}

// for new max obex/pattr comptibility
long max_jit_obex_attr_getnames(void *x, long *argc, t_symbol ***argv)
{
    void *attrlist,*jitob;
    long i,j,mac=0,jac=0;
    t_symbol **jav=NULL;
    
    *argc = 0;
    *argv = NULL;
    if (attrlist=max_jit_obex_attrlist_get(x)) {
        mac = jit_linklist_getsize(attrlist);
    }
    jitob = max_jit_obex_jitob_get(x);
    if (jitob) {
        object_attr_getnames(jitob, &jac, &jav);
    }
    *argc = mac+jac;
    if (*argc) {
        *argv = (t_symbol **)getbytes((*argc)*sizeof(t_symbol *));
        for (i=0;i<mac;i++)
            (*argv)[i] = jit_object_method(jit_linklist_getindex(attrlist,i),_jit_sym_getname);
        for (j=0;j<jac;i++,j++)
            (*argv)[i] = jav[j];
    }
    if (jac&&jav)
        freebytes(jav,jac*sizeof(t_symbol *));
        
    return 0;
}

void *max_jit_obex_attrlist_get(void *x)
{
    t_max_jit_classex *c=NULL;
    if (x) {
        if (c=max_jit_classex_get(x))
            return c->attrlist;
    }
    return NULL;
}

/**
 * Sets an attribute of the Max wrapper or the wrapped Jitter object.
 * 
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 * @param   s           attribute name
 * @param   ac          atom count
 * @param   av          atom vector
 *
 * @return  t_jit_error error code
 *
 */
t_jit_err max_jit_obex_attr_set(void *x, t_symbol *s, long ac, t_atom *av)
{
    t_jit_linklist *attrlist;   
    void *attr;
    method m=NULL;
    t_box *b;
    t_jit_err rv;
    
    if (x&&(attrlist=max_jit_obex_attrlist_get(x))) {
        jit_linklist_findfirst(attrlist,&attr,(t_cmpfn)jit_attr_symcompare,s);
        if (attr) m = jit_object_method(attr,_jit_sym_getmethod,_jit_sym_set);
        if (m) rv = (t_jit_err)((*m)(x,attr,ac,av));
        object_notify(x,ps_attr_modified,attr);
        if ((b = max_jit_obex_box_get(x)) && ((void *)b != x)) {
            object_notify(b, ps_attr_modified, attr);
        }
        return rv;
    }
    
    return JIT_ERR_GENERIC;
}

/**
 * Retrienves an attribute of the Max wrapper or the wrapped Jitter object.
 * 
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 * @param   s           attribute name
 * @param   ac          pointer to atom count
 * @param   av          pointer to atom vector
 *
 * @return  t_jit_error error code
 *
 */
t_jit_err max_jit_obex_attr_get(void *x, t_symbol *s, long *ac, t_atom **av)
{
    t_jit_linklist *attrlist;   
    void *attr;
    method m=NULL;
        
    if (x&&(attrlist=max_jit_obex_attrlist_get(x))) {
        jit_linklist_findfirst(attrlist,&attr,(t_cmpfn)jit_attr_symcompare,s);
        if (attr) m = jit_object_method(attr,_jit_sym_getmethod,_jit_sym_get);
        if (m) 
            return (t_jit_err)((*m)(x,attr,ac,av));
        return JIT_ERR_NONE;
    }
    
    return JIT_ERR_GENERIC;
}

void max_jit_obex_attr_getdump(void *x, t_symbol *s, short argc, t_atom *argv)
{
    long ac=0;
    t_atom *av=NULL;
    method f;
    t_jit_err err;
    
    s = gensym(s->s_name+3); //strip get
    if ((err = max_jit_obex_attr_get(x,s,&ac,&av)) != JIT_ERR_NONE) {
        jit_error_code(x, err);
    } else {
        if (f=zgetfn(x,ps_dumpout))
            (*f)(x,s,(short)ac,av);
    }
    freebytes(av,sizeof(t_atom)*ac);
}

t_jit_err max_jit_obex_set(void *x, void *p)
{
    t_max_jit_classex *c=NULL;
    if (x) {
        if (c=max_jit_classex_get(x))
            *((t_max_jit_obex **)(((char *)x)+(c->oboffset))) = p;
            return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

void *max_jit_obex_get(void *x)
{
    t_max_jit_classex *c=NULL;
    if (x) {
        if (c=max_jit_classex_get(x))
            return *((t_max_jit_obex **)(((char *)x)+(c->oboffset)));
    }
    return NULL;
}

/**
 * Retrieves the wrapped Jitter object from a Max wrapper object.
 * 
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 *
 * @return  Jitter object pointer
 *
 */
void *max_jit_obex_jitob_get(void *x)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        return obex->jitob;
    else
        return NULL;
}

/**
 * Sets the wrapped Jitter object for a Max wrapper object.
 * 
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 * @param   jitob       Jitter object pointer
 *
 */
void max_jit_obex_jitob_set(void *x, void *jitob)
{
    t_max_jit_obex *obex;
    static t_symbol *ps_maxwrapper=NULL;
    
    if (!ps_maxwrapper)
        ps_maxwrapper = gensym("maxwrapper");
        
    if (obex=max_jit_obex_get(x)) {
        if (jitob)
            object_obex_storeflags(jitob,ps_maxwrapper,(t_object *)x,OBJ_FLAG_REF);
        obex->jitob=jitob;
    }
}

void *max_jit_obex_usurplist_get(void *x)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        return obex->usurplist;
    else
        return NULL;
}

void max_jit_obex_usurplist_set(void *x, void *usurplist)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        obex->usurplist=usurplist;
}

void *max_jit_obex_proxylist_get(void *x)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        return obex->proxylist;
    else
        return NULL;
}

void max_jit_obex_proxylist_set(void *x, void *proxylist)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        obex->proxylist=proxylist;
}

/**
 * Retrieves the current inlet number used by inlet proxies. 
 * 
 * @ingroup maxwrapmod
 *
 * @param   x               Max wrapper object pointer
 *
 * @return  current inlet index
 *
 */
long max_jit_obex_inletnumber_get(void *x)
{
    return proxy_getinlet(x);
}

/**
 * Sets the current inlet number used by inlet proxies. 
 * 
 * @warning Typically not used outside jitlib.
 * 
 * @ingroup maxwrapmod
 *
 * @param   x               Max wrapper object pointer
 * @param   inletnumber     inlet index
 *
 */
void max_jit_obex_inletnumber_set(void *x, long inletnumber)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        obex->inletnumber=inletnumber;
}

/**
 * Creates a new proxy inlet. 
 * 
 * @ingroup maxwrapmod
 *
 * @param   x       Max wrapper object pointer
 * @param   c       inlet index
 *
 * @return t_jit_err error code
 *
 */
t_jit_err max_jit_obex_proxy_new(void *x, long c)
{
    t_max_jit_obex *obex;
    void *proxy;
    if (obex=max_jit_obex_get(x)) {
        if (!obex->proxylist) {
            if (!(obex->proxylist=jit_linklist_new()))
                return JIT_ERR_OUT_OF_MEM;
        }
        if (proxy=proxy_new(x,c,&obex->inletnumber)) {
            jit_linklist_append(obex->proxylist,proxy);
            return JIT_ERR_NONE;            
        } else { 
            return JIT_ERR_OUT_OF_MEM;
        }
    } else {
        return JIT_ERR_GENERIC;
    }
}

/**
 * Sets the Max wrapper object's dump outlet's outlet pointer. 
 * 
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 * @param   outlet      dump outlet pointer
 *
 */
void max_jit_obex_dumpout_set(void *x, void *outlet)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        obex->dumpout=outlet;
}

/**
 * Retrieves the Max wrapper object's dump outlet's outlet pointer. 
 * 
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 *
 * @return  dump outlet pointer
 *
 */
void *max_jit_obex_dumpout_get(void *x)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        return obex->dumpout;
    else
        return NULL;
}

/**
 * Sends a message and arguments out the dump outlet. 
 * This message is equivalent to calling outlet_anything
 * with the outlet returned by max_jit_obex_dumpout_get.
 *
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 * @param   s           message symbol
 * @param   argc        argument count
 * @param   argv        argument vector
 *
 */
void max_jit_obex_dumpout(void *x, t_symbol *s, short argc, t_atom *argv)
{
    t_max_jit_obex *obex;
    
    if ((obex=max_jit_obex_get(x))&&obex->dumpout) {
        outlet_anything(obex->dumpout,s,argc,argv); 
    }
}

void *max_jit_obex_adornmentlist_get(void *x)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        return obex->adornmentlist;
    else
        return NULL;
}

void max_jit_obex_adornmentlist_set(void *x, void *adornmentlist)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        obex->adornmentlist=adornmentlist;
}

/**
 * Retrieves Max wrapper object adornment specified by class name.  
 * Typcially used for accessing the jit_mop adornment for MOP Max
 * wrapper objects.
 *
 * @ingroup maxwrapmod
 *
 * @param   x           Max wrapper object pointer
 * @param   classname   adornment classname
 * 
 * @return  adornment pointer
 *
 */
void *max_jit_obex_adornment_get(void *x, t_symbol *classname)
{
    t_max_jit_obex *obex;
    void *adornment=NULL;
    
    if ((obex=max_jit_obex_get(x)) && obex->adornmentlist) {
        jit_object_method(obex->adornmentlist,_jit_sym_findfirst,&adornment,jit_object_classname_compare,classname);
    } 
    
    return adornment;
}

void max_jit_obex_box_set(void *x, void *b)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        obex->b=b;
}

t_box *max_jit_obex_box_get(void *x)
{
    t_max_jit_obex *obex;
    if (obex=max_jit_obex_get(x))
        return obex->b;
    else
        return NULL;
}

t_jit_err max_jit_obex_addadornment(void *x,void *adornment)
{
    t_max_jit_obex *obex;
    
    if ((obex=max_jit_obex_get(x))&&adornment) {
        if (!obex->adornmentlist) {
            if (!(obex->adornmentlist=jit_object_new(_jit_sym_jit_linklist)))
                return JIT_ERR_OUT_OF_MEM;
        }
        
        jit_object_method(obex->adornmentlist,_jit_sym_append,adornment);
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_GENERIC;
    }
}

long max_jit_obex_attr_usercanset(void *x, t_symbol *s)
{
    void *attr=NULL;    
    t_max_jit_classex *c;
    
    if (c=max_jit_classex_get(x)) {
        if (c->attrlist) {
            jit_linklist_findfirst(c->attrlist,&attr,(t_cmpfn)jit_attr_symcompare,s);
            if (attr) return (long)jit_object_method(attr,ps_usercanset);
        }       
    }
    
    return FALSE;       
}

void *max_jit_obex_attr_method_direct(void *x, t_symbol *s, long ac, t_atom *av)
{
    void *attr=NULL;    
    method m;
    t_max_jit_classex *c;
    
    if (c=max_jit_classex_get(x)) {
        if (c->attrlist) {
            jit_linklist_findfirst(c->attrlist,&attr,(t_cmpfn)jit_attr_symcompare,s);
            if (attr) {
                if (m=(method)jit_object_method(attr,_jit_sym_getmethod,_jit_sym_set))
                    (*m)(x,attr,ac,av);
            }
        }       
    }
    return NULL;
}

// no dumpout
/**
 * Calls gimmeback methods and frees any return value.
 *
 * @ingroup maxwrapmod
 *
 * @param   x       Max wrapper object pointer
 * @param   s       method name
 * @param   ac      argument count
 * @param   av      argument vector
 *
 */
void max_jit_obex_gimmeback(void *x, t_symbol *s, long ac, t_atom *av)
{
    t_atom rv;
    t_atom *rav=NULL;
    long rac=0;
        
    object_method_typed(max_jit_obex_jitob_get(x),s,ac,av,&rv);
    if (rv.a_type == A_NOTHING) return;
    if (rv.a_type==A_OBJ) { 
        if (rac&&rav)
            freebytes(rav,rac*sizeof(t_atom));      
        if(rv.a_w.w_obj)
            freeobject(rv.a_w.w_obj);   
    }
}

/**
 * Calls gimmeback methods and outputs any return value through the Max wrapper class' dump outlet.
 *
 * @ingroup maxwrapmod
 *
 * @param   x       Max wrapper object pointer
 * @param   s       method name
 * @param   ac      argument count
 * @param   av      argument vector
 *
 */
void max_jit_obex_gimmeback_dumpout(void *x, t_symbol *s, long ac, t_atom *av)
{
    t_atom rv;
    t_atom *rav=NULL;
    long rac=0;
        
    object_method_typed(max_jit_obex_jitob_get(x),s,ac,av,&rv);
    if (rv.a_type == A_NOTHING) return;
    if (rv.a_type==A_OBJ) { 
        object_getvalueof(rv.a_w.w_obj,&rac,&rav);
    } else {
        rac = 1;
        rav = &rv;
    }
    if (s&&s->s_name[0]=='g'&&s->s_name[1]=='e'&&s->s_name[2]=='t')
        s = gensym(s->s_name+3);
    max_jit_obex_dumpout(x,s,rac,rav);
    if (rv.a_type==A_OBJ) { 
        if (rac&&rav)
            freebytes(rav,rac*sizeof(t_atom));      
        if(rv.a_w.w_obj)
            freeobject(rv.a_w.w_obj);   
    }
}

Copyright © 2008, Cycling '74