Max 5 API Reference

jit.functor.c

/*
    jit.functor.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com

    A functor is a function object with possible associated state.
    currently all of our functors take as input N values and output
    a single value. They may be evaulated using fixed point, 32 bit or
    64 bit floating point arithmetic. minimally a 64 bit floating point
    N-D evaluation function should be defined. Unless also defined
    by the functor class, 32 bit floating and 32 bit fixed point
    evaluation functions as well as specific 1D through 3D cases for
    each will be defined.

*/

#include "jit.common.h"
#include "jit.functor.h"
#include "ext_obex.h"

static t_hashtab *_jit_functor_hashtab=NULL;
static t_symbol *ps_evalfixed,*ps_evalfloat32,*ps_evalfloat64,*ps_subfunctor;

long jit_functor_category_match(t_class *c, t_symbol *categoryname);
long jit_functor_category_symcompare(t_symbol *categoryname, t_symbol *comparename);

long jit_functor_eval_fixed(t_jit_object *x, long dimcount, long *vals);
float jit_functor_eval_float32(t_jit_object *x, long dimcount, float *vals);
t_jit_err jit_functor_eval_typed(t_jit_object *x, t_symbol *s, long ac, t_atom *av, t_atom *rv);

// jitlib curve functors
t_jit_err jit_functor_curve_linear_init();
t_jit_err jit_functor_curve_cubicspline_init();

// jitlib filter functors
t_jit_err jit_functor_filter_bessel_init();
t_jit_err jit_functor_filter_box_init();
t_jit_err jit_functor_filter_catmullrom_init();
t_jit_err jit_functor_filter_disk_init();
t_jit_err jit_functor_filter_gaussian_init();
t_jit_err jit_functor_filter_lanczossinc_init();
t_jit_err jit_functor_filter_mitchell_init();
t_jit_err jit_functor_filter_sinc_init();
t_jit_err jit_functor_filter_triangle_init();

// jitlib noise functors
t_jit_err jit_functor_noise_cell_init();
t_jit_err jit_functor_noise_checker_init();
t_jit_err jit_functor_noise_distorted_init();
t_jit_err jit_functor_noise_gradient_init();
t_jit_err jit_functor_noise_simplex_init();
t_jit_err jit_functor_noise_sparse_convolution_init();
t_jit_err jit_functor_noise_value_convolution_init();
t_jit_err jit_functor_noise_value_cubicspline_init();
t_jit_err jit_functor_noise_voronoi_init();

// jitlib fractal functors
t_jit_err jit_functor_fractal_mono_init();
t_jit_err jit_functor_fractal_multi_init();
t_jit_err jit_functor_fractal_hetero_init();
t_jit_err jit_functor_fractal_multi_hybrid_init();
t_jit_err jit_functor_fractal_multi_ridged_init();
t_jit_err jit_functor_fractal_turbulence_init();

// jitlib distance functors
t_jit_err jit_functor_distance_chebychev_init();
t_jit_err jit_functor_distance_euclidean_init();
t_jit_err jit_functor_distance_euclidean_squared_init();
t_jit_err jit_functor_distance_manhattan_init();
t_jit_err jit_functor_distance_manhattan_radial_init();
t_jit_err jit_functor_distance_minkovsky_init();
t_jit_err jit_functor_distance_superquadratic_init();

// jitlib transfer functors
t_jit_err jit_functor_transfer_bias_init();
t_jit_err jit_functor_transfer_cubic_init();
t_jit_err jit_functor_transfer_gain_init();
t_jit_err jit_functor_transfer_linear_init();
t_jit_err jit_functor_transfer_pulse_init();
t_jit_err jit_functor_transfer_quintic_init();
t_jit_err jit_functor_transfer_saw_init();
t_jit_err jit_functor_transfer_sine_init();
t_jit_err jit_functor_transfer_smoothstep_init();
t_jit_err jit_functor_transfer_smoothpulse_init();
t_jit_err jit_functor_transfer_step_init();
t_jit_err jit_functor_transfer_solarize_init();

// jitlib functor evaluators
t_jit_err jit_functor_evaluate_init();

// jitlib sampler functors
t_jit_err jit_functor_sampler_regular_init();
    
    
t_jit_err jit_functor_init(void)
{
    _jit_functor_hashtab = hashtab_new(0);

    // jitlib curve functors
    jit_functor_curve_linear_init();
    jit_functor_curve_cubicspline_init();

    // jitlib filter functors
    jit_functor_filter_bessel_init();
    jit_functor_filter_box_init();
    jit_functor_filter_catmullrom_init();
    jit_functor_filter_disk_init();
    jit_functor_filter_gaussian_init();
    jit_functor_filter_lanczossinc_init();
    jit_functor_filter_mitchell_init();
    jit_functor_filter_sinc_init();
    jit_functor_filter_triangle_init();
    
    // jitlib noise functors
    jit_functor_noise_cell_init();  
    jit_functor_noise_checker_init();
    jit_functor_noise_distorted_init();
    jit_functor_noise_gradient_init();
    jit_functor_noise_simplex_init();
    jit_functor_noise_sparse_convolution_init();
    jit_functor_noise_value_convolution_init();
    jit_functor_noise_value_cubicspline_init();
    jit_functor_noise_voronoi_init();

    // jitlib fractal functors
    jit_functor_fractal_mono_init();
    jit_functor_fractal_multi_init();
    jit_functor_fractal_hetero_init();
    jit_functor_fractal_multi_hybrid_init();
    jit_functor_fractal_multi_ridged_init();
    jit_functor_fractal_turbulence_init();

    // jitlib distance functors
    jit_functor_distance_chebychev_init();
    jit_functor_distance_euclidean_init();
    jit_functor_distance_euclidean_squared_init();
    jit_functor_distance_manhattan_init();
    jit_functor_distance_manhattan_radial_init();
    jit_functor_distance_minkovsky_init();
    jit_functor_distance_superquadratic_init();

    // jitlib transfer functors
    jit_functor_transfer_bias_init();
    jit_functor_transfer_cubic_init();
    jit_functor_transfer_gain_init();
    jit_functor_transfer_linear_init();
    jit_functor_transfer_pulse_init();
    jit_functor_transfer_quintic_init();
    jit_functor_transfer_saw_init();
    jit_functor_transfer_sine_init();
    jit_functor_transfer_smoothstep_init();
    jit_functor_transfer_smoothpulse_init();
    jit_functor_transfer_step_init();
    jit_functor_transfer_solarize_init();

    // jitlib functor evaluators
    jit_functor_evaluate_init();
    
    // jitlib sampler functors
    jit_functor_sampler_regular_init();
    
    // generate symbols
    ps_evalfixed = gensym("evalfixed");
    ps_evalfloat32 = gensym("evalfloat32");
    ps_evalfloat64 = gensym("evalfloat64");
    ps_subfunctor = gensym("subfunctor");
    
    return JIT_ERR_NONE;
}

t_jit_err jit_functor_setup_class(t_class *c,  char *categoryname, char *classname)
{
    method m;
    t_class *cc=NULL;
    t_jit_functor_interface *fi;
    char tmpstr[256];

    jit_functor_addcategory(c,gensym(categoryname));

    hashtab_lookup(_jit_functor_hashtab,gensym(classname),(t_jit_object **)&cc);
    if (cc) {
        // TODO: if we wish to support multiple categories for a given functor
        // just add obex extra category token, not methods (already added)
        return JIT_ERR_NONE;
    }

    // add extra things to the class in the fashion of being the classes super class
    if (!jit_class_method(c,gensym("evalfixed")))
        jit_class_addmethod(c, (method)jit_functor_eval_fixed, "evalfixed", A_CANT, 0L);
    if (!jit_class_method(c,gensym("evalfloat32")))
        jit_class_addmethod(c, (method)jit_functor_eval_float32, "evalfloat32", A_CANT, 0L);

    // for optimized dim cases
    m = jit_class_method(c,gensym("evalfixed"));
    if (!jit_class_method(c,gensym("evalfixed_1d")))
        jit_class_addmethod(c, m, "evalfixed_1d", A_CANT, 0L);
    if (!jit_class_method(c,gensym("evalfixed_2d")))
        jit_class_addmethod(c, m, "evalfixed_2d", A_CANT, 0L);
    if (!jit_class_method(c,gensym("evalfixed_3d")))
        jit_class_addmethod(c, m, "evalfixed_3d", A_CANT, 0L);

    m = jit_class_method(c,gensym("evalfloat32"));
    if (!jit_class_method(c,gensym("evalfloat32_1d")))
        jit_class_addmethod(c, m, "evalfloat32_1d", A_CANT, 0L);
    if (!jit_class_method(c,gensym("evalfloat32_2d")))
        jit_class_addmethod(c, m, "evalfloat32_2d", A_CANT, 0L);
    if (!jit_class_method(c,gensym("evalfloat32_3d")))
        jit_class_addmethod(c, m, "evalfloat32_3d", A_CANT, 0L);

    m = jit_class_method(c,gensym("evalfloat64"));
    if (!jit_class_method(c,gensym("evalfloat64_1d")))
        jit_class_addmethod(c, m, "evalfloat64_1d", A_CANT, 0L);
    if (!jit_class_method(c,gensym("evalfloat64_2d")))
        jit_class_addmethod(c, m, "evalfloat64_2d", A_CANT, 0L);
    if (!jit_class_method(c,gensym("evalfloat64_3d")))
        jit_class_addmethod(c, m, "evalfloat64_3d", A_CANT, 0L);

    //the typed variant
    jit_class_addmethod(c, (method)jit_functor_eval_typed, "eval", A_GIMMEBACK, 0L);
    // synonym since eval seems to be reserved in JS
    jit_class_addmethod(c, (method)jit_functor_eval_typed, "evaluate", A_GIMMEBACK, 0L);

    // these utility functions will check to see if there is a method
    // defined for "subfunctor" (which is kind of like decorator implementation
    // where a symbol is passed in and an object pointer is returned and
    // on which the set/getattr method is to be called upon)
    jit_class_addmethod(c, (method)jit_functor_setattr, "setattr", A_GIMME, 0L);
    // save getattr for later. use attrstyle gimme or new gimmeback? not sure
    //jit_class_addmethod(c, jit_functor_getattr, "getattr", A_GIMMEBACK, 0L); 
    
    fi = (t_jit_functor_interface *) sysmem_newptrclear(sizeof(t_jit_functor_interface));

    fi->evalfixed       = (t_jit_functor_fixed_sig) jit_class_method(c,gensym("evalfixed"));
    fi->evalfixed_1d    = (t_jit_functor_fixed_sig) jit_class_method(c,gensym("evalfixed_1d"));
    fi->evalfixed_2d    = (t_jit_functor_fixed_sig) jit_class_method(c,gensym("evalfixed_2d"));
    fi->evalfixed_3d    = (t_jit_functor_fixed_sig) jit_class_method(c,gensym("evalfixed_3d"));

    fi->evalfloat32     = (t_jit_functor_float32_sig) jit_class_method(c,gensym("evalfloat32"));
    fi->evalfloat32_1d  = (t_jit_functor_float32_sig) jit_class_method(c,gensym("evalfloat32_1d"));
    fi->evalfloat32_2d  = (t_jit_functor_float32_sig) jit_class_method(c,gensym("evalfloat32_2d"));
    fi->evalfloat32_3d  = (t_jit_functor_float32_sig) jit_class_method(c,gensym("evalfloat32_3d"));

    fi->evalfloat64     = (t_jit_functor_float64_sig) jit_class_method(c,gensym("evalfloat64"));
    fi->evalfloat64_1d  = (t_jit_functor_float64_sig) jit_class_method(c,gensym("evalfloat64_1d"));
    fi->evalfloat64_2d  = (t_jit_functor_float64_sig) jit_class_method(c,gensym("evalfloat64_2d"));
    fi->evalfloat64_3d  = (t_jit_functor_float64_sig) jit_class_method(c,gensym("evalfloat64_3d"));
    
    class_extra_store(c,gensym("functor_interface"),(t_object *)fi);

    hashtab_store(_jit_functor_hashtab,gensym(classname),(t_object *)c);
    
    // also store in hashtab as full category.classname string
    sprintf(tmpstr,"%s.%s",categoryname,classname);
    hashtab_store(_jit_functor_hashtab,gensym(tmpstr),(t_object *)c);

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_addcategory(t_class *c, t_symbol *categoryname)
{
    t_jit_linklist *catlist;
    
    if (!(catlist=class_extra_lookup(c,gensym("functor_category")))) {
        catlist = jit_linklist_new();
        class_extra_store(c,gensym("functor_category"),(t_object *)catlist);
    }
    if (catlist) {
        jit_linklist_append(catlist,categoryname);  
        return JIT_ERR_NONE;
    } else
        return JIT_ERR_GENERIC;
}

t_jit_object *jit_functor_getcategorylist(t_class *c)
{
    return class_extra_lookup(c,gensym("functor_category"));
}

long jit_functor_category_match(t_class *c, t_symbol *categoryname)
{
    t_jit_linklist *catlist=(t_jit_linklist *)jit_functor_getcategorylist(c);
    t_jit_object *o=NULL;
    
    if (catlist) {
        jit_linklist_findfirst(catlist,(void **)&o,(t_cmpfn)jit_functor_category_symcompare,categoryname);
        if (o)
            return 1;
    }
    return 0;
}

long jit_functor_category_symcompare(t_symbol *categoryname, t_symbol *comparename)
{
    return categoryname==comparename;
}

t_jit_object *jit_functor_classlist_in_category(t_symbol *categoryname)
{
    t_object *o=NULL;
    t_class *c;
    t_jit_linklist *classlist=NULL;
    t_symbol **ckv=NULL;
    long i,ckc=0;

    if (_jit_functor_hashtab) {
        hashtab_getkeys(_jit_functor_hashtab,&ckc,&ckv);
        for (i=0;i<ckc;i++) {
            if (c=jit_functor_lookup(categoryname,ckv[i])) {
                if (!classlist)
                    classlist = jit_linklist_new();
                jit_linklist_append(classlist,(t_jit_object *)c);
            }
        }
        if (ckv)
            freebytes((char *)ckv,ckc*sizeof(t_symbol *));
    }   
    return (t_jit_object *)classlist; // callee should call jit_object_method(classlist,_jit_sym_chuck) instead of free
}

t_class *jit_functor_lookup_relaxed(t_symbol *categoryname, t_symbol *classname)
{
    t_class *c=NULL;
    long i,len;

    // categoryname arg is placeholder for recommended category if
    // we need it later. for now, just look for classes.
    
    hashtab_lookup(_jit_functor_hashtab,classname,(t_jit_object **)&c);
    if (!c) {
        // now check to see if the class has been specified in category.class syntax
        len = strlen(classname->s_name);
        for (i=0;i<len;i++) {
            if (classname->s_name[i]=='.') {
                hashtab_lookup(_jit_functor_hashtab,gensym(classname->s_name+i+1),(t_jit_object **)&c);
                if (c)
                    return c;
            }       
        }
    }   
    return c;
}

t_class *jit_functor_lookup(t_symbol *categoryname, t_symbol *classname)
{
    t_class *c=NULL;

    hashtab_lookup(_jit_functor_hashtab,classname,(t_jit_object **)&c);
    if (categoryname) {
        if (c&&jit_functor_category_match(c,categoryname))
            return c;
        else 
            return NULL;
    }           
    return c;
}

t_jit_err jit_functor_new_object_with_interface(
    t_jit_object **ob, t_jit_functor_interface **fi,
    t_symbol *category, t_symbol *classname)
{
    t_class *c = NULL;

    if(ob && fi && classname)
    {
        // lookup the object in the functor registry
        c = jit_functor_lookup_relaxed(category, classname);
        if(!c) return JIT_ERR_INVALID_PTR;

        // create a new functor object
        (*ob) = NULL;
        (*ob) = jit_object_new(c->c_sym);
        if(!(*ob)) return JIT_ERR_INVALID_PTR;

        // get the functor interface
        (*fi) = NULL;
        (*fi) = class_extra_lookup(c, gensym("functor_interface"));
        if(!(*fi)) return JIT_ERR_INVALID_PTR;

        return JIT_ERR_NONE;
    }

    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_wrapper_init(
    t_jit_functor_wrapper *e, t_symbol *category, t_symbol *classname)
{
    if(e && classname)
    {
        if(e->ob)
        {
            jit_object_free(e->ob);
            e->ob = NULL;
        }

        return jit_functor_new_object_with_interface(&e->ob, &e->fm, category, classname);
    }

    return JIT_ERR_INVALID_PTR;
}

// default functions for fixed and float32. strongly recommend defining the functions
// to avoid message lookup overhead
long jit_functor_eval_fixed(t_jit_object *x, long dimcount, long *vals)
{
    t_jit_functor_float64_sig fp;
    fp = (t_jit_functor_float64_sig) object_getmethod(x,ps_evalfloat64);

    return jit_functor_eval_fixed_with_float64(x,dimcount,vals,fp);
}

float jit_functor_eval_float32(t_jit_object *x, long dimcount, float *vals)
{
    t_jit_functor_float64_sig fp;
    fp = (t_jit_functor_float64_sig) object_getmethod(x,ps_evalfloat64);

    return jit_functor_eval_float32_with_float64(x,dimcount,vals,fp);
}

// to be called from javascript/java via atom/message based interface
t_jit_err jit_functor_eval_typed(t_jit_object *x, t_symbol *s, long ac, t_atom *av, t_atom *rv)
{
    long i;
    float v,f[256];
    t_jit_functor_float32_sig fp;
    fp = (t_jit_functor_float32_sig) object_getmethod(x,ps_evalfloat32);

    ac = MIN(ac,256);
    for (i=0;i<ac;i++)
        f[i] = atom_getfloat(av+i);

    // later could parse typed argument list for attribute style arguments.
    v = (*fp)(x,ac,f);
    atom_setfloat(rv,v);
    return JIT_ERR_NONE;
}

long jit_functor_eval_fixed_with_float32(t_jit_object *x, long dimcount, long *vals, t_jit_functor_float32_sig fp)
{
    long i;
    float fvals[256];

    dimcount = MIN(dimcount,256);
    for (i=0;i<dimcount;i++)
        fvals[i] = FixedToFloat(vals[i]);
    return FloatToFixed((*fp)(x,dimcount,fvals));
}

long jit_functor_eval_fixed_with_float64(t_jit_object *x, long dimcount, long *vals, t_jit_functor_float64_sig fp)
{
    long i;
    double dvals[256];

    dimcount = MIN(dimcount,256);
    for (i=0;i<dimcount;i++)
        dvals[i] = FixedToDouble(vals[i]);
    return DoubleToFixed((*fp)(x,dimcount,dvals));
}

float jit_functor_eval_float32_with_fixed(t_jit_object *x, long dimcount, float *vals, t_jit_functor_fixed_sig fp)
{
    long i;
    long fixvals[256];

    dimcount = MIN(dimcount,256);
    for (i=0;i<dimcount;i++)
        fixvals[i] = FloatToFixed(vals[i]);
    return FixedToFloat((*fp)(x,dimcount,fixvals));
}

float jit_functor_eval_float32_with_float64(t_jit_object *x, long dimcount, float *vals, t_jit_functor_float64_sig fp)
{
    long i;
    double dvals[256];

    dimcount = MIN(dimcount,256);
    for (i=0;i<dimcount;i++)
        dvals[i] = vals[i];
    return (float) (*fp)(x,dimcount,dvals);
}

double jit_functor_eval_float64_with_fixed(t_jit_object *x, long dimcount, double *vals, t_jit_functor_fixed_sig fp)
{
    long i;
    long fixvals[256];

    dimcount = MIN(dimcount,256);
    for (i=0;i<dimcount;i++)
        fixvals[i] = DoubleToFixed(vals[i]);
    return FixedToDouble((*fp)(x,dimcount,fixvals));
}

double jit_functor_eval_float64_with_float32(t_jit_object *x, long dimcount, double *vals, t_jit_functor_float32_sig fp)
{
    long i;
    float fvals[256];

    dimcount = MIN(dimcount,256);
    for (i=0;i<dimcount;i++)
        fvals[i] = vals[i];
    return (double) (*fp)(x,dimcount,fvals);
}

long jit_functor_eval_fixed_with_scalar_product(t_jit_object *x, long dimcount, long *vals, t_jit_functor_fixed_scalar_sig fp)
{
    long i;
    long rval=(*fp)(x,vals[0]);

    for (i=1;i<dimcount;i++) {
        //rval = FixMul(rval,(*fp)(x,vals[i]));
        // a little more precision than FixMul() since we assume values are in the range -fixed1 to fixed1
        rval = ((rval>>4L)*(((*fp)(x,vals[i]))>>4L))>>8L;
    }
    return rval;
}

float jit_functor_eval_float32_with_scalar_product(t_jit_object *x, long dimcount, float *vals, t_jit_functor_float32_scalar_sig fp)
{
    long i;
    float rval=(*fp)(x,vals[0]);

    for (i=1;i<dimcount;i++) {
        rval *= (*fp)(x,vals[i]);
    }
    return rval;
}

double jit_functor_eval_float64_with_scalar_product(t_jit_object *x, long dimcount, double *vals, t_jit_functor_float64_scalar_sig fp)
{
    long i;
    double rval=(*fp)(x,vals[0]);

    for (i=1;i<dimcount;i++) {
        rval *= (*fp)(x,vals[i]);
    }
    return rval;
}

long jit_functor_eval_fixed_with_scalar_sum(t_jit_object *x, long dimcount, long *vals, t_jit_functor_fixed_scalar_sig fp)
{
    long i;
    long rval=(*fp)(x,vals[0]);

    for (i=1;i<dimcount;i++) {
        rval += (*fp)(x,vals[i]);
    }
    return rval;
}

float jit_functor_eval_float32_with_scalar_sum(t_jit_object *x, long dimcount, float *vals, t_jit_functor_float32_scalar_sig fp)
{
    long i;
    float rval=(*fp)(x,vals[0]);

    for (i=1;i<dimcount;i++) {
        rval += (*fp)(x,vals[i]);
    }
    return rval;
}

double jit_functor_eval_float64_with_scalar_sum(t_jit_object *x, long dimcount, double *vals, t_jit_functor_float64_scalar_sig fp)
{
    long i;
    double rval=(*fp)(x,vals[0]);

    for (i=1;i<dimcount;i++) {
        rval += (*fp)(x,vals[i]);
    }
    return rval;
}

long jit_functor_eval_fixed_with_lut_wrap_product(t_jit_object *x, long dimcount, long *vals, long *fixlut)
{
    long rval;
    long i,j;

    j = vals[0]%fixed1;
    if (j<0) j += fixed1;
    rval = fixlut[j];

    for (i=1;i<dimcount;i++) {
        j = vals[i]%fixed1;
        if (j<0) j += fixed1;
        // a little more precision than FixMul() since we assume values are in the range -fixed1 to fixed1
        rval = ((rval>>4L)*(fixlut[j]>>4L))>>8L;
    }

    return rval;
}

long jit_functor_eval_fixed_with_lut_wrap_sum(t_jit_object *x, long dimcount, long *vals, long *fixlut)
{
    long rval;
    long i,j;

    j = vals[0]%fixed1;
    if (j<0) j += fixed1;
    rval = fixlut[j];

    for (i=1;i<dimcount;i++) {
        j = vals[i]%fixed1;
        if (j<0) j += fixed1;
        // a little more precision than FixMul() since we assume values are in the range -fixed1 to fixed1
        rval += fixlut[j];
    }

    return rval;
}

long jit_functor_eval_fixed_with_lut_clip_product(t_jit_object *x, long dimcount, long *vals, long *fixlut)
{
    long rval;
    long i,j;

    j = CLAMP(vals[0],0,fixed1-1);
    rval = fixlut[j];

    for (i=1;i<dimcount;i++) {
        j = CLAMP(vals[i],0,fixed1-1);
        // a little more precision than FixMul() since we assume values are in the range -fixed1 to fixed1
        rval = ((rval>>4L)*(fixlut[j]>>4L))>>8L;
    }

    return rval;
}

long jit_functor_eval_fixed_with_lut_clip_sum(t_jit_object *x, long dimcount, long *vals, long *fixlut)
{
    long rval;
    long i,j;

    j = CLAMP(vals[0],0,fixed1-1);
    rval = fixlut[j];

    for (i=1;i<dimcount;i++) {
        j = CLAMP(vals[i],0,fixed1-1);
        // a little more precision than FixMul() since we assume values are in the range -fixed1 to fixed1
        rval += fixlut[j];
    }

    return rval;
}

t_jit_err jit_functor_combined_dynarray_init(
    t_jit_functor_combined_dynarray *x, long count)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;

    if(jit_functor_combined_dynarray_destroy(x))
        return JIT_ERR_INVALID_PTR;

    x->count = count;
    x->fixed = (long*)jit_newptr(x->count * sizeof(long));
    if(!x->fixed) 
        return JIT_ERR_INVALID_PTR;

    x->float32 = (float*)jit_newptr(x->count * sizeof(float));
    if(!x->float32) 
        return JIT_ERR_INVALID_PTR;

    x->float64 = (double*)jit_newptr(x->count * sizeof(double));
    if(!x->float64) 
        return JIT_ERR_INVALID_PTR;

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_combined_dynarray_destroy(
    t_jit_functor_combined_dynarray *x)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;

    // free any allocated mem
    if(x->fixed) 
        jit_disposeptr((char *)x->fixed);
    x->fixed = NULL;

    if(x->float32) 
        jit_disposeptr((char *)x->float32);
    x->float32 = NULL;

    if(x->float64) 
        jit_disposeptr((char *)x->float64);
    x->float64 = NULL;

    x->count = 0;

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_setattr(t_jit_object *x, t_symbol *s, long ac, t_atom *av)
{
    t_symbol *subfun;
    method m;
    t_jit_object *o;
    t_jit_err err = JIT_ERR_NONE;
    static method mf=NULL;

    
    if (ac && (subfun=jit_atom_getsym(av)) && (subfun!=_jit_sym_nothing))  {
        if (!mf)
            mf = jit_object_getmethod(NULL,NULL);
        m = jit_object_getmethod(x,ps_subfunctor);
        if (m!=mf) {
            o = (*m)(x,subfun); // get which object if any
            if (o&&ac>2)        // ac = 1 == method name, ac > 2 == other arguments 
                err = object_method_typed(o,s,ac-1,av+1,NULL); // call method on object
            else                // ac = 1 == attr name, ac = 2 == attr value
                err = object_attr_setvalueof(x,subfun,ac-1,av+1); // subfun as attrname
        } else {
            err = object_attr_setvalueof(x,subfun,ac-1,av+1); // subfun as attrname
        }
        return err;
    }   
    return JIT_ERR_GENERIC;
}

/*
t_jit_err jit_functor_getattr(t_jit_object *x, t_symbol *s, long ac, t_atom *av, t_atom *rv);
deal with getattr later
*/

Copyright © 2008, Cycling '74