Dynamically creating variable length argument list

[Lost User]

The problem is the var1, var2, etc. part :). If they pass in just 2 parameters, I need to call wsprintf one way. If they pass 3, another way, and so on. I could potentially create a huge if statement with a call to the original function for each number of parameters. In that case, I assume you'd treat all the arguments as void *, but you'd have to put a limit on how many actual parameters you wanted to support. You could cover up to 10 parameters for instance, but the instant they pass 11, your function won't call the original correctly. I'd like to find the correct way to do this by dynamically creating the argument list with the arguments they passed in. I've seen built in functions that look like they would work on gcc, but I don't know what the VC++ equivalent would really be.

[David Crow]

Using wsprintf() as an example is kind of awkward since the format specifier governs the count/type of the arguments passed to the function. In any case, you're going to need to parse the format specifier and extract each argument appropriately. Once you have all of them, a call to wsprintf() can be made. I used to have the code for printf() but that was ages ago, so the closest I can come to now is the code for MFC's CString::Format() function. It's a rather long example of how to handle format specifiers. For each '%' found, you'll extract the appropriate type argument from the variable list, and store it in a variable. When the variable list has been exhausted, you can then call wsprintf(). So, if someone called wsprintf() like: wsprintf(szBuffer, "%c %d\n", 'c', 97); you'd end up with a char variable and an int variable. At the end of your hook function, you'd have something like: return wsprintf(lpOut, lpFmt, somechar, someint);

---

Five birds are sitting on a fence. Three of them decide to fly off. How many are left?

[WREY]

A simple approach might be to read the original parameters into a vector and then pass the vector to the function that will be responsible for reconstructing the parameter list. Doing something like this wouldn't affect the number of parameters present in the "wsprintf" function. If the original "wsprintf" function contains two parameters, then two parameters are what the vector will contain, but if it turns out that the "wsprintf" contains 3, or 4, or 5, (etc.) parameters, then that's the number of parameters the vector will contain. Afterwards, you simply pass the vector itself as a parameter to the function that will be responsible for reconstructing the new parameter list you will need. William Fortes in fide et opere!

[Kentamanos]

wsprintf vs. printf vs. CString::Format doesn't make too big of a difference in regard to this problem. Just to be clear, I could rewrite any of the above functions. The challenge lies in forwarding these function calls to their originals in a completely generic manner (no matter how many parameters are passed in). It's not a problem if I know the number of arguments they're going to pass every time. It's pretty trivial then to pull these arguments out (using the format specifiers in this case to pull them out based upon type) and make a call to wsprintf. It's also not a problem if I don't know how many arguments they're passing, but I don't need to forward the call and therefore I don't have to dynamically create a variable length argument list. The problem is they're passing me an unspecified number of arguments, and I have to forward that call regardless of the number. I'm trying to wrap a function (it's not actually wsprintf, it's just an example) with variable arguments, and I have no idea what the typical calling usage is. Think of the problem this way: Your mission is to write a replacement function for wsprintf, printf, or CString::Format (I don't really care which one we talk about). This function should write some debug info and forward the call to the original function no matter how the user calls the original function (in other words, no matter how many parameters they actually end up passing).

[Kentamanos]

This wouldn't work in this situation since I eventually need to pass the arguments to the original wsprintf function (in this example). Creating the vector would be easy. Taking that vector and reading out each argument would be easy. Calling wsprintf appropriately with these arguments would NOT be easy (perhaps impossible?). That's the problem in general. Create a variable length argument list on the fly. Since I'm doing a DLL Hook on a function, I get called exactly like the original function. I then want to do a bit of processing and then call the original function. There's no reason for me to put in an intermediate function that uses vectors to pass the variable length arguments since I still have to put a variable length argument list together (the whole problem to begin with).

[WREY]

While the vector approach (I previously mentioned) would work, I agree, it could be a pain to go that route. Perhaps a simpler approach might be to just pass the address of "wsprintf" itself as a parameter, and then activate its address (which would be activating wsprintf itself). IOW, handle wsprintf as a pointer to a function. The address of "wsprintf" is the name itself. Include the name as an extra parameter in the DLL Hook function that gets called, and at the appropriate time simply use it as you would at any other time. For example:

void DLLHookFunc(etc., wsprintf);
//then later do this
wsprintf(parameter1, ...);

William Fortes in fide et opere!

[Kentamanos]

Based upon a post on microsoft.public.vc.language I just made and got a response on, I think the best bet would be to make my function not affect the stack at all (declspec naked), possibly do some inline assembly to get the parameters passed in without affecting the stack (no pops), and then doing an assembly JMP to the original function. That would insure the parameters are on the stack just like they were passed in, and it would allow me not to worry about recreating the variable length argument list. It's going to be a pain to pull off with my assembly skills though :).

[WREY]

Good luck to you on whichever way you choose. I still think passing 'wsprintf' as a pointer parameter in the DLL Hook function and then later use it as you normally would, is the simplest way. ;) William Fortes in fide et opere!

[John R Shaw]

I keep returning to the days when I only programed in 'C'. The following should help, it is out of my old dos windowing library and is still valid even in 'C++' (MS).

int w_printf(
int r, /* row */
int c, /* column */
int color,/* color */
unsigned flags, /* formating flags */
const char *format, /* format (see printf())
... /* variable arguments */
)
{
int n=-1;
char *buf=NULL;
size_t size=0;
va_list ap;
va_start( ap,format );
while( n == -1 ) {
size += 128; /* change size */
if( buf ) free(buf); /* free old buffer */
buf = (char *)malloc(size); /* allocate new buffer */
if( !buf ) n = 0; /* allocation failer */
else n = _vsnprintf(buf,size,format,ap); /* do basic formating */
}
va_end(ap);
if( buf ) {
n = w_pfmt( r,c,color,flags,buf );
free(buf);
}
return n;
}

INTP

[David Crow]

Ok, how about:

int _wsprintf( LPTSTR lpOut, LPCTSTR lpFmt, ... )
{
va_list list;
int nReturn;

va\_start(list, lpFmt);
nReturn = wsprintf(lpOut, lpFmt, list);
va\_end(list);

return nReturn;

}

---

Five birds are sitting on a fence. Three of them decide to fly off. How many are left?

[Kentamanos]

I created a Win32 Console App to test this approach, and it created garbage for me. Did you get this method to work? Here is the code I used:

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

int MyWsprintf( LPTSTR lpOut, LPCTSTR lpFmt, ...) 
{	 
	va_list list;	  
	int	nReturn;	 
	va_start(list, lpFmt);	  
	nReturn	= wsprintf(lpOut, lpFmt, list);	   
	va_end(list);	  
	return nReturn;
}


int _tmain(int argc, _TCHAR* argv[])
{
	char buf[1024];

	MyWsprintf(buf, "%s %s %s", "test1", "test2", "test3");

	printf(buf);
}

If I change the call of MyWsprintf to the real wsprintf, it works great, indicating the problem is in the rewrite.

[Kentamanos]

I'm not quite sure what you mean by that. For simplicity sake, don't worry about the DLL Hook portion of this problem. Attempt to write a function that generically wraps printf for instance that you can call exactly like printf.

[David Crow]

That was a bad suggestion on my part (at least I thought it would work based on this code snippet). I guess the address that va_start() sets list to is not the same as the stack address that wsprintf() is popping arguments from.

---

Five birds are sitting on a fence. Three of them decide to fly off. How many are left?