misc/wsprintf.c

   1 /*
   2  * wsprintf functions
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include <stdarg.h>
   8 #include <string.h>
   9 #include "windows.h"
  10 #include "ldt.h"
  11 #include "stackframe.h"
  12 #include "debug.h"
  13
  14
  15 #define WPRINTF_LEFTALIGN   0x0001  /* Align output on the left ('-' prefix) */
  16 #define WPRINTF_PREFIX_HEX  0x0002  /* Prefix hex with 0x ('#' prefix) */
  17 #define WPRINTF_ZEROPAD     0x0004  /* Pad with zeros ('0' prefix) */
  18 #define WPRINTF_LONG        0x0008  /* Long arg ('l' prefix) */
  19 #define WPRINTF_SHORT       0x0010  /* Short arg ('h' prefix) */
  20 #define WPRINTF_UPPER_HEX   0x0020  /* Upper-case hex ('X' specifier) */
  21 #define WPRINTF_WIDE        0x0040  /* Wide arg ('w' prefix) */
  22
  23 typedef enum
  24 {
  25     WPR_UNKNOWN,
  26     WPR_CHAR,
  27     WPR_WCHAR,
  28     WPR_STRING,
  29     WPR_WSTRING,
  30     WPR_SIGNED,
  31     WPR_UNSIGNED,
  32     WPR_HEXA
  33 } WPRINTF_TYPE;
  34
  35 typedef struct
  36 {
  37     UINT32         flags;
  38     UINT32         width;
  39     UINT32         precision;
  40     WPRINTF_TYPE   type;
  41 } WPRINTF_FORMAT;
  42
  43 static const CHAR null_stringA[] = "(null)";
  44 static const WCHAR null_stringW[] = { '(', 'n', 'u', 'l', 'l', ')', 0 };
  45
  46 /***********************************************************************
  47  *           WPRINTF_ParseFormatA
  48  *
  49  * Parse a format specification. A format specification has the form:
  50  *
  51  * [-][#][0][width][.precision]type
  52  *
  53  * Return value is the length of the format specification in characters.
  54  */
  55 static INT32 WPRINTF_ParseFormatA( LPCSTR format, WPRINTF_FORMAT *res )
  56 {
  57     LPCSTR p = format;
  58
  59     res->flags = 0;
  60     res->width = 0;
  61     res->precision = 0;
  62     if (*p == '-') { res->flags |= WPRINTF_LEFTALIGN; p++; }
  63     if (*p == '#') { res->flags |= WPRINTF_PREFIX_HEX; p++; }
  64     if (*p == '0') { res->flags |= WPRINTF_ZEROPAD; p++; }
  65     while ((*p >= '0') && (*p <= '9'))  /* width field */
  66     {
  67         res->width = res->width * 10 + *p - '0';
  68         p++;
  69     }
  70     if (*p == '.')  /* precision field */
  71     {
  72         p++;
  73         while ((*p >= '0') && (*p <= '9'))
  74         {
  75             res->precision = res->precision * 10 + *p - '0';
  76             p++;
  77         }
  78     }
  79     if (*p == 'l') { res->flags |= WPRINTF_LONG; p++; }
  80     else if (*p == 'h') { res->flags |= WPRINTF_SHORT; p++; }
  81     else if (*p == 'w') { res->flags |= WPRINTF_WIDE; p++; }
  82     switch(*p)
  83     {
  84     case 'c':
  85         res->type = (res->flags & WPRINTF_LONG) ? WPR_WCHAR : WPR_CHAR;
  86         break;
  87     case 'C':
  88         res->type = (res->flags & WPRINTF_SHORT) ? WPR_CHAR : WPR_WCHAR;
  89         break;
  90     case 'd':
  91     case 'i':
  92         res->type = WPR_SIGNED;
  93         break;
  94     case 's':
  95         res->type = (res->flags & (WPRINTF_LONG |WPRINTF_WIDE))
  96                     ? WPR_WSTRING : WPR_STRING;
  97         break;
  98     case 'S':
  99         res->type = (res->flags & (WPRINTF_SHORT|WPRINTF_WIDE))
 100                     ? WPR_STRING : WPR_WSTRING;
 101         break;
 102     case 'u':
 103         res->type = WPR_UNSIGNED;
 104         break;
 105     case 'X':
 106         res->flags |= WPRINTF_UPPER_HEX;
 107         /* fall through */
 108     case 'x':
 109         res->type = WPR_HEXA;
 110         break;
 111     default: /* unknown format char */
 112         res->type = WPR_UNKNOWN;
 113         p--;  /* print format as normal char */
 114         break;
 115     }
 116     return (INT32)(p - format) + 1;
 117 }
 118
 119
 120 /***********************************************************************
 121  *           WPRINTF_ParseFormatW
 122  *
 123  * Parse a format specification. A format specification has the form:
 124  *
 125  * [-][#][0][width][.precision]type
 126  *
 127  * Return value is the length of the format specification in characters.
 128  */
 129 static INT32 WPRINTF_ParseFormatW( LPCWSTR format, WPRINTF_FORMAT *res )
 130 {
 131     LPCWSTR p = format;
 132
 133     res->flags = 0;
 134     res->width = 0;
 135     res->precision = 0;
 136     if (*p == '-') { res->flags |= WPRINTF_LEFTALIGN; p++; }
 137     if (*p == '#') { res->flags |= WPRINTF_PREFIX_HEX; p++; }
 138     if (*p == '0') { res->flags |= WPRINTF_ZEROPAD; p++; }
 139     while ((*p >= '0') && (*p <= '9'))  /* width field */
 140     {
 141         res->width = res->width * 10 + *p - '0';
 142         p++;
 143     }
 144     if (*p == '.')  /* precision field */
 145     {
 146         p++;
 147         while ((*p >= '0') && (*p <= '9'))
 148         {
 149             res->precision = res->precision * 10 + *p - '0';
 150             p++;
 151         }
 152     }
 153     if (*p == 'l') { res->flags |= WPRINTF_LONG; p++; }
 154     else if (*p == 'h') { res->flags |= WPRINTF_SHORT; p++; }
 155     else if (*p == 'w') { res->flags |= WPRINTF_WIDE; p++; }
 156     switch((CHAR)*p)
 157     {
 158     case 'c':
 159         res->type = (res->flags & WPRINTF_SHORT) ? WPR_CHAR : WPR_WCHAR;
 160         break;
 161     case 'C':
 162         res->type = (res->flags & WPRINTF_LONG) ? WPR_WCHAR : WPR_CHAR;
 163         break;
 164     case 'd':
 165     case 'i':
 166         res->type = WPR_SIGNED;
 167         break;
 168     case 's':
 169         res->type = ((res->flags & WPRINTF_SHORT) && !(res->flags & WPRINTF_WIDE)) ? WPR_STRING : WPR_WSTRING;
 170         break;
 171     case 'S':
 172         res->type = (res->flags & (WPRINTF_LONG|WPRINTF_WIDE)) ? WPR_WSTRING : WPR_STRING;
 173         break;
 174     case 'u':
 175         res->type = WPR_UNSIGNED;
 176         break;
 177     case 'X':
 178         res->flags |= WPRINTF_UPPER_HEX;
 179         /* fall through */
 180     case 'x':
 181         res->type = WPR_HEXA;
 182         break;
 183     default:
 184         res->type = WPR_UNKNOWN;
 185         p--;  /* print format as normal char */
 186         break;
 187     }
 188     return (INT32)(p - format) + 1;
 189 }
 190
 191
 192 /***********************************************************************
 193  *           WPRINTF_GetLen
 194  */
 195 static UINT32 WPRINTF_GetLen( WPRINTF_FORMAT *format, LPCVOID arg,
 196                               LPSTR number, UINT32 maxlen )
 197 {
 198     UINT32 len;
 199
 200     if (format->flags & WPRINTF_LEFTALIGN) format->flags &= ~WPRINTF_ZEROPAD;
 201     if (format->width > maxlen) format->width = maxlen;
 202     switch(format->type)
 203     {
 204     case WPR_CHAR:
 205     case WPR_WCHAR:
 206         return (format->precision = 1);
 207     case WPR_STRING:
 208         if (!*(LPCSTR *)arg) *(LPCSTR *)arg = null_stringA;
 209         for (len = 0; !format->precision || (len < format->precision); len++)
 210             if (!*(*(LPCSTR *)arg + len)) break;
 211         if (len > maxlen) len = maxlen;
 212         return (format->precision = len);
 213     case WPR_WSTRING:
 214         if (!*(LPCWSTR *)arg) *(LPCWSTR *)arg = null_stringW;
 215         for (len = 0; !format->precision || (len < format->precision); len++)
 216             if (!*(*(LPCWSTR *)arg + len)) break;
 217         if (len > maxlen) len = maxlen;
 218         return (format->precision = len);
 219     case WPR_SIGNED:
 220         len = sprintf( number, "%d", *(INT32 *)arg );
 221         break;
 222     case WPR_UNSIGNED:
 223         len = sprintf( number, "%u", *(UINT32 *)arg );
 224         break;
 225     case WPR_HEXA:
 226         len = sprintf( number,
 227                         (format->flags & WPRINTF_UPPER_HEX) ? "%X" : "%x",
 228                         *(UINT32 *)arg );
 229         if (format->flags & WPRINTF_PREFIX_HEX) len += 2;
 230         break;
 231     default:
 232         return 0;
 233     }
 234     if (len > maxlen) len = maxlen;
 235     if (format->precision < len) format->precision = len;
 236     if (format->precision > maxlen) format->precision = maxlen;
 237     if ((format->flags & WPRINTF_ZEROPAD) && (format->width > format->precision))
 238         format->precision = format->width;
 239     return len;
 240 }
 241
 242
 243 /***********************************************************************
 244  *           wvsnprintf16   (Not a Windows API)
 245  */
 246 INT16 WINAPI wvsnprintf16( LPSTR buffer, UINT16 maxlen, LPCSTR spec,
 247                            LPCVOID args )
 248 {
 249     WPRINTF_FORMAT format;
 250     LPSTR p = buffer;
 251     UINT32 i, len;
 252     CHAR number[20];
 253     DWORD cur_arg;
 254
 255     while (*spec && (maxlen > 1))
 256     {
 257         if (*spec != '%') { *p++ = *spec++; maxlen--; continue; }
 258         spec++;
 259         if (*spec == '%') { *p++ = *spec++; maxlen--; continue; }
 260         spec += WPRINTF_ParseFormatA( spec, &format );
 261         switch(format.type)
 262         {
 263         case WPR_WCHAR:  /* No Unicode in Win16 */
 264         case WPR_CHAR:
 265             cur_arg = (DWORD)VA_ARG16( args, CHAR );
 266             break;
 267         case WPR_WSTRING:  /* No Unicode in Win16 */
 268         case WPR_STRING:
 269             cur_arg = (DWORD)VA_ARG16( args, SEGPTR );
 270             if (IsBadReadPtr16( (SEGPTR)cur_arg, 1 )) cur_arg = (DWORD)"";
 271             else cur_arg = (DWORD)PTR_SEG_TO_LIN( (SEGPTR)cur_arg );
 272             break;
 273         case WPR_SIGNED:
 274             if (!(format.flags & WPRINTF_LONG))
 275             {
 276                 cur_arg = (DWORD)(INT32)VA_ARG16( args, INT16 );
 277                 break;
 278             }
 279             /* fall through */
 280         case WPR_HEXA:
 281         case WPR_UNSIGNED:
 282             if (format.flags & WPRINTF_LONG)
 283                 cur_arg = (DWORD)VA_ARG16( args, UINT32 );
 284             else
 285                 cur_arg = (DWORD)VA_ARG16( args, UINT16 );
 286             break;
 287         case WPR_UNKNOWN:
 288             continue;
 289         }
 290         len = WPRINTF_GetLen( &format, &cur_arg, number, maxlen - 1 );
 291         if (!(format.flags & WPRINTF_LEFTALIGN))
 292             for (i = format.precision; i < format.width; i++, maxlen--)
 293                 *p++ = ' ';
 294         switch(format.type)
 295         {
 296         case WPR_WCHAR:
 297         case WPR_CHAR:
 298             if ((*p = (CHAR)cur_arg)) p++;
 299             else if (format.width > 1) *p++ = ' ';
 300             else len = 0;
 301             break;
 302         case WPR_WSTRING:
 303         case WPR_STRING:
 304             if (len) memcpy( p, (LPCSTR)cur_arg, len );
 305             p += len;
 306             break;
 307         case WPR_HEXA:
 308             if ((format.flags & WPRINTF_PREFIX_HEX) && (maxlen > 3))
 309             {
 310                 *p++ = '0';
 311                 *p++ = (format.flags & WPRINTF_UPPER_HEX) ? 'X' : 'x';
 312                 maxlen -= 2;
 313                 len -= 2;
 314                 format.precision -= 2;
 315                 format.width -= 2;
 316             }
 317             /* fall through */
 318         case WPR_SIGNED:
 319         case WPR_UNSIGNED:
 320             for (i = len; i < format.precision; i++, maxlen--) *p++ = '0';
 321             if (len) memcpy( p, number, len );
 322             p += len;
 323             break;
 324         case WPR_UNKNOWN:
 325             continue;
 326         }
 327         if (format.flags & WPRINTF_LEFTALIGN)
 328             for (i = format.precision; i < format.width; i++, maxlen--)
 329                 *p++ = ' ';
 330         maxlen -= len;
 331     }
 332     *p = 0;
 333     return (maxlen > 1) ? (INT32)(p - buffer) : -1;
 334 }
 335
 336
 337 /***********************************************************************
 338  *           wvsnprintf32A   (Not a Windows API)
 339  */
 340 INT32 WINAPI wvsnprintf32A( LPSTR buffer, UINT32 maxlen, LPCSTR spec,
 341                             va_list args )
 342 {
 343     WPRINTF_FORMAT format;
 344     LPSTR p = buffer;
 345     UINT32 i, len;
 346     CHAR number[20];
 347
 348     while (*spec && (maxlen > 1))
 349     {
 350         if (*spec != '%') { *p++ = *spec++; maxlen--; continue; }
 351         spec++;
 352         if (*spec == '%') { *p++ = *spec++; maxlen--; continue; }
 353         spec += WPRINTF_ParseFormatA( spec, &format );
 354         len = WPRINTF_GetLen( &format, args, number, maxlen - 1 );
 355         if (!(format.flags & WPRINTF_LEFTALIGN))
 356             for (i = format.precision; i < format.width; i++, maxlen--)
 357                 *p++ = ' ';
 358         switch(format.type)
 359         {
 360         case WPR_WCHAR:
 361             if ((*p = (CHAR)va_arg( args, WCHAR ))) p++;
 362             else if (format.width > 1) *p++ = ' ';
 363             else len = 0;
 364             break;
 365         case WPR_CHAR:
 366             if ((*p = va_arg( args, CHAR ))) p++;
 367             else if (format.width > 1) *p++ = ' ';
 368             else len = 0;
 369             break;
 370         case WPR_STRING:
 371             memcpy( p, va_arg( args, LPCSTR ), len );
 372             p += len;
 373             break;
 374         case WPR_WSTRING:
 375             {
 376                 LPCWSTR ptr = va_arg( args, LPCWSTR );
 377                 for (i = 0; i < len; i++) *p++ = (CHAR)*ptr++;
 378             }
 379             break;
 380         case WPR_HEXA:
 381             if ((format.flags & WPRINTF_PREFIX_HEX) && (maxlen > 3))
 382             {
 383                 *p++ = '0';
 384                 *p++ = (format.flags & WPRINTF_UPPER_HEX) ? 'X' : 'x';
 385                 maxlen -= 2;
 386                 len -= 2;
 387                 format.precision -= 2;
 388                 format.width -= 2;
 389             }
 390             /* fall through */
 391         case WPR_SIGNED:
 392         case WPR_UNSIGNED:
 393             for (i = len; i < format.precision; i++, maxlen--) *p++ = '0';
 394             memcpy( p, number, len );
 395             p += len;
 396             (void)va_arg( args, INT32 ); /* Go to the next arg */
 397             break;
 398         case WPR_UNKNOWN:
 399             continue;
 400         }
 401         if (format.flags & WPRINTF_LEFTALIGN)
 402             for (i = format.precision; i < format.width; i++, maxlen--)
 403                 *p++ = ' ';
 404         maxlen -= len;
 405     }
 406     *p = 0;
 407     TRACE(string,"%s\n",buffer);
 408     return (maxlen > 1) ? (INT32)(p - buffer) : -1;
 409 }
 410
 411
 412 /***********************************************************************
 413  *           wvsnprintf32W   (Not a Windows API)
 414  */
 415 INT32 WINAPI wvsnprintf32W( LPWSTR buffer, UINT32 maxlen, LPCWSTR spec,
 416                             va_list args )
 417 {
 418     WPRINTF_FORMAT format;
 419     LPWSTR p = buffer;
 420     UINT32 i, len;
 421     CHAR number[20];
 422
 423     while (*spec && (maxlen > 1))
 424     {
 425         if (*spec != '%') { *p++ = *spec++; maxlen--; continue; }
 426         spec++;
 427         if (*spec == '%') { *p++ = *spec++; maxlen--; continue; }
 428         spec += WPRINTF_ParseFormatW( spec, &format );
 429         len = WPRINTF_GetLen( &format, args, number, maxlen - 1 );
 430         if (!(format.flags & WPRINTF_LEFTALIGN))
 431             for (i = format.precision; i < format.width; i++, maxlen--)
 432                 *p++ = ' ';
 433         switch(format.type)
 434         {
 435         case WPR_WCHAR:
 436             if ((*p = va_arg( args, WCHAR ))) p++;
 437             else if (format.width > 1) *p++ = ' ';
 438             else len = 0;
 439             break;
 440         case WPR_CHAR:
 441             if ((*p = (WCHAR)va_arg( args, CHAR ))) p++;
 442             else if (format.width > 1) *p++ = ' ';
 443             else len = 0;
 444             break;
 445         case WPR_STRING:
 446             {
 447                 LPCSTR ptr = va_arg( args, LPCSTR );
 448                 for (i = 0; i < len; i++) *p++ = (WCHAR)*ptr++;
 449             }
 450             break;
 451         case WPR_WSTRING:
 452             if (len) memcpy( p, va_arg( args, LPCWSTR ), len * sizeof(WCHAR) );
 453             p += len;
 454             break;
 455         case WPR_HEXA:
 456             if ((format.flags & WPRINTF_PREFIX_HEX) && (maxlen > 3))
 457             {
 458                 *p++ = '0';
 459                 *p++ = (format.flags & WPRINTF_UPPER_HEX) ? 'X' : 'x';
 460                 maxlen -= 2;
 461                 len -= 2;
 462                 format.precision -= 2;
 463                 format.width -= 2;
 464             }
 465             /* fall through */
 466         case WPR_SIGNED:
 467         case WPR_UNSIGNED:
 468             for (i = len; i < format.precision; i++, maxlen--) *p++ = '0';
 469             for (i = 0; i < len; i++) *p++ = (WCHAR)number[i];
 470             (void)va_arg( args, INT32 ); /* Go to the next arg */
 471             break;
 472         case WPR_UNKNOWN:
 473             continue;
 474         }
 475         if (format.flags & WPRINTF_LEFTALIGN)
 476             for (i = format.precision; i < format.width; i++, maxlen--)
 477                 *p++ = ' ';
 478         maxlen -= len;
 479     }
 480     *p = 0;
 481     return (maxlen > 1) ? (INT32)(p - buffer) : -1;
 482 }
 483
 484
 485 /***********************************************************************
 486  *           wvsprintf16   (USER.421)
 487  */
 488 INT16 WINAPI wvsprintf16( LPSTR buffer, LPCSTR spec, LPCVOID args )
 489 {
 490     TRACE(string,"for %p got:\n",buffer);
 491     return wvsnprintf16( buffer, 0xffff, spec, args );
 492 }
 493
 494
 495 /***********************************************************************
 496  *           wvsprintf32A   (USER32.587)
 497  */
 498 INT32 WINAPI wvsprintf32A( LPSTR buffer, LPCSTR spec, va_list args )
 499 {
 500     TRACE(string,"for %p got:\n",buffer);
 501     return wvsnprintf32A( buffer, 0xffffffff, spec, args );
 502 }
 503
 504
 505 /***********************************************************************
 506  *           wvsprintf32W   (USER32.588)
 507  */
 508 INT32 WINAPI wvsprintf32W( LPWSTR buffer, LPCWSTR spec, va_list args )
 509 {
 510     TRACE(string,"for %p got:\n",buffer);
 511     return wvsnprintf32W( buffer, 0xffffffff, spec, args );
 512 }
 513
 514
 515 /***********************************************************************
 516  *           wsprintf16   (USER.420)
 517  */
 518 /* Winelib version */
 519 INT16 WINAPIV wsprintf16( LPSTR buffer, LPCSTR spec, ... )
 520 {
 521     va_list valist;
 522     INT16 res;
 523
 524     TRACE(string,"for %p got:\n",buffer);
 525     va_start( valist, spec );
 526     /* Note: we call the 32-bit version, because the args are 32-bit */
 527     res = (INT16)wvsnprintf32A( buffer, 0xffffffff, spec, valist );
 528     va_end( valist );
 529     return res;
 530 }
 531
 532 /* Emulator version */
 533 INT16 WINAPIV WIN16_wsprintf16(void)
 534 {
 535     VA_LIST16 valist;
 536     INT16 res;
 537     SEGPTR buffer, spec;
 538
 539     VA_START16( valist );
 540     buffer = VA_ARG16( valist, SEGPTR );
 541     spec   = VA_ARG16( valist, SEGPTR );
 542     TRACE(string,"got:\n");
 543     res = wvsnprintf16( (LPSTR)PTR_SEG_TO_LIN(buffer), 0xffff,
 544                         (LPCSTR)PTR_SEG_TO_LIN(spec), valist );
 545     VA_END16( valist );
 546     return res;
 547 }
 548
 549
 550 /***********************************************************************
 551  *           wsprintf32A   (USER32.585)
 552  */
 553 INT32 WINAPIV wsprintf32A( LPSTR buffer, LPCSTR spec, ... )
 554 {
 555     va_list valist;
 556     INT32 res;
 557
 558     TRACE(string,"for %p got:\n",buffer);
 559     va_start( valist, spec );
 560     res = wvsnprintf32A( buffer, 0xffffffff, spec, valist );
 561     va_end( valist );
 562     return res;
 563 }
 564
 565
 566 /***********************************************************************
 567  *           wsprintf32W   (USER32.586)
 568  */
 569 INT32 WINAPIV wsprintf32W( LPWSTR buffer, LPCWSTR spec, ... )
 570 {
 571     va_list valist;
 572     INT32 res;
 573
 574     TRACE(string,"wsprintf32W for %p\n",buffer);
 575     va_start( valist, spec );
 576     res = wvsnprintf32W( buffer, 0xffffffff, spec, valist );
 577     va_end( valist );
 578     return res;
 579 }
 580
 581
 582 /***********************************************************************
 583  *           wsnprintf16   (Not a Windows API)
 584  */
 585 INT16 WINAPIV wsnprintf16( LPSTR buffer, UINT16 maxlen, LPCSTR spec, ... )
 586 {
 587     va_list valist;
 588     INT16 res;
 589
 590     va_start( valist, spec );
 591     res = wvsnprintf16( buffer, maxlen, spec, valist );
 592     va_end( valist );
 593     return res;
 594 }
 595
 596
 597 /***********************************************************************
 598  *           wsnprintf32A   (Not a Windows API)
 599  */
 600 INT32 WINAPIV wsnprintf32A( LPSTR buffer, UINT32 maxlen, LPCSTR spec, ... )
 601 {
 602     va_list valist;
 603     INT32 res;
 604
 605     va_start( valist, spec );
 606     res = wvsnprintf32A( buffer, maxlen, spec, valist );
 607     va_end( valist );
 608     return res;
 609 }
 610
 611
 612 /***********************************************************************
 613  *           wsnprintf32W   (Not a Windows API)
 614  */
 615 INT32 WINAPIV wsnprintf32W( LPWSTR buffer, UINT32 maxlen, LPCWSTR spec, ... )
 616 {
 617     va_list valist;
 618     INT32 res;
 619
 620     va_start( valist, spec );
 621     res = wvsnprintf32W( buffer, maxlen, spec, valist );
 622     va_end( valist );
 623     return res;
 624 }