ntdll: Silence RtlNtStatusToDosErrorNoTeb() a bit.
[wine] / dlls / ntdll / printf.c
1 /*
2  * ntdll printf functions
3  *
4  * Copyright 1999, 2009 Alexandre Julliard
5  * Copyright 2000 Jon Griffiths
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <ctype.h>
27 #include <stdarg.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31
32 #include "windef.h"
33 #include "winternl.h"
34 #include "ntdll_misc.h"
35 #include "wine/unicode.h"
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
39
40 static const SIZE_T size_max = ~(SIZE_T)0 >> 1;
41
42 /* FIXME: convert sizes to SIZE_T etc. */
43
44 typedef struct pf_output_t
45 {
46     int used;
47     int len;
48     BOOL unicode;
49     union {
50         LPWSTR W;
51         LPSTR  A;
52     } buf;
53 } pf_output;
54
55 typedef struct pf_flags_t
56 {
57     char Sign, LeftAlign, Alternate, PadZero;
58     int FieldLength, Precision;
59     char IntegerLength, IntegerDouble;
60     char WideString;
61     char Format;
62 } pf_flags;
63
64 /*
65  * writes a string of characters to the output
66  * returns -1 if the string doesn't fit in the output buffer
67  * return the length of the string if all characters were written
68  */
69 static inline int pf_output_stringW( pf_output *out, LPCWSTR str, int len )
70 {
71     int space = out->len - out->used;
72
73     if( len < 0 )
74         len = strlenW( str );
75     if( out->unicode )
76     {
77         LPWSTR p = out->buf.W + out->used;
78
79         if( space >= len )
80         {
81             memcpy( p, str, len*sizeof(WCHAR) );
82             out->used += len;
83             return len;
84         }
85         if( space > 0 )
86             memcpy( p, str, space*sizeof(WCHAR) );
87         out->used += len;
88     }
89     else
90     {
91         LPSTR p = out->buf.A + out->used;
92         ULONG n;
93
94         RtlUnicodeToMultiByteSize( &n, str, len * sizeof(WCHAR) );
95         if( space >= n )
96         {
97             RtlUnicodeToMultiByteN( p, n, NULL, str, len * sizeof(WCHAR) );
98             out->used += n;
99             return len;
100         }
101         if (space > 0) RtlUnicodeToMultiByteN( p, space, NULL, str, len * sizeof(WCHAR) );
102         out->used += n;
103     }
104     return -1;
105 }
106
107 static inline int pf_output_stringA( pf_output *out, LPCSTR str, int len )
108 {
109     int space = out->len - out->used;
110
111     if( len < 0 )
112         len = strlen( str );
113     if( !out->unicode )
114     {
115         LPSTR p = out->buf.A + out->used;
116
117         if( space >= len )
118         {
119             memcpy( p, str, len );
120             out->used += len;
121             return len;
122         }
123         if( space > 0 )
124             memcpy( p, str, space );
125         out->used += len;
126     }
127     else
128     {
129         LPWSTR p = out->buf.W + out->used;
130         ULONG n;
131
132         RtlMultiByteToUnicodeSize( &n, str, len );
133         if (space >= n / sizeof(WCHAR))
134         {
135             RtlMultiByteToUnicodeN( p, n, NULL, str, len );
136             out->used += n / sizeof(WCHAR);
137             return len;
138         }
139         if (space > 0) RtlMultiByteToUnicodeN( p, space * sizeof(WCHAR), NULL, str, len );
140         out->used += n;
141     }
142     return -1;
143 }
144
145 /* pf_fill: takes care of signs, alignment, zero and field padding */
146 static inline int pf_fill( pf_output *out, int len, pf_flags *flags, char left )
147 {
148     int i, r = 0;
149
150     if( flags->Sign && !( flags->Format == 'd' || flags->Format == 'i' ) )
151         flags->Sign = 0;
152
153     if( left && flags->Sign )
154     {
155         flags->FieldLength--;
156         if( flags->PadZero )
157             r = pf_output_stringA( out, &flags->Sign, 1 );
158     }
159
160     if( ( !left &&  flags->LeftAlign ) ||
161         (  left && !flags->LeftAlign ))
162     {
163         for( i=0; (i<(flags->FieldLength-len)) && (r>=0); i++ )
164         {
165             if( left && flags->PadZero )
166                 r = pf_output_stringA( out, "0", 1 );
167             else
168                 r = pf_output_stringA( out, " ", 1 );
169         }
170     }
171
172     if( left && flags->Sign && !flags->PadZero )
173         r = pf_output_stringA( out, &flags->Sign, 1 );
174
175     return r;
176 }
177
178 static inline int pf_output_format_W( pf_output *out, LPCWSTR str,
179                                       int len, pf_flags *flags )
180 {
181     int r = 0;
182
183     if( len < 0 )
184         len = strlenW( str );
185
186     if (flags->Precision >= 0 && flags->Precision < len)
187         len = flags->Precision;
188
189     r = pf_fill( out, len, flags, 1 );
190
191     if( r>=0 )
192         r = pf_output_stringW( out, str, len );
193
194     if( r>=0 )
195         r = pf_fill( out, len, flags, 0 );
196
197     return r;
198 }
199
200 static inline int pf_output_format_A( pf_output *out, LPCSTR str,
201                                       int len, pf_flags *flags )
202 {
203     int r = 0;
204
205     if( len < 0 )
206         len = strlen( str );
207
208     if (flags->Precision >= 0 && flags->Precision < len)
209         len = flags->Precision;
210
211     r = pf_fill( out, len, flags, 1 );
212
213     if( r>=0 )
214         r = pf_output_stringA( out, str, len );
215
216     if( r>=0 )
217         r = pf_fill( out, len, flags, 0 );
218
219     return r;
220 }
221
222 static int pf_handle_string_format( pf_output *out, const void* str, int len,
223                              pf_flags *flags, BOOL capital_letter)
224 {
225      if(str == NULL)  /* catch NULL pointer */
226         return pf_output_format_A( out, "(null)", -1, flags);
227
228      /* prefixes take priority over %c,%s vs. %C,%S, so we handle them first */
229     if(flags->WideString || flags->IntegerLength == 'l')
230         return pf_output_format_W( out, str, len, flags);
231     if(flags->IntegerLength == 'h')
232         return pf_output_format_A( out, str, len, flags);
233
234     /* %s,%c ->  chars in ansi functions & wchars in unicode
235      * %S,%C -> wchars in ansi functions &  chars in unicode */
236     if( capital_letter == out->unicode) /* either both TRUE or both FALSE */
237         return pf_output_format_A( out, str, len, flags);
238     else
239         return pf_output_format_W( out, str, len, flags);
240 }
241
242 static inline BOOL pf_is_integer_format( char fmt )
243 {
244     static const char float_fmts[] = "diouxX";
245     if (!fmt)
246         return FALSE;
247     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
248 }
249
250 static inline BOOL pf_is_double_format( char fmt )
251 {
252     static const char float_fmts[] = "aeEfgG";
253     if (!fmt)
254         return FALSE;
255     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
256 }
257
258 static inline BOOL pf_is_valid_format( char fmt )
259 {
260     static const char float_fmts[] = "acCdeEfgGinouxX";
261     if (!fmt)
262         return FALSE;
263     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
264 }
265
266 static void pf_rebuild_format_string( char *p, pf_flags *flags )
267 {
268     *p++ = '%';
269     if( flags->Sign )
270         *p++ = flags->Sign;
271     if( flags->LeftAlign )
272         *p++ = flags->LeftAlign;
273     if( flags->Alternate )
274         *p++ = flags->Alternate;
275     if( flags->PadZero )
276         *p++ = flags->PadZero;
277     if( flags->FieldLength )
278     {
279         sprintf(p, "%d", flags->FieldLength);
280         p += strlen(p);
281     }
282     if( flags->Precision >= 0 )
283     {
284         sprintf(p, ".%d", flags->Precision);
285         p += strlen(p);
286     }
287     *p++ = flags->Format;
288     *p++ = 0;
289 }
290
291 /* pf_integer_conv:  prints x to buf, including alternate formats and
292    additional precision digits, but not field characters or the sign */
293 static void pf_integer_conv( char *buf, int buf_len, pf_flags *flags,
294                              LONGLONG x )
295 {
296     unsigned int base;
297     const char *digits;
298
299     int i, j, k;
300     char number[40], *tmp = number;
301
302     if( buf_len > sizeof number )
303         tmp = RtlAllocateHeap( GetProcessHeap(), 0, buf_len );
304
305     base = 10;
306     if( flags->Format == 'o' )
307         base = 8;
308     else if( flags->Format == 'x' || flags->Format == 'X' )
309         base = 16;
310
311     if( flags->Format == 'X' )
312         digits = "0123456789ABCDEFX";
313     else
314         digits = "0123456789abcdefx";
315
316     if( x < 0 && ( flags->Format == 'd' || flags->Format == 'i' ) )
317     {
318         x = -x;
319         flags->Sign = '-';
320     }
321
322     /* Do conversion (backwards) */
323     i = 0;
324     if( x == 0 && flags->Precision )
325         tmp[i++] = '0';
326     else
327         while( x != 0 )
328         {
329             j = (ULONGLONG) x % base;
330             x = (ULONGLONG) x / base;
331             tmp[i++] = digits[j];
332         }
333     k = flags->Precision - i;
334     while( k-- > 0 )
335         tmp[i++] = '0';
336     if( flags->Alternate )
337     {
338         if( base == 16 )
339         {
340             tmp[i++] = digits[16];
341             tmp[i++] = '0';
342         }
343         else if( base == 8 && tmp[i-1] != '0' )
344             tmp[i++] = '0';
345     }
346
347     /* Reverse for buf */
348     j = 0;
349     while( i-- > 0 )
350         buf[j++] = tmp[i];
351     buf[j] = '\0';
352
353     /* Adjust precision so pf_fill won't truncate the number later */
354     flags->Precision = strlen( buf );
355
356     if( tmp != number )
357         RtlFreeHeap( GetProcessHeap(), 0, tmp );
358
359     return;
360 }
361
362 /* pf_fixup_exponent: convert a string containing a 2 digit exponent
363    to 3 digits, accounting for padding, in place. Needed to match
364    the native printf's which always use 3 digits. */
365 static void pf_fixup_exponent( char *buf )
366 {
367     char* tmp = buf;
368
369     while (tmp[0] && toupper(tmp[0]) != 'E')
370         tmp++;
371
372     if (tmp[0] && (tmp[1] == '+' || tmp[1] == '-') &&
373         isdigit(tmp[2]) && isdigit(tmp[3]))
374     {
375         char final;
376
377         if (isdigit(tmp[4]))
378             return; /* Exponent already 3 digits */
379
380         /* We have a 2 digit exponent. Prepend '0' to make it 3 */
381         tmp += 2;
382         final = tmp[2];
383         tmp[2] = tmp[1];
384         tmp[1] = tmp[0];
385         tmp[0] = '0';
386         if (final == '\0')
387         {
388             /* We didn't expand into trailing space, so this string isn't left
389              * justified. Terminate the string and strip a ' ' at the start of
390              * the string if there is one (as there may be if the string is
391              * right justified).
392              */
393             tmp[3] = '\0';
394             if (buf[0] == ' ')
395                 memmove(buf, buf + 1, (tmp - buf) + 3);
396         }
397         /* Otherwise, we expanded into trailing space -> nothing to do */
398     }
399 }
400
401 /*********************************************************************
402  *  pf_vsnprintf  (INTERNAL)
403  *
404  *  implements both A and W vsnprintf functions
405  */
406 static int pf_vsnprintf( pf_output *out, const WCHAR *format, __ms_va_list valist )
407 {
408     int r;
409     LPCWSTR q, p = format;
410     pf_flags flags;
411
412     TRACE("format is %s\n",debugstr_w(format));
413     while (*p)
414     {
415         q = strchrW( p, '%' );
416
417         /* there's no % characters left, output the rest of the string */
418         if( !q )
419         {
420             r = pf_output_stringW(out, p, -1);
421             if( r<0 )
422                 return r;
423             p += r;
424             continue;
425         }
426
427         /* there's characters before the %, output them */
428         if( q != p )
429         {
430             r = pf_output_stringW(out, p, q - p);
431             if( r<0 )
432                 return r;
433             p = q;
434         }
435
436         /* we must be at a % now, skip over it */
437         assert( *p == '%' );
438         p++;
439
440         /* output a single % character */
441         if( *p == '%' )
442         {
443             r = pf_output_stringW(out, p++, 1);
444             if( r<0 )
445                 return r;
446             continue;
447         }
448
449         /* parse the flags */
450         memset( &flags, 0, sizeof flags );
451         while (*p)
452         {
453             if( *p == '+' || *p == ' ' )
454             {
455                 if ( flags.Sign != '+' )
456                     flags.Sign = *p;
457             }
458             else if( *p == '-' )
459                 flags.LeftAlign = *p;
460             else if( *p == '0' )
461                 flags.PadZero = *p;
462             else if( *p == '#' )
463                 flags.Alternate = *p;
464             else
465                 break;
466             p++;
467         }
468
469         /* deal with the field width specifier */
470         flags.FieldLength = 0;
471         if( *p == '*' )
472         {
473             flags.FieldLength = va_arg( valist, int );
474             if (flags.FieldLength < 0)
475             {
476                 flags.LeftAlign = '-';
477                 flags.FieldLength = -flags.FieldLength;
478             }
479             p++;
480         }
481         else while( isdigit(*p) )
482         {
483             flags.FieldLength *= 10;
484             flags.FieldLength += *p++ - '0';
485         }
486
487         /* deal with precision */
488         flags.Precision = -1;
489         if( *p == '.' )
490         {
491             flags.Precision = 0;
492             p++;
493             if( *p == '*' )
494             {
495                 flags.Precision = va_arg( valist, int );
496                 p++;
497             }
498             else while( isdigit(*p) )
499             {
500                 flags.Precision *= 10;
501                 flags.Precision += *p++ - '0';
502             }
503         }
504
505         /* deal with integer width modifier */
506         while( *p )
507         {
508             if( *p == 'h' || *p == 'l' || *p == 'L' )
509             {
510                 flags.IntegerLength = *p;
511                 p++;
512             }
513             else if( *p == 'I' )
514             {
515                 if( *(p+1) == '6' && *(p+2) == '4' )
516                 {
517                     flags.IntegerDouble++;
518                     p += 3;
519                 }
520                 else if( *(p+1) == '3' && *(p+2) == '2' )
521                     p += 3;
522                 else if( isdigit(*(p+1)) || *(p+1) == 0 )
523                     break;
524                 else
525                     p++;
526             }
527             else if( *p == 'w' )
528                 flags.WideString = *p++;
529             else if( *p == 'F' )
530                 p++; /* ignore */
531             else
532                 break;
533         }
534
535         flags.Format = *p;
536         r = 0;
537
538         if (flags.Format == '$')
539         {
540             FIXME("Positional parameters are not supported (%s)\n", wine_dbgstr_w(format));
541             return -1;
542         }
543         /* output a string */
544         if(  flags.Format == 's' || flags.Format == 'S' )
545             r = pf_handle_string_format( out, va_arg(valist, const void*), -1,
546                                          &flags, (flags.Format == 'S') );
547
548         /* output a single character */
549         else if( flags.Format == 'c' || flags.Format == 'C' )
550         {
551             INT ch = va_arg( valist, int );
552
553             r = pf_handle_string_format( out, &ch, 1, &flags, (flags.Format == 'C') );
554         }
555
556         /* output a pointer */
557         else if( flags.Format == 'p' )
558         {
559             char pointer[32];
560             void *ptr = va_arg( valist, void * );
561
562             flags.PadZero = 0;
563             if( flags.Alternate )
564                 sprintf(pointer, "0X%0*lX", 2 * (int)sizeof(ptr), (ULONG_PTR)ptr);
565             else
566                 sprintf(pointer, "%0*lX", 2 * (int)sizeof(ptr), (ULONG_PTR)ptr);
567             r = pf_output_format_A( out, pointer, -1, &flags );
568         }
569
570         /* deal with %n */
571         else if( flags.Format == 'n' )
572         {
573             int *x = va_arg(valist, int *);
574             *x = out->used;
575         }
576
577         /* deal with 64-bit integers */
578         else if( pf_is_integer_format( flags.Format ) && flags.IntegerDouble )
579         {
580             char number[40], *x = number;
581
582             /* Estimate largest possible required buffer size:
583                * Chooses the larger of the field or precision
584                * Includes extra bytes: 1 byte for null, 1 byte for sign,
585                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
586                  for a decimal, and 1 byte for an additional float digit. */
587             int x_len = ((flags.FieldLength > flags.Precision) ?
588                         flags.FieldLength : flags.Precision) + 10;
589
590             if( x_len >= sizeof number)
591                 x = RtlAllocateHeap( GetProcessHeap(), 0, x_len );
592
593             pf_integer_conv( x, x_len, &flags, va_arg(valist, LONGLONG) );
594
595             r = pf_output_format_A( out, x, -1, &flags );
596             if( x != number )
597                 RtlFreeHeap( GetProcessHeap(), 0, x );
598         }
599
600         /* deal with integers and floats using libc's printf */
601         else if( pf_is_valid_format( flags.Format ) )
602         {
603             char fmt[20], number[40], *x = number;
604
605             /* Estimate largest possible required buffer size:
606                * Chooses the larger of the field or precision
607                * Includes extra bytes: 1 byte for null, 1 byte for sign,
608                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
609                  for a decimal, and 1 byte for an additional float digit. */
610             int x_len = ((flags.FieldLength > flags.Precision) ?
611                         flags.FieldLength : flags.Precision) + 10;
612
613             if( x_len >= sizeof number)
614                 x = RtlAllocateHeap( GetProcessHeap(), 0, x_len );
615
616             pf_rebuild_format_string( fmt, &flags );
617
618             if( pf_is_double_format( flags.Format ) )
619             {
620                 sprintf( x, fmt, va_arg(valist, double) );
621                 if (toupper(flags.Format) == 'E' || toupper(flags.Format) == 'G')
622                     pf_fixup_exponent( x );
623             }
624             else
625                 sprintf( x, fmt, va_arg(valist, int) );
626
627             r = pf_output_stringA( out, x, -1 );
628             if( x != number )
629                 RtlFreeHeap( GetProcessHeap(), 0, x );
630         }
631         else
632             continue;
633
634         if( r<0 )
635             return r;
636         p++;
637     }
638
639     /* check we reached the end, and null terminate the string */
640     assert( *p == 0 );
641     pf_output_stringW( out, p, 1 );
642
643     return out->used - 1;
644 }
645
646
647 /*********************************************************************
648  *                  _vsnprintf   (NTDLL.@)
649  */
650 int CDECL NTDLL__vsnprintf( char *str, SIZE_T len, const char *format, __ms_va_list args )
651 {
652     DWORD sz;
653     LPWSTR formatW = NULL;
654     pf_output out;
655     int r;
656
657     out.unicode = FALSE;
658     out.buf.A = str;
659     out.used = 0;
660     out.len = len;
661
662     if (format)
663     {
664         RtlMultiByteToUnicodeSize( &sz, format, strlen(format) + 1 );
665         if (!(formatW = RtlAllocateHeap( GetProcessHeap(), 0, sz ))) return -1;
666         RtlMultiByteToUnicodeN( formatW, sz, NULL, format, strlen(format) + 1 );
667     }
668     r = pf_vsnprintf( &out, formatW, args );
669     RtlFreeHeap( GetProcessHeap(), 0, formatW );
670     return r;
671 }
672
673
674 /***********************************************************************
675  *                  _vsnwprintf   (NTDLL.@)
676  */
677 int CDECL NTDLL__vsnwprintf( WCHAR *str, SIZE_T len, const WCHAR *format, __ms_va_list args )
678 {
679     pf_output out;
680
681     out.unicode = TRUE;
682     out.buf.W = str;
683     out.used = 0;
684     out.len = len;
685
686     return pf_vsnprintf( &out, format, args );
687 }
688
689
690 /*********************************************************************
691  *                  _snprintf   (NTDLL.@)
692  */
693 int CDECL NTDLL__snprintf( char *str, SIZE_T len, const char *format, ... )
694 {
695     int ret;
696     __ms_va_list valist;
697
698     __ms_va_start( valist, format );
699     ret = NTDLL__vsnprintf( str, len, format, valist );
700     __ms_va_end( valist );
701     return ret;
702 }
703
704
705 /***********************************************************************
706  *                  _snwprintf   (NTDLL.@)
707  */
708 int CDECL NTDLL__snwprintf( WCHAR *str, SIZE_T len, const WCHAR *format, ... )
709 {
710     int ret;
711     __ms_va_list valist;
712
713     __ms_va_start(valist, format);
714     ret = NTDLL__vsnwprintf( str, len, format, valist );
715     __ms_va_end(valist);
716     return ret;
717 }
718
719
720 /*********************************************************************
721  *                  vsprintf   (NTDLL.@)
722  */
723 int CDECL NTDLL_vsprintf( char *str, const char *format, __ms_va_list args )
724 {
725     return NTDLL__vsnprintf( str, size_max, format, args );
726 }
727
728
729 /*********************************************************************
730  *                  sprintf   (NTDLL.@)
731  */
732 int CDECL NTDLL_sprintf( char *str, const char *format, ... )
733 {
734     int ret;
735     __ms_va_list valist;
736
737     __ms_va_start( valist, format );
738     ret = NTDLL__vsnprintf( str, size_max, format, valist );
739     __ms_va_end( valist );
740     return ret;
741 }
742
743
744 /***********************************************************************
745  *                  swprintf   (NTDLL.@)
746  */
747 int CDECL NTDLL_swprintf( WCHAR *str, const WCHAR *format, ... )
748 {
749     int ret;
750     __ms_va_list valist;
751
752     __ms_va_start(valist, format);
753     ret = NTDLL__vsnwprintf( str, size_max, format, valist );
754     __ms_va_end(valist);
755     return ret;
756 }