misc/wsprintf.c

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