git.oblomov.eu Git - wine/blob - dlls/msvcrt/printf.h

   1 /*
   2  * Copyright 2011 Piotr Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifdef PRINTF_WIDE
  20 #define APICHAR MSVCRT_wchar_t
  21 #define CONVCHAR char
  22 #define FUNC_NAME(func) func ## _w
  23 #else
  24 #define APICHAR char
  25 #define CONVCHAR MSVCRT_wchar_t
  26 #define FUNC_NAME(func) func ## _a
  27 #endif
  28
  29 typedef struct FUNC_NAME(pf_flags_t)
  30 {
  31     APICHAR Sign, LeftAlign, Alternate, PadZero;
  32     int FieldLength, Precision;
  33     APICHAR IntegerLength, IntegerDouble;
  34     APICHAR WideString;
  35     APICHAR Format;
  36 } FUNC_NAME(pf_flags);
  37
  38 struct FUNC_NAME(_str_ctx) {
  39     MSVCRT_size_t len;
  40     APICHAR *buf;
  41 };
  42
  43 static int FUNC_NAME(puts_clbk_str)(void *ctx, int len, const APICHAR *str)
  44 {
  45     struct FUNC_NAME(_str_ctx) *out = ctx;
  46
  47     if(!out->buf)
  48         return len;
  49
  50     if(out->len < len) {
  51         memcpy(out->buf, str, out->len);
  52         out->buf += out->len;
  53         out->len = 0;
  54         return -1;
  55     }
  56
  57     memcpy(out->buf, str, len*sizeof(APICHAR));
  58     out->buf += len;
  59     return len;
  60 }
  61
  62 static inline const APICHAR* FUNC_NAME(pf_parse_int)(const APICHAR *fmt, int *val)
  63 {
  64     *val = 0;
  65
  66     while(isdigit(*fmt)) {
  67         *val *= 10;
  68         *val += *fmt++ - '0';
  69     }
  70
  71     return fmt;
  72 }
  73
  74 /* pf_fill: takes care of signs, alignment, zero and field padding */
  75 static inline int FUNC_NAME(pf_fill)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx,
  76         int len, FUNC_NAME(pf_flags) *flags, BOOL left)
  77 {
  78     int i, r = 0, written;
  79
  80     if(flags->Sign && !(flags->Format=='d' || flags->Format=='i'))
  81         flags->Sign = 0;
  82
  83     if(left && flags->Sign) {
  84         flags->FieldLength--;
  85         if(flags->PadZero)
  86             r = pf_puts(puts_ctx, 1, &flags->Sign);
  87     }
  88     written = r;
  89
  90     if((!left && flags->LeftAlign) || (left && !flags->LeftAlign)) {
  91         APICHAR ch;
  92
  93         if(left && flags->PadZero)
  94             ch = '0';
  95         else
  96             ch = ' ';
  97
  98         for(i=0; i<flags->FieldLength-len && r>=0; i++) {
  99             r = pf_puts(puts_ctx, 1, &ch);
 100             written += r;
 101         }
 102     }
 103
 104
 105     if(r>=0 && left && flags->Sign && !flags->PadZero) {
 106         r = pf_puts(puts_ctx, 1, &flags->Sign);
 107         written += r;
 108     }
 109
 110     return r>=0 ? written : r;
 111 }
 112
 113 static inline int FUNC_NAME(pf_output_wstr)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx,
 114         const MSVCRT_wchar_t *str, int len, MSVCRT__locale_t locale)
 115 {
 116 #ifdef PRINTF_WIDE
 117     return pf_puts(puts_ctx, len, str);
 118 #else
 119     LPSTR out;
 120     int len_a = WideCharToMultiByte(locale->locinfo->lc_codepage, 0, str, len, NULL, 0, NULL, NULL);
 121
 122     out = HeapAlloc(GetProcessHeap(), 0, len_a);
 123     if(!out)
 124         return -1;
 125
 126     WideCharToMultiByte(locale->locinfo->lc_codepage, 0, str, len, out, len_a, NULL, NULL);
 127     len = pf_puts(puts_ctx, len_a, out);
 128     HeapFree(GetProcessHeap(), 0, out);
 129     return len;
 130 #endif
 131 }
 132
 133 static inline int FUNC_NAME(pf_output_str)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx,
 134         const char *str, int len, MSVCRT__locale_t locale)
 135 {
 136 #ifdef PRINTF_WIDE
 137     LPWSTR out;
 138     int len_w = MultiByteToWideChar(locale->locinfo->lc_codepage, 0, str, len, NULL, 0);
 139
 140     out = HeapAlloc(GetProcessHeap(), 0, len_w*sizeof(WCHAR));
 141     if(!out)
 142         return -1;
 143
 144     MultiByteToWideChar(locale->locinfo->lc_codepage, 0, str, len, out, len_w);
 145     len = pf_puts(puts_ctx, len_w, out);
 146     HeapFree(GetProcessHeap(), 0, out);
 147     return len;
 148 #else
 149     return pf_puts(puts_ctx, len, str);
 150 #endif
 151 }
 152
 153 static inline int FUNC_NAME(pf_output_format_wstr)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx,
 154         const MSVCRT_wchar_t *str, int len, FUNC_NAME(pf_flags) *flags, MSVCRT__locale_t locale)
 155 {
 156     int r, ret;
 157
 158     if(len < 0)
 159         len = strlenW(str);
 160
 161     if(flags->Precision>=0 && flags->Precision<len)
 162         len = flags->Precision;
 163
 164     r = FUNC_NAME(pf_fill)(pf_puts, puts_ctx, len, flags, TRUE);
 165     ret = r;
 166     if(r >= 0) {
 167         r = FUNC_NAME(pf_output_wstr)(pf_puts, puts_ctx, str, len, locale);
 168         ret += r;
 169     }
 170     if(r >= 0) {
 171         r = FUNC_NAME(pf_fill)(pf_puts, puts_ctx, len, flags, FALSE);
 172         ret += r;
 173     }
 174
 175     return r>=0 ? ret : r;
 176 }
 177
 178 static inline int FUNC_NAME(pf_output_format_str)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx,
 179         const char *str, int len, FUNC_NAME(pf_flags) *flags, MSVCRT__locale_t locale)
 180 {
 181     int r, ret;
 182
 183     if(len < 0)
 184         len = strlen(str);
 185
 186     if(flags->Precision>=0 && flags->Precision<len)
 187         len = flags->Precision;
 188
 189     r = FUNC_NAME(pf_fill)(pf_puts, puts_ctx, len, flags, TRUE);
 190     ret = r;
 191     if(r >= 0) {
 192         r = FUNC_NAME(pf_output_str)(pf_puts, puts_ctx, str, len, locale);
 193         ret += r;
 194     }
 195     if(r >= 0) {
 196         r = FUNC_NAME(pf_fill)(pf_puts, puts_ctx, len, flags, FALSE);
 197         ret += r;
 198     }
 199
 200     return r>=0 ? ret : r;
 201 }
 202
 203 static inline int FUNC_NAME(pf_handle_string)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx,
 204         const void *str, int len, FUNC_NAME(pf_flags) *flags, MSVCRT__locale_t locale)
 205 {
 206 #ifdef PRINTF_WIDE
 207     static const MSVCRT_wchar_t nullW[] = {'(','n','u','l','l',')',0};
 208
 209     if(!str)
 210         return FUNC_NAME(pf_output_format_wstr)(pf_puts, puts_ctx, nullW, 6, flags, locale);
 211 #else
 212     if(!str)
 213         return FUNC_NAME(pf_output_format_str)(pf_puts, puts_ctx, "(null)", 6, flags, locale);
 214 #endif
 215
 216     if(flags->WideString || flags->IntegerLength=='l')
 217         return FUNC_NAME(pf_output_format_wstr)(pf_puts, puts_ctx, str, len, flags, locale);
 218     if(flags->IntegerLength == 'h')
 219         return FUNC_NAME(pf_output_format_str)(pf_puts, puts_ctx, str, len, flags, locale);
 220
 221     if((flags->Format=='S' || flags->Format=='C') == (sizeof(APICHAR)==sizeof(MSVCRT_wchar_t)))
 222         return FUNC_NAME(pf_output_format_str)(pf_puts, puts_ctx, str, len, flags, locale);
 223     else
 224         return FUNC_NAME(pf_output_format_wstr)(pf_puts, puts_ctx, str, len, flags, locale);
 225 }
 226
 227 static inline void FUNC_NAME(pf_rebuild_format_string)(char *p, FUNC_NAME(pf_flags) *flags)
 228 {
 229     *p++ = '%';
 230     if(flags->Sign)
 231         *p++ = flags->Sign;
 232     if(flags->LeftAlign)
 233         *p++ = flags->LeftAlign;
 234     if(flags->Alternate)
 235         *p++ = flags->Alternate;
 236     if(flags->PadZero)
 237         *p++ = flags->PadZero;
 238     if(flags->FieldLength) {
 239         sprintf(p, "%d", flags->FieldLength);
 240         p += strlen(p);
 241     }
 242     if(flags->Precision >= 0) {
 243         sprintf(p, ".%d", flags->Precision);
 244         p += strlen(p);
 245     }
 246     *p++ = flags->Format;
 247     *p++ = 0;
 248 }
 249
 250 /* pf_integer_conv:  prints x to buf, including alternate formats and
 251    additional precision digits, but not field characters or the sign */
 252 static inline void FUNC_NAME(pf_integer_conv)(APICHAR *buf, int buf_len,
 253         FUNC_NAME(pf_flags) *flags, LONGLONG x)
 254 {
 255     unsigned int base;
 256     const char *digits;
 257     int i, j, k;
 258
 259     if(flags->Format == 'o')
 260         base = 8;
 261     else if(flags->Format=='x' || flags->Format=='X')
 262         base = 16;
 263     else
 264         base = 10;
 265
 266     if(flags->Format == 'X')
 267         digits = "0123456789ABCDEFX";
 268     else
 269         digits = "0123456789abcdefx";
 270
 271     if(x<0 && (flags->Format=='d' || flags->Format=='i')) {
 272         x = -x;
 273         flags->Sign = '-';
 274     }
 275
 276     i = 0;
 277     if(x==0 && flags->Precision)
 278         buf[i++] = '0';
 279     else {
 280         while(x != 0) {
 281             j = (ULONGLONG)x%base;
 282             x = (ULONGLONG)x/base;
 283             buf[i++] = digits[j];
 284         }
 285     }
 286     k = flags->Precision-i;
 287     while(k-- > 0)
 288         buf[i++] = '0';
 289     if(flags->Alternate) {
 290         if(base == 16) {
 291             buf[i++] = digits[16];
 292             buf[i++] = '0';
 293         } else if(base==8 && buf[i-1]!='0')
 294             buf[i++] = '0';
 295     }
 296
 297     /* Adjust precision so pf_fill won't truncate the number later */
 298     flags->Precision = i;
 299
 300     buf[i] = '\0';
 301     j = 0;
 302     while(--i > j) {
 303         APICHAR tmp = buf[j];
 304         buf[j] = buf[i];
 305         buf[i] = tmp;
 306         j++;
 307     }
 308 }
 309
 310 static inline void FUNC_NAME(pf_fixup_exponent)(char *buf)
 311 {
 312     char* tmp = buf;
 313
 314     while(tmp[0] && toupper(tmp[0])!='E')
 315         tmp++;
 316
 317     if(tmp[0] && (tmp[1]=='+' || tmp[1]=='-') &&
 318             isdigit(tmp[2]) && isdigit(tmp[3])) {
 319         char final;
 320
 321         if (isdigit(tmp[4]))
 322             return; /* Exponent already 3 digits */
 323
 324         tmp += 2;
 325         final = tmp[2];
 326         tmp[2] = tmp[1];
 327         tmp[1] = tmp[0];
 328         tmp[0] = '0';
 329
 330         if(final == '\0') {
 331             tmp[3] = '\0';
 332             if(buf[0] == ' ')
 333                 memmove(buf, buf + 1, (tmp - buf) + 3);
 334         }
 335     }
 336 }
 337
 338 int FUNC_NAME(pf_printf)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx, const APICHAR *fmt,
 339         MSVCRT__locale_t locale, BOOL positional_params, BOOL invoke_invalid_param_handler,
 340         args_clbk pf_args, void *args_ctx, __ms_va_list *valist)
 341 {
 342     const APICHAR *q, *p = fmt;
 343     APICHAR buf[32];
 344     int written = 0, pos, i;
 345     FUNC_NAME(pf_flags) flags;
 346
 347     TRACE("Format is: %s\n", FUNC_NAME(debugstr)(fmt));
 348
 349     if(!locale)
 350         locale = get_locale();
 351
 352     while(*p) {
 353         /* output characters before '%' */
 354         for(q=p; *q && *q!='%'; q++);
 355         if(p != q) {
 356             i = pf_puts(puts_ctx, q-p, p);
 357             if(i < 0)
 358                 return i;
 359
 360             written += i;
 361             p = q;
 362             continue;
 363         }
 364
 365         /* *p == '%' here */
 366         p++;
 367
 368         /* output a single '%' character */
 369         if(*p == '%') {
 370             i = pf_puts(puts_ctx, 1, p++);
 371             if(i < 0)
 372                 return i;
 373
 374             written += i;
 375             continue;
 376         }
 377
 378         /* check parameter position */
 379         if(positional_params && (q = FUNC_NAME(pf_parse_int)(p, &pos)) && *q=='$')
 380             p = q+1;
 381         else
 382             pos = -1;
 383
 384         /* parse the flags */
 385         memset(&flags, 0, sizeof(flags));
 386         while(*p) {
 387             if(*p=='+' || *p==' ') {
 388                 if(flags.Sign != '+')
 389                     flags.Sign = *p;
 390             } else if(*p == '-')
 391                 flags.LeftAlign = *p;
 392             else if(*p == '0')
 393                 flags.PadZero = *p;
 394             else if(*p == '#')
 395                 flags.Alternate = *p;
 396             else
 397                 break;
 398
 399             p++;
 400         }
 401
 402         /* parse the widh */
 403         if(*p == '*') {
 404             p++;
 405             if(positional_params && (q = FUNC_NAME(pf_parse_int)(p, &i)) && *q=='$')
 406                 p = q+1;
 407             else
 408                 i = -1;
 409
 410             flags.FieldLength = pf_args(args_ctx, i, VT_INT, valist).get_int;
 411             if(flags.FieldLength < 0) {
 412                 flags.LeftAlign = '-';
 413                 flags.FieldLength = -flags.FieldLength;
 414             }
 415         } else while(isdigit(*p)) {
 416             flags.FieldLength *= 10;
 417             flags.FieldLength += *p++ - '0';
 418         }
 419
 420         /* parse the precision */
 421         flags.Precision = -1;
 422         if(*p == '.') {
 423             flags.Precision = 0;
 424             p++;
 425             if(*p == '*') {
 426                 p++;
 427                 if(positional_params && (q = FUNC_NAME(pf_parse_int)(p, &i)) && *q=='$')
 428                     p = q+1;
 429                 else
 430                     i = -1;
 431
 432                 flags.Precision = pf_args(args_ctx, i, VT_INT, valist).get_int;
 433             } else while(isdigit(*p)) {
 434                 flags.Precision *= 10;
 435                 flags.Precision += *p++ - '0';
 436             }
 437         }
 438
 439         /* parse argument size modifier */
 440         while(*p) {
 441             if(*p=='l' && *(p+1)=='l') {
 442                 flags.IntegerDouble++;
 443                 p += 2;
 444             } else if(*p=='h' || *p=='l' || *p=='L') {
 445                 flags.IntegerLength = *p;
 446                 p++;
 447             } else if(*p == 'I') {
 448                 if(*(p+1)=='6' && *(p+2)=='4') {
 449                     flags.IntegerDouble++;
 450                     p += 3;
 451                 } else if(*(p+1)=='3' && *(p+2)=='2')
 452                     p += 3;
 453                 else if(isdigit(*(p+1)) || !*(p+1))
 454                     break;
 455                 else
 456                     p++;
 457             } else if(*p == 'w')
 458                 flags.WideString = *p++;
 459             else if(*p == 'F')
 460                 p++; /* ignore */
 461             else
 462                 break;
 463         }
 464
 465         flags.Format = *p;
 466
 467         if(flags.Format == 's' || flags.Format == 'S') {
 468             i = FUNC_NAME(pf_handle_string)(pf_puts, puts_ctx,
 469                     pf_args(args_ctx, pos, VT_PTR, valist).get_ptr,
 470                     -1,  &flags, locale);
 471         } else if(flags.Format == 'c' || flags.Format == 'C') {
 472             int ch = pf_args(args_ctx, pos, VT_INT, valist).get_int;
 473
 474             if((ch&0xff) != ch)
 475                 FIXME("multibyte characters printing not supported\n");
 476
 477             i = FUNC_NAME(pf_handle_string)(pf_puts, puts_ctx, &ch, 1, &flags, locale);
 478         } else if(flags.Format == 'p') {
 479             flags.Format = 'X';
 480             flags.PadZero = '0';
 481             i = flags.Precision;
 482             flags.Precision = 2*sizeof(void*);
 483             FUNC_NAME(pf_integer_conv)(buf, sizeof(buf)/sizeof(APICHAR), &flags,
 484                     pf_args(args_ctx, pos, VT_INT, valist).get_int);
 485             flags.PadZero = 0;
 486             flags.Precision = i;
 487
 488 #ifdef PRINTF_WIDE
 489             i = FUNC_NAME(pf_output_format_wstr)(pf_puts, puts_ctx, buf, -1, &flags, locale);
 490 #else
 491             i = FUNC_NAME(pf_output_format_str)(pf_puts, puts_ctx, buf, -1, &flags, locale);
 492 #endif
 493         } else if(flags.Format == 'n') {
 494             int *used;
 495
 496             if(!n_format_enabled) {
 497                 MSVCRT_INVALID_PMT("\'n\' format specifier disabled");
 498                 *MSVCRT__errno() = MSVCRT_EINVAL;
 499                 return -1;
 500             }
 501
 502             used = pf_args(args_ctx, pos, VT_PTR, valist).get_ptr;
 503             *used = written;
 504             i = 0;
 505         } else if(flags.Format && strchr("diouxX", flags.Format)) {
 506             APICHAR *tmp = buf;
 507             int max_len = (flags.FieldLength>flags.Precision ? flags.FieldLength : flags.Precision) + 10;
 508
 509             if(max_len > sizeof(buf)/sizeof(APICHAR))
 510                 tmp = HeapAlloc(GetProcessHeap(), 0, max_len);
 511             if(!tmp)
 512                 return -1;
 513
 514             if(flags.IntegerDouble)
 515                 FUNC_NAME(pf_integer_conv)(tmp, max_len, &flags, pf_args(args_ctx, pos,
 516                             VT_I8, valist).get_longlong);
 517             else if(flags.Format=='d' || flags.Format=='i')
 518                 FUNC_NAME(pf_integer_conv)(tmp, max_len, &flags, pf_args(args_ctx, pos,
 519                             VT_INT, valist).get_int);
 520             else
 521                 FUNC_NAME(pf_integer_conv)(tmp, max_len, &flags, (unsigned)pf_args(
 522                             args_ctx, pos, VT_INT, valist).get_int);
 523
 524 #ifdef PRINTF_WIDE
 525             i = FUNC_NAME(pf_output_format_wstr)(pf_puts, puts_ctx, tmp, -1, &flags, locale);
 526 #else
 527             i = FUNC_NAME(pf_output_format_str)(pf_puts, puts_ctx, tmp, -1, &flags, locale);
 528 #endif
 529             if(tmp != buf)
 530                 HeapFree(GetProcessHeap(), 0, tmp);
 531         } else if(flags.Format && strchr("aeEfgG", flags.Format)) {
 532             char fmt[20], buf_a[32], *tmp = buf_a, *decimal_point;
 533             int max_len = (flags.FieldLength>flags.Precision ? flags.FieldLength : flags.Precision) + 10;
 534
 535             if(max_len > sizeof(buf_a))
 536                 tmp = HeapAlloc(GetProcessHeap(), 0, max_len);
 537             if(!tmp)
 538                 return -1;
 539
 540             FUNC_NAME(pf_rebuild_format_string)(fmt, &flags);
 541
 542             sprintf(tmp, fmt, pf_args(args_ctx, pos, VT_R8, valist).get_double);
 543             if(toupper(flags.Format)=='E' || toupper(flags.Format)=='G')
 544                 FUNC_NAME(pf_fixup_exponent)(tmp);
 545
 546             decimal_point = strchr(tmp, '.');
 547             if(decimal_point)
 548                 *decimal_point = *locale->locinfo->lconv->decimal_point;
 549
 550             i = FUNC_NAME(pf_output_str)(pf_puts, puts_ctx, tmp, strlen(tmp), locale);
 551             if(tmp != buf_a)
 552                 HeapFree(GetProcessHeap(), 0, tmp);
 553         } else {
 554             if(invoke_invalid_param_handler) {
 555                 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
 556                 *MSVCRT__errno() = MSVCRT_EINVAL;
 557                 return -1;
 558             }
 559
 560             continue;
 561         }
 562
 563         if(i < 0)
 564             return i;
 565         written += i;
 566         p++;
 567     }
 568
 569     return written;
 570 }
 571
 572 #ifndef PRINTF_WIDE
 573 enum types_clbk_flags {
 574     TYPE_CLBK_VA_LIST = 1,
 575     TYPE_CLBK_POSITIONAL = 2,
 576     TYPE_CLBK_ERROR_POS = 4,
 577     TYPE_CLBK_ERROR_TYPE = 8
 578 };
 579
 580 /* This functions stores types of arguments. It uses args[0] internally */
 581 static printf_arg arg_clbk_type(void *ctx, int pos, int type, __ms_va_list *valist)
 582 {
 583     static const printf_arg ret;
 584     printf_arg *args = ctx;
 585
 586     if(pos == -1) {
 587         args[0].get_int |= TYPE_CLBK_VA_LIST;
 588         return ret;
 589     } else
 590         args[0].get_int |= TYPE_CLBK_POSITIONAL;
 591
 592     if(pos<1 || pos>MSVCRT__ARGMAX)
 593         args[0].get_int |= TYPE_CLBK_ERROR_POS;
 594     else if(args[pos].get_int && args[pos].get_int!=type)
 595         args[0].get_int |= TYPE_CLBK_ERROR_TYPE;
 596     else
 597         args[pos].get_int = type;
 598
 599     return ret;
 600 }
 601 #endif
 602
 603 static int FUNC_NAME(create_positional_ctx)(void *args_ctx, const APICHAR *format, __ms_va_list valist)
 604 {
 605     struct FUNC_NAME(_str_ctx) puts_ctx = {INT_MAX, NULL};
 606     printf_arg *args = args_ctx;
 607     int i, j;
 608
 609     i = FUNC_NAME(pf_printf)(FUNC_NAME(puts_clbk_str), &puts_ctx, format, NULL, TRUE, FALSE,
 610             arg_clbk_type, args_ctx, NULL);
 611     if(i < 0)
 612         return i;
 613
 614     if(args[0].get_int==0 || args[0].get_int==TYPE_CLBK_VA_LIST)
 615         return 0;
 616     if(args[0].get_int != TYPE_CLBK_POSITIONAL)
 617         return -1;
 618
 619     for(i=MSVCRT__ARGMAX; i>0; i--)
 620         if(args[i].get_int)
 621             break;
 622
 623     for(j=1; j<=i; j++) {
 624         switch(args[j].get_int) {
 625         case VT_I8:
 626             args[j].get_longlong = va_arg(valist, LONGLONG);
 627             break;
 628         case VT_INT:
 629             args[j].get_int = va_arg(valist, int);
 630             break;
 631         case VT_R8:
 632             args[j].get_double = va_arg(valist, double);
 633             break;
 634         case VT_PTR:
 635             args[j].get_ptr = va_arg(valist, void*);
 636             break;
 637         default:
 638             return -1;
 639         }
 640     }
 641
 642     return j;
 643 }
 644
 645 #undef APICHAR
 646 #undef CONVCHAR
 647 #undef FUNC_NAME