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