4 * Copyright 1996 Alexandre Julliard
9 #include "wine/winbase16.h"
12 #include "stackframe.h"
15 DEFAULT_DEBUG_CHANNEL(string
)
18 #define WPRINTF_LEFTALIGN 0x0001 /* Align output on the left ('-' prefix) */
19 #define WPRINTF_PREFIX_HEX 0x0002 /* Prefix hex with 0x ('#' prefix) */
20 #define WPRINTF_ZEROPAD 0x0004 /* Pad with zeros ('0' prefix) */
21 #define WPRINTF_LONG 0x0008 /* Long arg ('l' prefix) */
22 #define WPRINTF_SHORT 0x0010 /* Short arg ('h' prefix) */
23 #define WPRINTF_UPPER_HEX 0x0020 /* Upper-case hex ('X' specifier) */
24 #define WPRINTF_WIDE 0x0040 /* Wide arg ('w' prefix) */
54 static const CHAR null_stringA
[] = "(null)";
55 static const WCHAR null_stringW
[] = { '(', 'n', 'u', 'l', 'l', ')', 0 };
57 /***********************************************************************
58 * WPRINTF_ParseFormatA
60 * Parse a format specification. A format specification has the form:
62 * [-][#][0][width][.precision]type
64 * Return value is the length of the format specification in characters.
66 static INT
WPRINTF_ParseFormatA( LPCSTR format
, WPRINTF_FORMAT
*res
)
73 if (*p
== '-') { res
->flags
|= WPRINTF_LEFTALIGN
; p
++; }
74 if (*p
== '#') { res
->flags
|= WPRINTF_PREFIX_HEX
; p
++; }
75 if (*p
== '0') { res
->flags
|= WPRINTF_ZEROPAD
; p
++; }
76 while ((*p
>= '0') && (*p
<= '9')) /* width field */
78 res
->width
= res
->width
* 10 + *p
- '0';
81 if (*p
== '.') /* precision field */
84 while ((*p
>= '0') && (*p
<= '9'))
86 res
->precision
= res
->precision
* 10 + *p
- '0';
90 if (*p
== 'l') { res
->flags
|= WPRINTF_LONG
; p
++; }
91 else if (*p
== 'h') { res
->flags
|= WPRINTF_SHORT
; p
++; }
92 else if (*p
== 'w') { res
->flags
|= WPRINTF_WIDE
; p
++; }
96 res
->type
= (res
->flags
& WPRINTF_LONG
) ? WPR_WCHAR
: WPR_CHAR
;
99 res
->type
= (res
->flags
& WPRINTF_SHORT
) ? WPR_CHAR
: WPR_WCHAR
;
103 res
->type
= WPR_SIGNED
;
106 res
->type
= (res
->flags
& (WPRINTF_LONG
|WPRINTF_WIDE
))
107 ? WPR_WSTRING
: WPR_STRING
;
110 res
->type
= (res
->flags
& (WPRINTF_SHORT
|WPRINTF_WIDE
))
111 ? WPR_STRING
: WPR_WSTRING
;
114 res
->type
= WPR_UNSIGNED
;
117 res
->flags
|= WPRINTF_UPPER_HEX
;
120 res
->type
= WPR_HEXA
;
122 default: /* unknown format char */
123 res
->type
= WPR_UNKNOWN
;
124 p
--; /* print format as normal char */
127 return (INT
)(p
- format
) + 1;
131 /***********************************************************************
132 * WPRINTF_ParseFormatW
134 * Parse a format specification. A format specification has the form:
136 * [-][#][0][width][.precision]type
138 * Return value is the length of the format specification in characters.
140 static INT
WPRINTF_ParseFormatW( LPCWSTR format
, WPRINTF_FORMAT
*res
)
147 if (*p
== '-') { res
->flags
|= WPRINTF_LEFTALIGN
; p
++; }
148 if (*p
== '#') { res
->flags
|= WPRINTF_PREFIX_HEX
; p
++; }
149 if (*p
== '0') { res
->flags
|= WPRINTF_ZEROPAD
; p
++; }
150 while ((*p
>= '0') && (*p
<= '9')) /* width field */
152 res
->width
= res
->width
* 10 + *p
- '0';
155 if (*p
== '.') /* precision field */
158 while ((*p
>= '0') && (*p
<= '9'))
160 res
->precision
= res
->precision
* 10 + *p
- '0';
164 if (*p
== 'l') { res
->flags
|= WPRINTF_LONG
; p
++; }
165 else if (*p
== 'h') { res
->flags
|= WPRINTF_SHORT
; p
++; }
166 else if (*p
== 'w') { res
->flags
|= WPRINTF_WIDE
; p
++; }
170 res
->type
= (res
->flags
& WPRINTF_SHORT
) ? WPR_CHAR
: WPR_WCHAR
;
173 res
->type
= (res
->flags
& WPRINTF_LONG
) ? WPR_WCHAR
: WPR_CHAR
;
177 res
->type
= WPR_SIGNED
;
180 res
->type
= ((res
->flags
& WPRINTF_SHORT
) && !(res
->flags
& WPRINTF_WIDE
)) ? WPR_STRING
: WPR_WSTRING
;
183 res
->type
= (res
->flags
& (WPRINTF_LONG
|WPRINTF_WIDE
)) ? WPR_WSTRING
: WPR_STRING
;
186 res
->type
= WPR_UNSIGNED
;
189 res
->flags
|= WPRINTF_UPPER_HEX
;
192 res
->type
= WPR_HEXA
;
195 res
->type
= WPR_UNKNOWN
;
196 p
--; /* print format as normal char */
199 return (INT
)(p
- format
) + 1;
203 /***********************************************************************
206 static UINT
WPRINTF_GetLen( WPRINTF_FORMAT
*format
, WPRINTF_DATA
*arg
,
207 LPSTR number
, UINT maxlen
)
211 if (format
->flags
& WPRINTF_LEFTALIGN
) format
->flags
&= ~WPRINTF_ZEROPAD
;
212 if (format
->width
> maxlen
) format
->width
= maxlen
;
217 return (format
->precision
= 1);
219 if (!arg
->lpcstr_view
) arg
->lpcstr_view
= null_stringA
;
220 for (len
= 0; !format
->precision
|| (len
< format
->precision
); len
++)
221 if (!*(arg
->lpcstr_view
+ len
)) break;
222 if (len
> maxlen
) len
= maxlen
;
223 return (format
->precision
= len
);
225 if (!arg
->lpcwstr_view
) arg
->lpcwstr_view
= null_stringW
;
226 for (len
= 0; !format
->precision
|| (len
< format
->precision
); len
++)
227 if (!*(arg
->lpcwstr_view
+ len
)) break;
228 if (len
> maxlen
) len
= maxlen
;
229 return (format
->precision
= len
);
231 len
= sprintf( number
, "%d", arg
->int_view
);
234 len
= sprintf( number
, "%u", (UINT
)arg
->int_view
);
237 len
= sprintf( number
,
238 (format
->flags
& WPRINTF_UPPER_HEX
) ? "%X" : "%x",
239 (UINT
)arg
->int_view
);
240 if (format
->flags
& WPRINTF_PREFIX_HEX
) len
+= 2;
245 if (len
> maxlen
) len
= maxlen
;
246 if (format
->precision
< len
) format
->precision
= len
;
247 if (format
->precision
> maxlen
) format
->precision
= maxlen
;
248 if ((format
->flags
& WPRINTF_ZEROPAD
) && (format
->width
> format
->precision
))
249 format
->precision
= format
->width
;
253 /***********************************************************************
254 * WPRINTF_ExtractVAPtr (Not a Windows API)
256 static WPRINTF_DATA
WPRINTF_ExtractVAPtr( WPRINTF_FORMAT
*format
, va_list* args
)
262 result
.wchar_view
= va_arg( *args
, WCHAR
); break;
264 result
.char_view
= va_arg( *args
, CHAR
); break;
266 result
.lpcstr_view
= va_arg( *args
, LPCSTR
); break;
268 result
.lpcwstr_view
= va_arg( *args
, LPCWSTR
); break;
272 result
.int_view
= va_arg( *args
, INT
); break;
274 result
.wchar_view
= 0; break;
279 /***********************************************************************
280 * wvsnprintf16 (Not a Windows API)
282 INT16 WINAPI
wvsnprintf16( LPSTR buffer
, UINT16 maxlen
, LPCSTR spec
,
285 WPRINTF_FORMAT format
;
289 WPRINTF_DATA cur_arg
;
292 while (*spec
&& (maxlen
> 1))
294 if (*spec
!= '%') { *p
++ = *spec
++; maxlen
--; continue; }
296 if (*spec
== '%') { *p
++ = *spec
++; maxlen
--; continue; }
297 spec
+= WPRINTF_ParseFormatA( spec
, &format
);
300 case WPR_WCHAR
: /* No Unicode in Win16 */
302 cur_arg
.char_view
= VA_ARG16( args
, CHAR
);
304 case WPR_WSTRING
: /* No Unicode in Win16 */
306 seg_str
= VA_ARG16( args
, SEGPTR
);
307 if (IsBadReadPtr16(seg_str
, 1 )) cur_arg
.lpcstr_view
= "";
308 else cur_arg
.lpcstr_view
= PTR_SEG_TO_LIN( seg_str
);
311 if (!(format
.flags
& WPRINTF_LONG
))
313 cur_arg
.int_view
= VA_ARG16( args
, INT16
);
319 if (format
.flags
& WPRINTF_LONG
)
320 cur_arg
.int_view
= VA_ARG16( args
, UINT
);
322 cur_arg
.int_view
= VA_ARG16( args
, UINT16
);
327 len
= WPRINTF_GetLen( &format
, &cur_arg
, number
, maxlen
- 1 );
328 if (!(format
.flags
& WPRINTF_LEFTALIGN
))
329 for (i
= format
.precision
; i
< format
.width
; i
++, maxlen
--)
333 case WPR_WCHAR
: /* No Unicode in Win16 */
335 *p
= cur_arg
.char_view
;
337 else if (format
.width
> 1) *p
++ = ' ';
340 case WPR_WSTRING
: /* No Unicode in Win16 */
342 if (len
) memcpy( p
, cur_arg
.lpcstr_view
, len
);
346 if ((format
.flags
& WPRINTF_PREFIX_HEX
) && (maxlen
> 3))
349 *p
++ = (format
.flags
& WPRINTF_UPPER_HEX
) ? 'X' : 'x';
352 format
.precision
-= 2;
358 for (i
= len
; i
< format
.precision
; i
++, maxlen
--) *p
++ = '0';
359 if (len
) memcpy( p
, number
, len
);
365 if (format
.flags
& WPRINTF_LEFTALIGN
)
366 for (i
= format
.precision
; i
< format
.width
; i
++, maxlen
--)
371 return (maxlen
> 1) ? (INT
)(p
- buffer
) : -1;
375 /***********************************************************************
376 * wvsnprintfA (Not a Windows API)
378 INT WINAPI
wvsnprintfA( LPSTR buffer
, UINT maxlen
, LPCSTR spec
,
381 WPRINTF_FORMAT format
;
385 WPRINTF_DATA argData
= (WPRINTF_DATA
)0;
387 while (*spec
&& (maxlen
> 1))
389 if (*spec
!= '%') { *p
++ = *spec
++; maxlen
--; continue; }
391 if (*spec
== '%') { *p
++ = *spec
++; maxlen
--; continue; }
392 spec
+= WPRINTF_ParseFormatA( spec
, &format
);
393 argData
= WPRINTF_ExtractVAPtr( &format
, &args
);
394 len
= WPRINTF_GetLen( &format
, &argData
, number
, maxlen
- 1 );
395 if (!(format
.flags
& WPRINTF_LEFTALIGN
))
396 for (i
= format
.precision
; i
< format
.width
; i
++, maxlen
--)
401 *p
= argData
.wchar_view
;
403 else if (format
.width
> 1) *p
++ = ' ';
407 *p
= argData
.char_view
;
409 else if (format
.width
> 1) *p
++ = ' ';
413 memcpy( p
, argData
.lpcstr_view
, len
);
418 LPCWSTR ptr
= argData
.lpcwstr_view
;
419 for (i
= 0; i
< len
; i
++) *p
++ = (CHAR
)*ptr
++;
423 if ((format
.flags
& WPRINTF_PREFIX_HEX
) && (maxlen
> 3))
426 *p
++ = (format
.flags
& WPRINTF_UPPER_HEX
) ? 'X' : 'x';
429 format
.precision
-= 2;
435 for (i
= len
; i
< format
.precision
; i
++, maxlen
--) *p
++ = '0';
436 memcpy( p
, number
, len
);
438 /* Go to the next arg */
443 if (format
.flags
& WPRINTF_LEFTALIGN
)
444 for (i
= format
.precision
; i
< format
.width
; i
++, maxlen
--)
449 TRACE(string
,"%s\n",buffer
);
450 return (maxlen
> 1) ? (INT
)(p
- buffer
) : -1;
454 /***********************************************************************
455 * wvsnprintfW (Not a Windows API)
457 INT WINAPI
wvsnprintfW( LPWSTR buffer
, UINT maxlen
, LPCWSTR spec
,
460 WPRINTF_FORMAT format
;
465 while (*spec
&& (maxlen
> 1))
467 if (*spec
!= '%') { *p
++ = *spec
++; maxlen
--; continue; }
469 if (*spec
== '%') { *p
++ = *spec
++; maxlen
--; continue; }
470 spec
+= WPRINTF_ParseFormatW( spec
, &format
);
471 len
= WPRINTF_GetLen( &format
, args
, number
, maxlen
- 1 );
472 if (!(format
.flags
& WPRINTF_LEFTALIGN
))
473 for (i
= format
.precision
; i
< format
.width
; i
++, maxlen
--)
478 *p
= va_arg( args
, WCHAR
);
480 else if (format
.width
> 1) *p
++ = ' ';
484 *p
= (WCHAR
)va_arg( args
, CHAR
);
486 else if (format
.width
> 1) *p
++ = ' ';
491 LPCSTR ptr
= va_arg( args
, LPCSTR
);
492 for (i
= 0; i
< len
; i
++) *p
++ = (WCHAR
)*ptr
++;
496 if (len
) memcpy( p
, va_arg( args
, LPCWSTR
), len
* sizeof(WCHAR
) );
500 if ((format
.flags
& WPRINTF_PREFIX_HEX
) && (maxlen
> 3))
503 *p
++ = (format
.flags
& WPRINTF_UPPER_HEX
) ? 'X' : 'x';
506 format
.precision
-= 2;
512 for (i
= len
; i
< format
.precision
; i
++, maxlen
--) *p
++ = '0';
513 for (i
= 0; i
< len
; i
++) *p
++ = (WCHAR
)number
[i
];
514 (void)va_arg( args
, INT
); /* Go to the next arg */
519 if (format
.flags
& WPRINTF_LEFTALIGN
)
520 for (i
= format
.precision
; i
< format
.width
; i
++, maxlen
--)
525 return (maxlen
> 1) ? (INT
)(p
- buffer
) : -1;
529 /***********************************************************************
530 * wvsprintf16 (USER.421)
532 INT16 WINAPI
wvsprintf16( LPSTR buffer
, LPCSTR spec
, LPCVOID args
)
534 TRACE(string
,"for %p got:\n",buffer
);
535 return wvsnprintf16( buffer
, 0xffff, spec
, args
);
539 /***********************************************************************
540 * wvsprintfA (USER32.587)
542 INT WINAPI
wvsprintfA( LPSTR buffer
, LPCSTR spec
, va_list args
)
544 TRACE(string
,"for %p got:\n",buffer
);
545 return wvsnprintfA( buffer
, 0xffffffff, spec
, args
);
549 /***********************************************************************
550 * wvsprintfW (USER32.588)
552 INT WINAPI
wvsprintfW( LPWSTR buffer
, LPCWSTR spec
, va_list args
)
554 TRACE(string
,"for %p got:\n",buffer
);
555 return wvsnprintfW( buffer
, 0xffffffff, spec
, args
);
559 /***********************************************************************
560 * wsprintf16 (USER.420)
562 /* Winelib version */
563 INT16 WINAPIV
wsprintf16( LPSTR buffer
, LPCSTR spec
, ... )
568 TRACE(string
,"for %p got:\n",buffer
);
569 va_start( valist
, spec
);
570 /* Note: we call the 32-bit version, because the args are 32-bit */
571 res
= (INT16
)wvsnprintfA( buffer
, 0xffffffff, spec
, valist
);
576 /* Emulator version */
577 INT16 WINAPIV
WIN16_wsprintf16(void)
583 VA_START16( valist
);
584 buffer
= VA_ARG16( valist
, SEGPTR
);
585 spec
= VA_ARG16( valist
, SEGPTR
);
586 TRACE(string
,"got:\n");
587 res
= wvsnprintf16( (LPSTR
)PTR_SEG_TO_LIN(buffer
), 0xffff,
588 (LPCSTR
)PTR_SEG_TO_LIN(spec
), valist
);
594 /***********************************************************************
595 * wsprintfA (USER32.585)
597 INT WINAPIV
wsprintfA( LPSTR buffer
, LPCSTR spec
, ... )
602 TRACE(string
,"for %p got:\n",buffer
);
603 va_start( valist
, spec
);
604 res
= wvsnprintfA( buffer
, 0xffffffff, spec
, valist
);
610 /***********************************************************************
611 * wsprintfW (USER32.586)
613 INT WINAPIV
wsprintfW( LPWSTR buffer
, LPCWSTR spec
, ... )
618 TRACE(string
,"wsprintfW for %p\n",buffer
);
619 va_start( valist
, spec
);
620 res
= wvsnprintfW( buffer
, 0xffffffff, spec
, valist
);
626 /***********************************************************************
627 * wsnprintf16 (Not a Windows API)
629 INT16 WINAPIV
wsnprintf16( LPSTR buffer
, UINT16 maxlen
, LPCSTR spec
, ... )
634 va_start( valist
, spec
);
635 res
= wvsnprintf16( buffer
, maxlen
, spec
, valist
);
641 /***********************************************************************
642 * wsnprintfA (Not a Windows API)
644 INT WINAPIV
wsnprintfA( LPSTR buffer
, UINT maxlen
, LPCSTR spec
, ... )
649 va_start( valist
, spec
);
650 res
= wvsnprintfA( buffer
, maxlen
, spec
, valist
);
656 /***********************************************************************
657 * wsnprintfW (Not a Windows API)
659 INT WINAPIV
wsnprintfW( LPWSTR buffer
, UINT maxlen
, LPCWSTR spec
, ... )
664 va_start( valist
, spec
);
665 res
= wvsnprintfW( buffer
, maxlen
, spec
, valist
);