variable argument va_arg does not work with icu u_vformatMessag e

[braj]

Hi Friends,
I was trying a test code to use the icu stuff with variable arguments
and I seem to be heading nowhere.

Can anyone please help.
Given below is the test code and the Output.

Thanks a ton in advance
-braj
#include <stdio.h>
#include <stdarg.h>

#include "unicode/utypes.h"
#include <stdlib.h>
#include <string.h>
#include "unicode/uloc.h"
#include "unicode/umsg.h"
#include "unicode/urename.h"
#include "unicode/ustring.h" /* required for UERROR CODE u_strlen
etc... */

void msgCall(const char *msgid, char *type, ...);

int main()
{
printf("here is goes \n");

msgCall("MSG_VF I_E0332", "HELLO" , "%s: something %s : follows : %s
nothing\n", "ONE", "TWO", "THREE");

return 0;
}

void msgCall(const char *msgid, char *type, ...)
{
char *fmt = NULL, *lfmt = NULL, *lmsg = NULL, *msg = NULL;
va_list ap;
char *finalstr;
UChar *result;
UChar pattern[2048];
int32_t resultlength, resultLengthOut ;
UErrorCode status = U_ZERO_ERROR;
char *message = "CLI Tool {0} could not be {1} found with {2}
ending";
int len = 0;
u_uastrcpy(patt ern, message);

va_start(ap, type);
fmt = va_arg(ap, char *);

resultlength=0;
resultLengthOut =u_vformatMessa ge("en_US", pattern, resultlength,
NULL, resultlength, ap, &status);
if(status == U_BUFFER_OVERFL OW_ERROR) {
status = U_ZERO_ERROR;
resultlength = resultLengthOut +1;
result = (UChar *)malloc(sizeof (UChar) * resultlength);
u_vformatMessag e("en_US", pattern, resultlength, result,
resultlength, ap, &status);
}
len = u_strlen(result );
finalstr = (char*)malloc(s izeof(char) * (len + 1));
u_austrcpy(fina lstr, result);

printf("finalst r = [%s]\n", finalstr);
va_end(ap);
}
/* OUTPUT of the above */
here is goes
finalstr = [CLI Tool ä¹E could not be åOä¹E found with ä¡äEåOä¹E
ending]

[Chris Torek]

In article <11************ *********@j27g2 000cwj.googlegr oups.com>
braj <br**********@g mail.comwrote:

>Given below is the test code and the Output.

Most of these are not standard functions, so there is no predicting
what they require or do.

That said, however, if I replace most of your nonstandard code with
two Standard C functions, I see an immediate problem:

[nonstandard code deleted, Standard C added, as marked]

>#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

[stuff removed]

>
void msgCall(const char *msgid, char *type, ...);

int main()
{
printf("here is goes \n");

msgCall("MSG_VF I_E0332", "HELLO" , "%s: something %s : follows : %s \
nothing\n", "ONE", "TWO", "THREE");

return 0;
}

void msgCall(const char *msgid, char *type, ...)
{
char *fmt = NULL, *lfmt = NULL, *lmsg = NULL, *msg = NULL;
va_list ap;

[stuff removed]

va_start(ap, type);
fmt = va_arg(ap, char *);

[insertion of new, Standard C, function call:]

vprintf(fmt, ap);

[stuff removed]
[insertion of new, Standard C, function call, plus skeleton to make
it clearer why there are two calls:]

if (1 /* some condition that decides we should try again */) {
vprintf(fmt, ap);
}

[stuff removed]

va_end(ap);
}

If this new code is compiled and run, the output may (or may not)
be:

ONE: something TWO : follows : THREE nothing
ONE: something TWO : follows : THREE nothing

It seems to me that you are expecting this output. The problem
is that the output may, instead, be something more like:

ONE: something TWO : follows : THREE nothing
keq1: something 8%# : follows : >m,(==_ nothing

(or perhaps a crash when the "%s" directives try to follow invalid
pointers, for instance; in this case, typically the first line will
still get printed though).

The problem is that after calling vprintf() -- or indeed any
function, standard or user-written, that uses va_arg() to access
the various parameters -- the value stored in "ap" is officially
"dead". The only thing you can do is va_end() it. After that,
you can va_start() it again, in this case. (In C99, if you need
to use an "ap" more than once, you can va_copy() it as well.)

So, msgCall() might be better written, e.g.:

void msgCall(const char *msgid, char *type, const char *fmt, ...) {
va_list ap;

va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
if (1 /* replace with appropriate test */) {
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
}
}

However, note that any time you write a variadic function, you
probably should provide the "v" version of it, for the same reason
that the C library provides not only printf() but also vprintf().
This requires the new C99-specific "va_copy", however:

void msgCall(const char *msgid, char *type, const char *fmt, ...) {
va_list ap;

va_start(ap, fmt);
vmsgCall(msgid, type, fmt, ap);
va_end(ap);
}

void vmsgCall(const char *msgid, char *type, const char *fmt, va_list ap) {
va_list copy;

va_copy(ap, copy); /* make copy before we wreck the original */

vprintf(fmt, ap); /* now use (and wreck) ap */
if (1) {
vprintf(fmt, copy); /* and if we need to repeat, use/wreck copy */
}

va_end(copy); /* in any case, delete the copy we made */
}

If you lack C99 (or at least va_copy), you may be able to get away
with providing only the non-"v" version of msgCall, in the same way
that many programmers get away with using printf() and never needing
vprintf(). (But once you *do* need it, you really need it!)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.