misc/wsprintf.c

   1 /*
   2  * wsprintf functions
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #define NO_TRANSITION_TYPES  /* This file is Win32-clean */
   8 #include <stdarg.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include "windows.h"
  12 #include "ldt.h"
  13 #include "stackframe.h"
  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
  22 typedef enum
  23 {
  24     WPR_CHAR,
  25     WPR_WCHAR,
  26     WPR_STRING,
  27     WPR_WSTRING,
  28     WPR_SIGNED,
  29     WPR_UNSIGNED,
  30     WPR_HEXA
  31 } WPRINTF_TYPE;
  32
  33 typedef struct
  34 {
  35     UINT32         flags;
  36     UINT32         width;
  37     UINT32         precision;
  38     WPRINTF_TYPE   type;
  39 } WPRINTF_FORMAT;
  40
  41
  42 /***********************************************************************
  43  *           WPRINTF_ParseFormatA
  44  *
  45  * Parse a format specification. A format specification has the form:
  46  *
  47  * [-][#][0][width][.precision]type
  48  *
  49  * Return value is the length of the format specification in characters.
  50  */
  51 static INT32 WPRINTF_ParseFormatA( LPCSTR format, WPRINTF_FORMAT *res )
  52 {
  53     LPCSTR p = format;
  54
  55     res->flags = 0;
  56     res->width = 0;
  57     res->precision = 0;
  58     if (*p == '-') { res->flags |= WPRINTF_LEFTALIGN; p++; }
  59     if (*p == '#') { res->flags |= WPRINTF_PREFIX_HEX; p++; }
  60     if (*p == '0') { res->flags |= WPRINTF_ZEROPAD; p++; }
  61     while ((*p >= '0') && (*p <= '9'))  /* width field */
  62     {
  63         res->width = res->width * 10 + *p - '0';
  64         p++;
  65     }
  66     if (*p == '.')  /* precision field */
  67     {
  68         p++;
  69         while ((*p >= '0') && (*p <= '9'))
  70         {
  71             res->precision = res->precision * 10 + *p - '0';
  72             p++;
  73         }
  74     }
  75     if (*p == 'l') { res->flags |= WPRINTF_LONG; p++; }
  76     else if (*p == 'h') { res->flags |= WPRINTF_SHORT; p++; }
  77     switch(*p)
  78     {
  79     case 'c':
  80         res->type = (res->flags & WPRINTF_LONG) ? WPR_WCHAR : WPR_CHAR;
  81         break;
  82     case 'C':
  83         res->type = (res->flags & WPRINTF_SHORT) ? WPR_CHAR : WPR_WCHAR;
  84         break;
  85     case 'd':
  86     case 'i':
  87         res->type = WPR_SIGNED;
  88         break;
  89     case 's':
  90         res->type = (res->flags & WPRINTF_LONG) ? WPR_WSTRING : WPR_STRING;
  91         break;
  92     case 'S':
  93         res->type = (res->flags & WPRINTF_SHORT) ? WPR_STRING : WPR_WSTRING;
  94         break;
  95     case 'u':
  96         res->type = WPR_UNSIGNED;
  97         break;
  98     case 'X':
  99         res->flags |= WPRINTF_UPPER_HEX;
 100         /* fall through */
 101     case 'x':
 102         res->type = WPR_HEXA;
 103         break;
 104     default:
 105         fprintf( stderr, "wvsprintf32A: unknown format '%c'\n", *p );
 106         break;
 107     }
 108     return (INT32)(p - format) + 1;
 109 }
 110
 111
 112 /***********************************************************************
 113  *           WPRINTF_ParseFormatW
 114  *
 115  * Parse a format specification. A format specification has the form:
 116  *
 117  * [-][#][0][width][.precision]type
 118  *
 119  * Return value is the length of the format specification in characters.
 120  */
 121 static INT32 WPRINTF_ParseFormatW( LPCWSTR format, WPRINTF_FORMAT *res )
 122 {
 123     LPCWSTR p = format;
 124
 125     res->flags = 0;
 126     res->width = 0;
 127     res->precision = 0;
 128     if (*p == '-') { res->flags |= WPRINTF_LEFTALIGN; p++; }
 129     if (*p == '#') { res->flags |= WPRINTF_PREFIX_HEX; p++; }
 130     if (*p == '0') { res->flags |= WPRINTF_ZEROPAD; p++; }
 131     while ((*p >= '0') && (*p <= '9'))  /* width field */
 132     {
 133         res->width = res->width * 10 + *p - '0';
 134         p++;
 135     }
 136     if (*p == '.')  /* precision field */
 137     {
 138         p++;
 139         while ((*p >= '0') && (*p <= '9'))
 140         {
 141             res->precision = res->precision * 10 + *p - '0';
 142             p++;
 143         }
 144     }
 145     if (*p == 'l') { res->flags |= WPRINTF_LONG; p++; }
 146     else if (*p == 'h') { res->flags |= WPRINTF_SHORT; p++; }
 147     switch((CHAR)*p)
 148     {
 149     case 'c':
 150         res->type = (res->flags & WPRINTF_SHORT) ? WPR_CHAR : WPR_WCHAR;
 151         break;
 152     case 'C':
 153         res->type = (res->flags & WPRINTF_LONG) ? WPR_WCHAR : WPR_CHAR;
 154         break;
 155     case 'd':
 156     case 'i':
 157         res->type = WPR_SIGNED;
 158         break;
 159     case 's':
 160         res->type = (res->flags & WPRINTF_SHORT) ? WPR_STRING : WPR_WSTRING;
 161         break;
 162     case 'S':
 163         res->type = (res->flags & WPRINTF_LONG) ? WPR_WSTRING : WPR_STRING;
 164         break;
 165     case 'u':
 166         res->type = WPR_UNSIGNED;
 167         break;
 168     case 'X':
 169         res->flags |= WPRINTF_UPPER_HEX;
 170         /* fall through */
 171     case 'x':
 172         res->type = WPR_HEXA;
 173         break;
 174     default:
 175         fprintf( stderr, "wvsprintf32W: unknown format '%c'\n", (CHAR)*p );
 176         break;
 177     }
 178     return (INT32)(p - format) + 1;
 179 }
 180
 181
 182 /***********************************************************************
 183  *           WPRINTF_GetLen
 184  */
 185 static UINT32 WPRINTF_GetLen( WPRINTF_FORMAT *format, LPCVOID arg,
 186                               LPSTR number, UINT32 maxlen )
 187 {
 188     UINT32 len;
 189
 190     if (format->flags & WPRINTF_LEFTALIGN) format->flags &= ~WPRINTF_ZEROPAD;
 191     if (format->width > maxlen) format->width = maxlen;
 192     switch(format->type)
 193     {
 194     case WPR_CHAR:
 195     case WPR_WCHAR:
 196         return (format->precision = 1);
 197     case WPR_STRING:
 198         for (len = 0; !format->precision || (len < format->precision); len++)
 199             if (!*(*(LPCSTR *)arg + len)) break;
 200         if (len > maxlen) len = maxlen;
 201         return (format->precision = len);
 202     case WPR_WSTRING:
 203         for (len = 0; !format->precision || (len < format->precision); len++)
 204             if (!*(*(LPCWSTR *)arg + len)) break;
 205         if (len > maxlen) len = maxlen;
 206         return (format->precision = len);
 207     case WPR_SIGNED:
 208         len = sprintf( number, "%d", *(INT32 *)arg );
 209         break;
 210     case WPR_UNSIGNED:
 211         len = sprintf( number, "%u", *(UINT32 *)arg );
 212         break;
 213     case WPR_HEXA:
 214         len = sprintf( number,
 215                         (format->flags & WPRINTF_UPPER_HEX) ? "%X" : "%x",
 216                         *(UINT32 *)arg );
 217         if (format->flags & WPRINTF_PREFIX_HEX) len += 2;
 218         break;
 219     default:
 220         return 0;
 221     }
 222     if (len > maxlen) len = maxlen;
 223     if (format->precision < len) format->precision = len;
 224     if (format->precision > maxlen) format->precision = maxlen;
 225     if ((format->flags & WPRINTF_ZEROPAD) && (format->width > format->precision))
 226         format->precision = format->width;
 227     return len;
 228 }
 229
 230
 231 /***********************************************************************
 232  *           wvsnprintf16   (Not a Windows API)
 233  */
 234 INT16 wvsnprintf16( LPSTR buffer, UINT16 maxlen, LPCSTR spec, LPCVOID args )
 235 {
 236     WPRINTF_FORMAT format;
 237     LPSTR p = buffer;
 238     UINT32 i, len;
 239     CHAR number[20];
 240     DWORD cur_arg;
 241
 242     while (*spec && (maxlen > 1))
 243     {
 244         if (*spec != '%') { *p++ = *spec++; maxlen--; continue; }
 245         spec++;
 246         if (*spec == '%') { *p++ = *spec++; maxlen--; continue; }
 247         spec += WPRINTF_ParseFormatA( spec, &format );
 248         switch(format.type)
 249         {
 250         case WPR_WCHAR:  /* No Unicode in Win16 */
 251         case WPR_CHAR:
 252             cur_arg = (DWORD)*(CHAR *)args;
 253             args = (WORD *)args + 1;
 254             break;
 255         case WPR_WSTRING:  /* No Unicode in Win16 */
 256         case WPR_STRING:
 257             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 #ifndef WINELIB
 502 INT16 WIN16_wsprintf16(void)
 503 {
 504     SEGPTR *win_stack = (DWORD *)CURRENT_STACK16->args;
 505     LPSTR buffer = (LPSTR)PTR_SEG_TO_LIN(win_stack[0]);
 506     LPCSTR spec  = (LPCSTR)PTR_SEG_TO_LIN(win_stack[1]);
 507     return wvsprintf16( buffer, spec, &win_stack[2] );
 508
 509 }
 510 #endif  /* WINELIB */
 511
 512
 513 /***********************************************************************
 514  *           wsprintf32A   (USER32.584)
 515  */
 516 /* Winelib version */
 517 INT32 wsprintf32A( LPSTR buffer, LPCSTR spec, ... )
 518 {
 519     va_list valist;
 520     INT32 res;
 521
 522     va_start( valist, spec );
 523     res = wvsprintf32A( buffer, spec, (LPCVOID)valist );
 524     va_end( valist );
 525     return res;
 526 }
 527
 528 /* Emulator version */
 529 INT32 WIN32_wsprintf32A( int *args )
 530 {
 531     return wvsprintf32A( (LPSTR)args[0], (LPCSTR)args[1], (LPCVOID)&args[2] );
 532 }
 533
 534
 535 /***********************************************************************
 536  *           wsprintf32W   (USER32.585)
 537  */
 538 /* Winelib version */
 539 INT32 wsprintf32W( LPWSTR buffer, LPCWSTR spec, ... )
 540 {
 541     va_list valist;
 542     INT32 res;
 543
 544     va_start( valist, spec );
 545     res = wvsprintf32W( buffer, spec, (LPCVOID)valist );
 546     va_end( valist );
 547     return res;
 548 }
 549
 550 /* Emulator version */
 551 INT32 WIN32_wsprintf32W( int *args )
 552 {
 553     return wvsprintf32W( (LPWSTR)args[0], (LPCWSTR)args[1], (LPCVOID)&args[2]);
 554 }