Gary Lee Nelson

I am working on a UB version of McCartney's pulse object. It compiled and

runs fine except that it ignores the arguments. I am guessing that I should

change the header to use argc and argv. Does anyone have an example of how

that works? There are four arguments (here t n d b) that may be omitted

/* function run to create a new instance of the Pulse class */

void *pulse_new(long t, long n, long d, long b)

x = (Pulse *)newobject(pulse_class); /* allocates memory and sticks

x->p_clock = clock_new(x, (method)pulse_tick);

x->p_tempo = (t==0) ? 120 : ((t500) ? 500 : t));

return (x); /* always return a copy of the created

I am working on a UB version of McCartney's pulse object.  It compiled and
runs fine except that it ignores the arguments.  I am guessing that I should
change the header to use argc and argv.  Does anyone have an example of how
that works?  There are four arguments (here t n d b) that may be omitted
with default values supplied as below.

/* function run to create a new instance of the Pulse class */
void *pulse_new(long t, long n, long d, long b)
{
    Pulse *x;

    x = (Pulse *)newobject(pulse_class);    /* allocates memory and sticks
in an inlet */

    intin(x,4);
    intin(x,3);
    intin(x,2);
    intin(x,1);
    x->p_out2 = intout(x);
    x->p_out1 = intout(x);
    x->p_clock = clock_new(x, (method)pulse_tick);
    x->p_tempo = (t==0) ? 120 : ((t500) ? 500 : t));
    x->p_durnumer = (n
    x->p_durdenom = (d
    x->p_maxbeats = (b
    x->p_changenumer = 0;
    x->p_changedenom = 0;
    x->p_onoff = 0;
    return (x);                    /* always return a copy of the created
object */
}

Cheers
Gary Lee Nelson
Oberlin College
www.timara.oberlin.edu/GaryLeeNelson

arguments-in-_new

What does your setup() function look like in main()? I think it should 

    setup((struct messlist **)&pulse_class, (method)pulse_new, 

(method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG, 

(I'm assuming pulse is an msp object...?)

On Fri, 13 Oct 2006, Gary Lee Nelson wrote:

> I am working on a UB version of McCartney's pulse object. It compiled and

> runs fine except that it ignores the arguments. I am guessing that I should

> change the header to use argc and argv. Does anyone have an example of how

> that works? There are four arguments (here t n d b) that may be omitted

> /* function run to create a new instance of the Pulse class */

> void *pulse_new(long t, long n, long d, long b)

> x = (Pulse *)newobject(pulse_class); /* allocates memory and sticks

> x->p_clock = clock_new(x, (method)pulse_tick);

> x->p_tempo = (t==0) ? 120 : ((t500) ? 500 : t));

> return (x); /* always return a copy of the created

What does your setup() function look like in main()?  I think it should 
read something like this:

 	setup((struct messlist **)&pulse_class, (method)pulse_new, 
(method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG, 
A_DEFLONG, A_DEFLONG, 0);

> I am working on a UB version of McCartney's pulse object.  It compiled and
> runs fine except that it ignores the arguments.  I am guessing that I should
> change the header to use argc and argv.  Does anyone have an example of how
> that works?  There are four arguments (here t n d b) that may be omitted
> with default values supplied as below.
>
> /* function run to create a new instance of the Pulse class */
> void *pulse_new(long t, long n, long d, long b)
> {
>    Pulse *x;
>
>    x = (Pulse *)newobject(pulse_class);    /* allocates memory and sticks
> in an inlet */
>
>    intin(x,4);
>    intin(x,3);
>    intin(x,2);
>    intin(x,1);
>    x->p_out2 = intout(x);
>    x->p_out1 = intout(x);
>    x->p_clock = clock_new(x, (method)pulse_tick);
>    x->p_tempo = (t==0) ? 120 : ((t500) ? 500 : t));
>    x->p_durnumer = (n
>    x->p_durdenom = (d
>    x->p_maxbeats = (b
>    x->p_changenumer = 0;
>    x->p_changedenom = 0;
>    x->p_onoff = 0;
>    return (x);                    /* always return a copy of the created
> object */
> }
>
>
> Cheers
> Gary Lee Nelson
> Oberlin College
> www.timara.oberlin.edu/GaryLeeNelson
>
>
>


> What does your setup() function look like in main()? I think it should 

> setup((struct messlist **)&pulse_class, (method)pulse_new, 

> (method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG, 

Well spotted. The code I sent him is really old and has this:

    setup(&pulse_class, pulse_new, 0L, (short)sizeof(Pulse),

        0L, A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0);

I remeber I once had a similar porblem and putting all the (method)s 

Additionally the dsp_free (or a private free function that does this 

> Gary --
>
> What does your setup() function look like in main()?  I think it should 
> read something like this:
>
>     setup((struct messlist **)&pulse_class, (method)pulse_new, 
> (method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG, 
> A_DEFLONG, A_DEFLONG, 0);

	/* set up the class */
	setup(&pulse_class, pulse_new, 0L, (short)sizeof(Pulse),
		0L, A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0);

I remeber I once had a similar porblem and putting all the (method)s 
there solved the problem.
Additionally the dsp_free (or a private free function that does this 
job) is missing here.

Pulse is McCartney's tempo object for Max - not MSP. Setup is this.

setup((t_messlist **)&pulse_class, (method)pulse_new,0L,

I replaced the new function with this borrowed from forgotten code by some

void *pulse_new(t_symbol *s, short argc, t_atom *argv)

case A_FLOAT: t = argv->a_w.w_float;break;

case A_FLOAT: n = argv->a_w.w_float;break;

case A_FLOAT: d = argv->a_w.w_float;break;

case A_FLOAT: b = argv->a_w.w_float;break;

On 10/13/06 1:51 PM, "Bradford Garton" wrote:

> What does your setup() function look like in main()? I think it should

> setup((struct messlist **)&pulse_class, (method)pulse_new,

> (method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG,

> (I'm assuming pulse is an msp object...?)

> On Fri, 13 Oct 2006, Gary Lee Nelson wrote:

>> I am working on a UB version of McCartney's pulse object. It compiled and

>> runs fine except that it ignores the arguments. I am guessing that I should

>> change the header to use argc and argv. Does anyone have an example of how

>> that works? There are four arguments (here t n d b) that may be omitted

>> with default values supplied as below.

>> /* function run to create a new instance of the Pulse class */

>> void *pulse_new(long t, long n, long d, long b)

>> x = (Pulse *)newobject(pulse_class); /* allocates memory and sticks

>> x->p_clock = clock_new(x, (method)pulse_tick);

>> x->p_tempo = (t==0) ? 120 : ((t500) ? 500 : t));

>> return (x); /* always return a copy of the created

Pulse is McCartney's tempo object for Max - not MSP.  Setup is this.

    setup((t_messlist **)&pulse_class, (method)pulse_new,0L,
(short)sizeof(Pulse), 0L, A_GIMME, 0);

I replaced the new function with this borrowed from forgotten code by some
guy named Gary Nelson.  It now works.

/* function run to create a new instance of the Pulse class */
void *pulse_new(t_symbol *s, short argc, t_atom *argv)
{
    Pulse *x;
    long t,n,d,b = 0;
    x = (Pulse *)newobject(pulse_class);    /* allocates memory and sticks
in an inlet */

    intin(x,4);
    intin(x,3);
    intin(x,2);
    intin(x,1);

    if (argc)
    {
        switch(argv->a_type)
        {
            case A_LONG: t = argv->a_w.w_long;break;
            case A_FLOAT: t = argv->a_w.w_float;break;
        }
        argv++;
        argc--;
    } else t = 0;
    if (argc)
    {
        switch(argv->a_type)
        {
            case A_LONG: n = argv->a_w.w_long;break;
            case A_FLOAT: n = argv->a_w.w_float;break;
        }
        argv++;
        argc--;
    } else n = 0;
    if (argc)
    {
        switch(argv->a_type)
        {
            case A_LONG: d = argv->a_w.w_long;break;
            case A_FLOAT: d = argv->a_w.w_float;break;
        }
        argv++;
        argc--;
    } else d = 0;
    if (argc)
    {
        switch(argv->a_type)
        {
            case A_LONG: b = argv->a_w.w_long;break;
            case A_FLOAT: b = argv->a_w.w_float;break;
        }
        argv++;
        argc--;
    } else b = 0;

    x->p_out2 = intout(x);
    x->p_out1 = intout(x);
    x->p_clock = clock_new(x, (method)pulse_tick);
    x->p_tempo = (t==0) ? 120 : ((t500) ? 500 : t));
    x->p_durnumer = (n
    x->p_durdenom = (d
    x->p_maxbeats = (b
    x->p_changenumer = 0;
    x->p_changedenom = 0;
    x->p_onoff = 0;
    return (x);                    /* always return a copy of the created
object */
}

On 10/13/06 1:51 PM, "Bradford Garton"  wrote:

> Gary --
>
> What does your setup() function look like in main()?  I think it should
> read something like this:
>
> setup((struct messlist **)&pulse_class, (method)pulse_new,
> (method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG,
> A_DEFLONG, A_DEFLONG, 0);
>
> (I'm assuming pulse is an msp object...?)
>
> brad
> http://music.columbia.edu/~brad
>
>
> On Fri, 13 Oct 2006, Gary Lee Nelson wrote:
>
>> I am working on a UB version of McCartney's pulse object.  It compiled and
>> runs fine except that it ignores the arguments.  I am guessing that I should
>> change the header to use argc and argv.  Does anyone have an example of how
>> that works?  There are four arguments (here t n d b) that may be omitted
>> with default values supplied as below.
>>
>> /* function run to create a new instance of the Pulse class */
>> void *pulse_new(long t, long n, long d, long b)
>> {
>>    Pulse *x;
>>
>>    x = (Pulse *)newobject(pulse_class);    /* allocates memory and sticks
>> in an inlet */
>>
>>    intin(x,4);
>>    intin(x,3);
>>    intin(x,2);
>>    intin(x,1);
>>    x->p_out2 = intout(x);
>>    x->p_out1 = intout(x);
>>    x->p_clock = clock_new(x, (method)pulse_tick);
>>    x->p_tempo = (t==0) ? 120 : ((t500) ? 500 : t));
>>    x->p_durnumer = (n
>>    x->p_durdenom = (d
>>    x->p_maxbeats = (b
>>    x->p_changenumer = 0;
>>    x->p_changedenom = 0;
>>    x->p_onoff = 0;
>>    return (x);                    /* always return a copy of the created
>> object */
>> }
>>
>>
>> Cheers
>> Gary Lee Nelson
>> Oberlin College
>> www.timara.oberlin.edu/GaryLeeNelson
>>
>>
>>

I expected that the code would be old so I went over it carefully removing

the A4 references and dependence on a resource file for the assist messages.

I just posted the whole thing on my download page - link below. Thanks so

On 10/13/06 2:00 PM, "Olaf Matthes" wrote:

>> What does your setup() function look like in main()? I think it should

>> setup((struct messlist **)&pulse_class, (method)pulse_new,

>> (method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG,

> Well spotted. The code I sent him is really old and has this:

> setup(&pulse_class, pulse_new, 0L, (short)sizeof(Pulse),

> 0L, A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0);

> I remeber I once had a similar porblem and putting all the (method)s

> Additionally the dsp_free (or a private free function that does this

I expected that the code would be old so I went over it carefully removing
the A4 references and dependence on a resource file for the assist messages.
I just posted the whole thing on my download page - link below.  Thanks so
much Olaf.

On 10/13/06 2:00 PM, "Olaf Matthes"  wrote:

> Bradford Garton wrote:
>
>> Gary --
>>
>> What does your setup() function look like in main()?  I think it should
>> read something like this:
>>
>>     setup((struct messlist **)&pulse_class, (method)pulse_new,
>> (method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG,
>> A_DEFLONG, A_DEFLONG, 0);
>
> Well spotted. The code I sent him is really old and has this:
>
> /* set up the class */
> setup(&pulse_class, pulse_new, 0L, (short)sizeof(Pulse),
> 0L, A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0);
>
>
> I remeber I once had a similar porblem and putting all the (method)s
> there solved the problem.
> Additionally the dsp_free (or a private free function that does this
> job) is missing here.
>
> Olaf


This dialog is interesting, but does nothing to explain Gary's problem.

The only difference between Brad's and Olaf's code are typecasts. The stack is set up identically in either case (bar the NULL vs. dsp_free item, but since Gary has confirmed that pulse is plain-vanilla Max, that ain't an issue). And since Gary was complaining about runtime issues, not compiler warnings (of which he presumably has legions, it is not possible to compile a Max object in XCode without spurious warnings), the question remains:

Why was (... A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0) not working?

Can anyone else confirm this? Unfortunately (as I've mentioned elsewhere) I can't run XCode on my road machine, so I can't try this myself. If four A_DEFLONGs won't work in Mach-O externs, that's worth knowing about.

It's true that A_GIMME seems to be the future (it's required of pattr-savvy objects), but there are still lots of objects using A_DEFLONG, A_DEFFLOAT, and A_DEFSYM.

Finally, a word to Gary: looking at your code, what happens if the user is naughty and types a symbol in your object's argument list? Typnig misteaks ni arugmnet lsits happne moer ofetn thna w eliketo thnik. (Examining your code closely, what happens isn't disastrous but is not conventional behavior either.) You might want to make use of the new argv/argc parsing functions that were introduced with the Max 4.0 API and/or add some type checking.

Quote: Olaf Matthes wrote on Fri, 13 October 2006 20:00

----------------------------------------------------

> > What does your setup() function look like in main()? I think it should 

> > setup((struct messlist **)&pulse_class, (method)pulse_new, 

> > (method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG, 

>     setup(&pulse_class, pulse_new, 0L, (short)sizeof(Pulse),

>         0L, A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0);

> I remeber I once had a similar porblem and putting all the (method)s 

> Additionally the dsp_free (or a private free function that does this 

It's true that A_GIMME seems to be the future (it's required of pattr-savvy objects), but there are still lots of objects using A_DEFLONG, A_DEFFLOAT, and A_DEFSYM. 

Quote: Olaf Matthes wrote on Fri, 13 October 2006 20:00
----------------------------------------------------
> Bradford Garton wrote:
>
> > Gary --
> >
> > What does your setup() function look like in main()?  I think it should 
> > read something like this:
> >
> >     setup((struct messlist **)&pulse_class, (method)pulse_new, 
> > (method)dsp_free, (short)sizeof(t_pulse), 0L, A_DEFLONG, A_DEFLONG, 
> > A_DEFLONG, A_DEFLONG, 0);
>
> Well spotted. The code I sent him is really old and has this:
>
> 	/* set up the class */
> 	setup(&pulse_class, pulse_new, 0L, (short)sizeof(Pulse),
> 		0L, A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0);
>
>
> I remeber I once had a similar porblem and putting all the (method)s 
> there solved the problem.
> Additionally the dsp_free (or a private free function that does this 
> job) is missing here.
>
> Olaf
>
----------------------------------------------------


On Sat, 14 Oct 2006, Peter Castine wrote:

> The only difference between Brad's and Olaf's code are typecasts.

Right -- I had asked Gary because I didn't know how he was using the 

setup(). I was also surprised that the typecasts would have made a 

> Why was (... A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0) not working?

I grabbed that from another object where the params were indeed recognized 

Right -- I had asked Gary because I didn't know how he was using the 
setup().  I was also surprised that the typecasts would have made a 
difference.

I grabbed that from another object where the params were indeed recognized 
properly.

> On Sat, 14 Oct 2006, Peter Castine wrote:

> > The only difference between Brad's and Olaf's code are typecasts.

> Right -- I had asked Gary because I didn't know how he was

> setup(). I was also surprised that the typecasts would have

> > Why was (... A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0) not working?

Another reason this is dangerous is that IIRC there is an arbitrary limit (maybe floats only, I forget) to how many of these arguments you can call for. Five in a row could cause parameter passing to mysteriously choke.

Definitely. It's just too bad you never get to write A_GIMME, A_GIMME, A_GIMME, in honor of Black Flag.

--- Original Message ---
> On Sat, 14 Oct 2006, Peter Castine wrote:
>
> > The only difference between Brad's and Olaf's code are typecasts.
>
> Right -- I had asked Gary because I didn't know how he was
> using the 
> setup().  I was also surprised that the typecasts would have
> made a 
> difference.
>
> > Why was (... A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0) not working?
>

Arguments in *_new