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             if (IsBadReadPtr16( *(SEGPTR *)args, 1 )) cur_arg = (DWORD)"";
 258             else cur_arg = (DWORD)PTR_SEG_TO_LIN( *(SEGPTR *)args );
 259             args = (SEGPTR *)args + 1;
 260             break;
 261         case WPR_HEXA:
 262         case WPR_SIGNED:
 263         case WPR_UNSIGNED:
 264             if (format.flags & WPRINTF_LONG)
 265             {
 266                 cur_arg = (DWORD)*(UINT32 *)args;
 267                 args = (UINT32 *)args + 1;
 268             }
 269             else
 270             {
 271                 cur_arg = (DWORD)*(UINT16 *)args;
 272                 args = (UINT16 *)args + 1;
 273             }
 274             break;
 275         }
 276         len = WPRINTF_GetLen( &format, &cur_arg, number, maxlen - 1 );
 277         if (!(format.flags & WPRINTF_LEFTALIGN))
 278             for (i = format.precision; i < format.width; i++, maxlen--)
 279                 *p++ = ' ';
 280         switch(format.type)
 281         {
 282         case WPR_CHAR:
 283             if ((*p = (CHAR)cur_arg)) p++;
 284             else if (format.width > 1) *p++ = ' ';
 285             else len = 0;
 286             break;
 287         case WPR_STRING:
 288             if (len) memcpy( p, (LPCSTR)cur_arg, len );
 289             p += len;
 290             break;
 291         case WPR_HEXA:
 292             if ((format.flags & WPRINTF_PREFIX_HEX) && (maxlen > 3))
 293             {
 294                 *p++ = '0';
 295                 *p++ = (format.flags & WPRINTF_UPPER_HEX) ? 'X' : 'x';
 296                 maxlen -= 2;
 297                 len -= 2;
 298                 format.precision -= 2;
 299                 format.width -= 2;
 300             }
 301             /* fall through */
 302         case WPR_SIGNED:
 303         case WPR_UNSIGNED:
 304             for (i = len; i < format.precision; i++, maxlen--) *p++ = '0';
 305             if (len) memcpy( p, number, len );
 306             p += len;
 307             break;
 308         case WPR_WCHAR:
 309         case WPR_WSTRING:
 310             fprintf( stderr, "Unicode not supported in wsprintf16\n" );
 311             break;
 312         }
 313         if (format.flags & WPRINTF_LEFTALIGN)
 314             for (i = format.precision; i < format.width; i++, maxlen--)
 315                 *p++ = ' ';
 316         maxlen -= len;
 317     }
 318     *p = 0;
 319     return (maxlen > 1) ? (INT32)(p - buffer) : -1;
 320 }
 321
 322
 323 /***********************************************************************
 324  *           wvsnprintf32A   (Not a Windows API)
 325  */
 326 INT32 wvsnprintf32A( LPSTR buffer, UINT32 maxlen, LPCSTR spec, LPCVOID args )
 327 {
 328     WPRINTF_FORMAT format;
 329     LPSTR p = buffer;
 330     UINT32 i, len;
 331     CHAR number[20];
 332
 333     while (*spec && (maxlen > 1))
 334     {
 335         if (*spec != '%') { *p++ = *spec++; maxlen--; continue; }
 336         spec++;
 337         if (*spec == '%') { *p++ = *spec++; maxlen--; continue; }
 338         spec += WPRINTF_ParseFormatA( spec, &format );
 339         len = WPRINTF_GetLen( &format, args, number, maxlen - 1 );
 340         if (!(format.flags & WPRINTF_LEFTALIGN))
 341             for (i = format.precision; i < format.width; i++, maxlen--)
 342                 *p++ = ' ';
 343         switch(format.type)
 344         {
 345         case WPR_WCHAR:
 346             if ((*p = (CHAR)*(WCHAR *)args)) p++;
 347             else if (format.width > 1) *p++ = ' ';
 348             else len = 0;
 349             break;
 350         case WPR_CHAR:
 351             if ((*p = *(CHAR *)args)) p++;
 352             else if (format.width > 1) *p++ = ' ';
 353             else len = 0;
 354             break;
 355         case WPR_STRING:
 356             if (len) memcpy( p, *(LPCSTR *)args, len );
 357             p += len;
 358             break;
 359         case WPR_WSTRING:
 360             for (i = 0; i < len; i++) *p++ = (CHAR)*(*(LPCWSTR *)args + i);
 361             break;
 362         case WPR_HEXA:
 363             if ((format.flags & WPRINTF_PREFIX_HEX) && (maxlen > 3))
 364             {
 365                 *p++ = '0';
 366                 *p++ = (format.flags & WPRINTF_UPPER_HEX) ? 'X' : 'x';
 367                 maxlen -= 2;
 368                 len -= 2;
 369                 format.precision -= 2;
 370                 format.width -= 2;
 371             }
 372             /* fall through */
 373         case WPR_SIGNED:
 374         case WPR_UNSIGNED:
 375             for (i = len; i < format.precision; i++, maxlen--) *p++ = '0';
 376             if (len) memcpy( p, number, len );
 377             p += len;
 378             break;
 379         }
 380         if (format.flags & WPRINTF_LEFTALIGN)
 381             for (i = format.precision; i < format.width; i++, maxlen--)
 382                 *p++ = ' ';
 383         args = (INT32 *)args + 1;
 384         maxlen -= len;
 385     }
 386     *p = 0;
 387     return (maxlen > 1) ? (INT32)(p - buffer) : -1;
 388 }
 389
 390
 391 /***********************************************************************
 392  *           wvsnprintf32W   (Not a Windows API)
 393  */
 394 INT32 wvsnprintf32W( LPWSTR buffer, UINT32 maxlen, LPCWSTR spec, LPCVOID args )
 395 {
 396     WPRINTF_FORMAT format;
 397     LPWSTR p = buffer;
 398     UINT32 i, len;
 399     CHAR number[20];
 400
 401     while (*spec && (maxlen > 1))
 402     {
 403         if (*spec != '%') { *p++ = *spec++; maxlen--; continue; }
 404         spec++;
 405         if (*spec == '%') { *p++ = *spec++; maxlen--; continue; }
 406         spec += WPRINTF_ParseFormatW( spec, &format );
 407         len = WPRINTF_GetLen( &format, args, number, maxlen - 1 );
 408         if (!(format.flags & WPRINTF_LEFTALIGN))
 409             for (i = format.precision; i < format.width; i++, maxlen--)
 410                 *p++ = ' ';
 411         switch(format.type)
 412         {
 413         case WPR_WCHAR:
 414             if ((*p = *(WCHAR *)args)) p++;
 415             else if (format.width > 1) *p++ = ' ';
 416             else len = 0;
 417             break;
 418         case WPR_CHAR:
 419             if ((*p = (WCHAR)*(CHAR *)args)) p++;
 420             else if (format.width > 1) *p++ = ' ';
 421             else len = 0;
 422             break;
 423         case WPR_STRING:
 424             for (i = 0; i < len; i++) *p++ = (WCHAR)*(*(LPCSTR *)args + i);
 425             break;
 426         case WPR_WSTRING:
 427             if (len) memcpy( p, *(LPCWSTR *)args, len * sizeof(WCHAR) );
 428             p += len;
 429             break;
 430         case WPR_HEXA:
 431             if ((format.flags & WPRINTF_PREFIX_HEX) && (maxlen > 3))
 432             {
 433                 *p++ = '0';
 434                 *p++ = (format.flags & WPRINTF_UPPER_HEX) ? 'X' : 'x';
 435                 maxlen -= 2;
 436                 len -= 2;
 437                 format.precision -= 2;
 438                 format.width -= 2;
 439             }
 440             /* fall through */
 441         case WPR_SIGNED:
 442         case WPR_UNSIGNED:
 443             for (i = len; i < format.precision; i++, maxlen--) *p++ = '0';
 444             for (i = 0; i < len; i++) *p++ = (WCHAR)number[i];
 445             break;
 446         }
 447         if (format.flags & WPRINTF_LEFTALIGN)
 448             for (i = format.precision; i < format.width; i++, maxlen--)
 449                 *p++ = ' ';
 450         args = (INT32 *)args + 1;
 451         maxlen -= len;
 452     }
 453     *p = 0;
 454     return (maxlen > 1) ? (INT32)(p - buffer) : -1;
 455 }
 456
 457
 458 /***********************************************************************
 459  *           wvsprintf16   (USER.421)
 460  */
 461 INT16 wvsprintf16( LPSTR buffer, LPCSTR spec, LPCVOID args )
 462 {
 463     return wvsnprintf16( buffer, 0xffff, spec, args );
 464 }
 465
 466
 467 /***********************************************************************
 468  *           wvsprintf32A   (USER32.586)
 469  */
 470 INT32 wvsprintf32A( LPSTR buffer, LPCSTR spec, LPCVOID args )
 471 {
 472     return wvsnprintf32A( buffer, 0xffffffff, spec, args );
 473 }
 474
 475
 476 /***********************************************************************
 477  *           wvsprintf32W   (USER32.587)
 478  */
 479 INT32 wvsprintf32W( LPWSTR buffer, LPCWSTR spec, LPCVOID args )
 480 {
 481     return wvsnprintf32W( buffer, 0xffffffff, spec, args );
 482 }
 483
 484
 485 /***********************************************************************
 486  *           wsprintf16   (USER.420)
 487  */
 488 /* Winelib version */
 489 INT16 wsprintf16( LPSTR buffer, LPCSTR spec, ... )
 490 {
 491     va_list valist;
 492     INT16 res;
 493
 494     va_start( valist, spec );
 495     /* Note: we call the 32-bit version, because the args are 32-bit */
 496     res = (INT16)wvsprintf32A( buffer, spec, (LPCVOID)valist );
 497     va_end( valist );
 498     return res;
 499 }
 500
 501 /* Emulator version */
 502 INT16 WIN16_wsprintf16(void)
 503 {
 504     SEGPTR *win_stack = (SEGPTR *)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
 511
 512 /***********************************************************************
 513  *           wsprintf32A   (USER32.584)
 514  */
 515 /* Winelib version */
 516 INT32 wsprintf32A( LPSTR buffer, LPCSTR spec, ... )
 517 {
 518     va_list valist;
 519     INT32 res;
 520
 521     va_start( valist, spec );
 522     res = wvsprintf32A( buffer, spec, (LPCVOID)valist );
 523     va_end( valist );
 524     return res;
 525 }
 526
 527 /* Emulator version */
 528 INT32 WIN32_wsprintf32A( int *args )
 529 {
 530     return wvsprintf32A( (LPSTR)args[0], (LPCSTR)args[1], (LPCVOID)&args[2] );
 531 }
 532
 533
 534 /***********************************************************************
 535  *           wsprintf32W   (USER32.585)
 536  */
 537 /* Winelib version */
 538 INT32 wsprintf32W( LPWSTR buffer, LPCWSTR spec, ... )
 539 {
 540     va_list valist;
 541     INT32 res;
 542
 543     va_start( valist, spec );
 544     res = wvsprintf32W( buffer, spec, (LPCVOID)valist );
 545     va_end( valist );
 546     return res;
 547 }
 548
 549 /* Emulator version */
 550 INT32 WIN32_wsprintf32W( int *args )
 551 {
 552     return wvsprintf32W( (LPWSTR)args[0], (LPCWSTR)args[1], (LPCVOID)&args[2]);
 553 }