On Sat, 2011-02-19 at 23:05 +0100, Roger Oberholtzer wrote:

On Sat, 2011-02-19 at 11:21 +0100, Per Jessen wrote:

...

What is the best/correct way of counting the number of args in vararg call:

int function( int blah, ... )

I've been googling a bit, and came across mentions of "vscprintf", in particular this alternative:

#define vscprintf(f,a) vsnprintf(NULL,0,f,a)

More's the pity, since the compiler knows how many things are on the stack.

The parameters don't really have to be on the stack either. It's implementation defined where the varargs are sent. va_start() is free to dynamically allocate memory on the heap for them There isn't a C standard for how to pass parameters. There is an x86 C calling convention, an x86_64 C calling convention, a SPARC C calling convention etc. (think stack vs. registers, for example). The language leaves that up to the implementation and only specifies how it should behave from the point of view of the C programs. The compiler doesn't even always know how large the stack is, between inline assembly and monstrosities like alloca() anything could happen. There is no guarantee that the function is called from another C binary. And on x86, the parameters are in the stack frame belonging to the previous function technically (before the base pointer, if such a thing is used), there is no way at all to know how much there is. The function needs to have some sort of convention, like the first parameter is the number of parameters, or a format string like printf, or that the argument list should be terminated by a NULL, or something. I don't think there is any other way. Anders -- To unsubscribe, e-mail: opensuse-programming+unsubscribe@opensuse.org For additional commands, e-mail: opensuse-programming+help@opensuse.org

On 02/20/2011 03:14 AM, Per Jessen wrote:

I was thinking that the compiler clearly knows how many arguments is puts on the stack, so perhaps that number was also pushed on the stack.

Certainly it is the compiler that sets up the stack. As others have said, the implementation has a calling convention. On the DEC Alpha, the first 6 parameters were placed into registers with the rest of the parameters (if any) on the stack. HP PA-RISC had a similar calling convention. Whether arguments are in registers or on the stack, C defines the behavior. The order in which parameters are placed on the stack or in registers is different in C than in other languages because C (and C++) allows for a variable number of parameters. While the compiler knows how many arguments it pushed onto the stack when calling a function, it does not really know how many arguments are actually on the stack in the called function. In some implementations, there is also a stack frame register that makes it easier to unroll the stack. But there are also other things stored in the stack, such as saved registers. But in general, there is no tag on the stack that indicates the number of parameters. -- Jerry Feldman <gaf@blu.org> Boston Linux and Unix PGP key id: 537C5846 PGP Key fingerprint: 3D1B 8377 A3C0 A5F2 ECBB CA3B 4607 4319 537C 5846