Knowing the size of a Variable argument list

[Hamid Mushtaq]

Is there a way to know the size of a variable argument list, without using a sentinel parameter.
For example, I have a function as below: -

void AssignArray(double* array, double first, ...);

and I used it as follows : -
AssignArray(array, 5.0, 6.0, 7.0);
Is there a way to determine that 3 parameters were passed to the function?

[dayknight]

I do not know the answer, but wouldn't the compiler give errors for not sending the exact numbers of parameters.
and what use would it be for knowing how many parameters are being passed?, since u already know how many u r suppose to send...

[Yves M]

No there is no other way. Using a sentinel parameter is the only option.

[Paul McKenzie]

Originally posted by Hamid Mushtaq
Is there a way to determine that 3 parameters were passed to the function?

Without any information, no. The number of arguments that are passed in a variable argument list is determined by either a sentinel value, or some other parameter that indicates the number of values, or some other value in your code that you've generated.

For example, you can do this:

void AssignArray(double* array, int numitems, double first, ...);

where "numitems" is the number of doubles in the variable argument list. Note that functions such as printf() use a format string to determine the number and type of the arguments. So you have a few options, but one option you don't have is a way to know the number of arguments without explicit information in your code somewhere.

Regards,

Paul McKenzie

[sephiroth2m]

I think there's at least one way to do this.
With __cdecl convention, the caller take the responsibility to setup and clear the callee's params. Looking at this in the caller:

 
//...
call AssignArray
add esp,NNNN
//...

'NNNN' is the number of bytes the callee's actual params take. This divided by 4 (on 32-bit platforms) is the number of the actual params. Here's the code that gets 'NNNN'

 
BYTE b[3];//size of opcode 'add esp,NNNN'
unsigned int dst= (unsigned int)b;

_asm{
;copy 3 bytes from address [ebp+4] to b
mov esi,[ebp+4]
mov edi,dst
mov ecx,3
rep movsb
}
int nVar= (int)b[2]/4;//b[2]= 'NNNN'

[ebp+4] points to the address of 'add esp,NNNN', and nVar is the number of your actual params. I tested this with VC 7, but must be compiled with /Od (disable optimization) option, otherwise, [ebp+4] will be other value.

[Yves M]

Yeah, well, that's a real nice hack

I.e. don't use this

[Mick]

let me throw my distracted comment in, why not jsut count the args via va_args etc. I'll think of a hack later on...

edit: I'll even think later on...

[Yves M]

Originally posted by Mick
let me throw my distracted comment in, why not jsut count the args via va_args etc.

Because there is no terminator, and no means to know that you have arrived at the last argument. It's a good way to crash though

[Mick]

Originally posted by Yves M
Because there is no terminator, and no means to know that you have arrived at the last argument. It's a good way to crash though

brain fart

[cma]

Just came up on an article about variable-length argument lists: http://www.cprogramming.com/tutorial/lesson17.html

[Guysl]

That article doesn't put any new light on the problem
described at this post. still, you have, by the article example,
to use the first argument as the sentinel.