1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/private/wxprintf.h
3 // Purpose: wxWidgets wxPrintf() implementation
5 // Modified by: Ron Lee, Francesco Montorsi
8 // Copyright: (c) wxWidgets copyright
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_PRIVATE_WXPRINTF_H_
13 #define _WX_PRIVATE_WXPRINTF_H_
15 // ---------------------------------------------------------------------------
17 // ---------------------------------------------------------------------------
25 #if defined(__MWERKS__) && __MSL__ >= 0x6000
30 // prefer snprintf over sprintf
31 #if defined(__VISUALC__) || \
32 (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
33 #define system_sprintf(buff, max, flags, data) \
34 ::_snprintf(buff, max, flags, data)
35 #elif defined(HAVE_SNPRINTF)
36 #define system_sprintf(buff, max, flags, data) \
37 ::snprintf(buff, max, flags, data)
38 #else // NB: at least sprintf() should always be available
39 // since 'max' is not used in this case, wxVsnprintf() should always
40 // ensure that 'buff' is big enough for all common needs
41 // (see wxMAX_SVNPRINTF_FLAGBUFFER_LEN and wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN)
42 #define system_sprintf(buff, max, flags, data) \
43 ::sprintf(buff, flags, data)
45 #define SYSTEM_SPRINTF_IS_UNSAFE
48 // ---------------------------------------------------------------------------
49 // printf format string parsing
50 // ---------------------------------------------------------------------------
52 // some limits of our implementation
53 #define wxMAX_SVNPRINTF_ARGUMENTS 64
54 #define wxMAX_SVNPRINTF_FLAGBUFFER_LEN 32
55 #define wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN 512
58 // the conversion specifiers accepted by wxCRT_VsnprintfW
63 wxPAT_INT
, // %d, %i, %o, %u, %x, %X
64 wxPAT_LONGINT
, // %ld, etc
66 wxPAT_LONGLONGINT
, // %Ld, etc
68 wxPAT_SIZET
, // %zd, etc
70 wxPAT_DOUBLE
, // %e, %E, %f, %g, %G
71 wxPAT_LONGDOUBLE
, // %le, etc
75 wxPAT_CHAR
, // %hc (in ANSI mode: %c, too)
76 wxPAT_WCHAR
, // %lc (in Unicode mode: %c, too)
78 wxPAT_PCHAR
, // %s (related to a char *)
79 wxPAT_PWCHAR
, // %s (related to a wchar_t *)
82 wxPAT_NSHORTINT
, // %hn
83 wxPAT_NLONGINT
, // %ln
85 wxPAT_STAR
// '*' used for width or precision
88 // an argument passed to wxCRT_VsnprintfW
91 int pad_int
; // %d, %i, %o, %u, %x, %X
92 long int pad_longint
; // %ld, etc
94 wxLongLong_t pad_longlongint
; // %Ld, etc
96 size_t pad_sizet
; // %zd, etc
98 double pad_double
; // %e, %E, %f, %g, %G
99 long double pad_longdouble
; // %le, etc
101 void *pad_pointer
; // %p
103 char pad_char
; // %hc (in ANSI mode: %c, too)
104 wchar_t pad_wchar
; // %lc (in Unicode mode: %c, too)
109 short int *pad_nshortint
; // %hn
110 long int *pad_nlongint
; // %ln
113 // helper for converting string into either char* or wchar_t* depending
114 // on the type of wxPrintfConvSpec<T> instantiation:
115 template<typename CharType
> struct wxPrintfStringHelper
{};
117 template<> struct wxPrintfStringHelper
<char>
119 typedef const wxWX2MBbuf ConvertedType
;
120 static ConvertedType
Convert(const wxString
& s
) { return s
.mb_str(); }
123 template<> struct wxPrintfStringHelper
<wchar_t>
125 typedef const wxWX2WCbuf ConvertedType
;
126 static ConvertedType
Convert(const wxString
& s
) { return s
.wc_str(); }
130 // Contains parsed data relative to a conversion specifier given to
131 // wxCRT_VsnprintfW and parsed from the format string
132 // NOTE: in C++ there is almost no difference between struct & classes thus
133 // there is no performance gain by using a struct here...
134 template<typename CharType
>
135 class wxPrintfConvSpec
139 // the position of the argument relative to this conversion specifier
142 // the type of this conversion specifier
143 wxPrintfArgType m_type
;
145 // the minimum and maximum width
146 // when one of this var is set to -1 it means: use the following argument
147 // in the stack as minimum/maximum width for this conversion specifier
148 int m_nMinWidth
, m_nMaxWidth
;
150 // does the argument need to the be aligned to left ?
153 // pointer to the '%' of this conversion specifier in the format string
154 // NOTE: this points somewhere in the string given to the Parse() function -
155 // it's task of the caller ensure that memory is still valid !
156 const CharType
*m_pArgPos
;
158 // pointer to the last character of this conversion specifier in the
160 // NOTE: this points somewhere in the string given to the Parse() function -
161 // it's task of the caller ensure that memory is still valid !
162 const CharType
*m_pArgEnd
;
164 // a little buffer where formatting flags like #+\.hlqLz are stored by Parse()
165 // for use in Process()
166 char m_szFlags
[wxMAX_SVNPRINTF_FLAGBUFFER_LEN
];
171 // we don't declare this as a constructor otherwise it would be called
172 // automatically and we don't want this: to be optimized, wxCRT_VsnprintfW
173 // calls this function only on really-used instances of this class.
176 // Parses the first conversion specifier in the given string, which must
177 // begin with a '%'. Returns false if the first '%' does not introduce a
178 // (valid) conversion specifier and thus should be ignored.
179 bool Parse(const CharType
*format
);
181 // Process this conversion specifier and puts the result in the given
182 // buffer. Returns the number of characters written in 'buf' or -1 if
183 // there's not enough space.
184 int Process(CharType
*buf
, size_t lenMax
, wxPrintfArg
*p
, size_t written
);
186 // Loads the argument of this conversion specifier from given va_list.
187 bool LoadArg(wxPrintfArg
*p
, va_list &argptr
);
190 // An helper function of LoadArg() which is used to handle the '*' flag
191 void ReplaceAsteriskWith(int w
);
194 template<typename CharType
>
195 void wxPrintfConvSpec
<CharType
>::Init()
198 m_nMaxWidth
= 0xFFFF;
200 m_bAlignLeft
= false;
201 m_pArgPos
= m_pArgEnd
= NULL
;
202 m_type
= wxPAT_INVALID
;
204 memset(m_szFlags
, 0, sizeof(m_szFlags
));
205 // this character will never be removed from m_szFlags array and
206 // is important when calling sprintf() in wxPrintfConvSpec::Process() !
210 template<typename CharType
>
211 bool wxPrintfConvSpec
<CharType
>::Parse(const CharType
*format
)
215 // temporary parse data
217 bool in_prec
, // true if we found the dot in some previous iteration
218 prec_dot
; // true if the dot has been already added to m_szFlags
221 m_bAlignLeft
= in_prec
= prec_dot
= false;
222 m_pArgPos
= m_pArgEnd
= format
;
226 if (in_prec && !prec_dot) \
228 m_szFlags[flagofs++] = '.'; \
233 const CharType ch
= *(++m_pArgEnd
);
237 return false; // not really an argument
240 return false; // not really an argument
248 m_szFlags
[flagofs
++] = char(ch
);
254 m_szFlags
[flagofs
++] = char(ch
);
258 // don't use CHECK_PREC here to avoid warning about the value
259 // assigned to prec_dot inside it being never used (because
260 // overwritten just below) from Borland in release build
261 if (in_prec
&& !prec_dot
)
262 m_szFlags
[flagofs
++] = '.';
266 // dot will be auto-added to m_szFlags if non-negative
273 m_szFlags
[flagofs
++] = char(ch
);
277 // NB: it's safe to use flagofs-1 as flagofs always start from 1
278 if (m_szFlags
[flagofs
-1] == 'l') // 'll' modifier is the same as 'L' or 'q'
283 m_szFlags
[flagofs
++] = char(ch
);
290 m_szFlags
[flagofs
++] = char(ch
);
293 // under Windows we support the special '%I64' notation as longlong
294 // integer conversion specifier for MSVC compatibility
295 // (it behaves exactly as '%lli' or '%Li' or '%qi')
297 if (*(m_pArgEnd
+1) == wxT('6') &&
298 *(m_pArgEnd
+2) == wxT('4'))
305 m_szFlags
[flagofs
++] = char(ch
);
306 m_szFlags
[flagofs
++] = '6';
307 m_szFlags
[flagofs
++] = '4';
310 // else: fall-through, 'I' is MSVC equivalent of C99 'z'
311 #endif // __WINDOWS__
315 // 'z' is C99 standard for size_t and ptrdiff_t, 'Z' was used
316 // for this purpose in libc5 and by wx <= 2.8
319 m_szFlags
[flagofs
++] = char(ch
);
327 // tell Process() to use the next argument
328 // in the stack as maxwidth...
333 // tell Process() to use the next argument
334 // in the stack as minwidth...
338 // save the * in our formatting buffer...
339 // will be replaced later by Process()
340 m_szFlags
[flagofs
++] = char(ch
);
343 case wxT('1'): case wxT('2'): case wxT('3'):
344 case wxT('4'): case wxT('5'): case wxT('6'):
345 case wxT('7'): case wxT('8'): case wxT('9'):
349 while ( (*m_pArgEnd
>= CharType('0')) &&
350 (*m_pArgEnd
<= CharType('9')) )
352 m_szFlags
[flagofs
++] = char(*m_pArgEnd
);
353 len
= len
*10 + (*m_pArgEnd
- wxT('0'));
362 m_pArgEnd
--; // the main loop pre-increments n again
366 case wxT('$'): // a positional parameter (e.g. %2$s) ?
368 if (m_nMinWidth
<= 0)
369 break; // ignore this formatting flag as no
370 // numbers are preceding it
372 // remove from m_szFlags all digits previously added
375 } while (m_szFlags
[flagofs
] >= '1' &&
376 m_szFlags
[flagofs
] <= '9');
378 // re-adjust the offset making it point to the
379 // next free char of m_szFlags
394 m_szFlags
[flagofs
++] = char(ch
);
398 // NB: 'short int' value passed through '...'
399 // is promoted to 'int', so we have to get
400 // an int from stack even if we need a short
403 m_type
= wxPAT_LONGINT
;
406 m_type
= wxPAT_LONGLONGINT
;
407 #else // !wxLongLong_t
408 m_type
= wxPAT_LONGINT
;
409 #endif // wxLongLong_t/!wxLongLong_t
411 m_type
= wxPAT_SIZET
;
421 m_szFlags
[flagofs
++] = char(ch
);
423 m_type
= wxPAT_LONGDOUBLE
;
425 m_type
= wxPAT_DOUBLE
;
430 m_type
= wxPAT_POINTER
;
431 m_szFlags
[flagofs
++] = char(ch
);
438 // in Unicode mode %hc == ANSI character
439 // and in ANSI mode, %hc == %c == ANSI...
444 // in ANSI mode %lc == Unicode character
445 // and in Unicode mode, %lc == %c == Unicode...
446 m_type
= wxPAT_WCHAR
;
451 // in Unicode mode, %c == Unicode character
452 m_type
= wxPAT_WCHAR
;
454 // in ANSI mode, %c == ANSI character
464 // Unicode mode wx extension: we'll let %hs mean non-Unicode
465 // strings (when in ANSI mode, %s == %hs == ANSI string)
466 m_type
= wxPAT_PCHAR
;
470 // in Unicode mode, %ls == %s == Unicode string
471 // in ANSI mode, %ls == Unicode string
472 m_type
= wxPAT_PWCHAR
;
477 m_type
= wxPAT_PWCHAR
;
479 m_type
= wxPAT_PCHAR
;
489 m_type
= wxPAT_NSHORTINT
;
491 m_type
= wxPAT_NLONGINT
;
496 // bad format, don't consider this an argument;
497 // leave it unchanged
501 if (flagofs
== wxMAX_SVNPRINTF_FLAGBUFFER_LEN
)
503 wxLogDebug(wxT("Too many flags specified for a single conversion specifier!"));
509 return true; // parsing was successful
512 template<typename CharType
>
513 void wxPrintfConvSpec
<CharType
>::ReplaceAsteriskWith(int width
)
515 char temp
[wxMAX_SVNPRINTF_FLAGBUFFER_LEN
];
517 // find the first * in our flag buffer
518 char *pwidth
= strchr(m_szFlags
, '*');
519 wxCHECK_RET(pwidth
, wxT("field width must be specified"));
521 // save what follows the * (the +1 is to skip the asterisk itself!)
522 strcpy(temp
, pwidth
+1);
525 pwidth
[0] = wxT('-');
529 // replace * with the actual integer given as width
530 #ifndef SYSTEM_SPRINTF_IS_UNSAFE
531 int maxlen
= (m_szFlags
+ wxMAX_SVNPRINTF_FLAGBUFFER_LEN
- pwidth
) /
534 int offset
= system_sprintf(pwidth
, maxlen
, "%d", abs(width
));
536 // restore after the expanded * what was following it
537 strcpy(pwidth
+offset
, temp
);
540 template<typename CharType
>
541 bool wxPrintfConvSpec
<CharType
>::LoadArg(wxPrintfArg
*p
, va_list &argptr
)
543 // did the '*' width/precision specifier was used ?
544 if (m_nMaxWidth
== -1)
546 // take the maxwidth specifier from the stack
547 m_nMaxWidth
= va_arg(argptr
, int);
551 ReplaceAsteriskWith(m_nMaxWidth
);
554 if (m_nMinWidth
== -1)
556 // take the minwidth specifier from the stack
557 m_nMinWidth
= va_arg(argptr
, int);
559 ReplaceAsteriskWith(m_nMinWidth
);
562 m_bAlignLeft
= !m_bAlignLeft
;
563 m_nMinWidth
= -m_nMinWidth
;
569 p
->pad_int
= va_arg(argptr
, int);
572 p
->pad_longint
= va_arg(argptr
, long int);
575 case wxPAT_LONGLONGINT
:
576 p
->pad_longlongint
= va_arg(argptr
, wxLongLong_t
);
578 #endif // wxLongLong_t
580 p
->pad_sizet
= va_arg(argptr
, size_t);
583 p
->pad_double
= va_arg(argptr
, double);
585 case wxPAT_LONGDOUBLE
:
586 p
->pad_longdouble
= va_arg(argptr
, long double);
589 p
->pad_pointer
= va_arg(argptr
, void *);
593 p
->pad_char
= (char)va_arg(argptr
, int); // char is promoted to int when passed through '...'
596 p
->pad_wchar
= (wchar_t)va_arg(argptr
, int); // char is promoted to int when passed through '...'
601 p
->pad_str
= va_arg(argptr
, void *);
605 p
->pad_nint
= va_arg(argptr
, int *);
607 case wxPAT_NSHORTINT
:
608 p
->pad_nshortint
= va_arg(argptr
, short int *);
611 p
->pad_nlongint
= va_arg(argptr
, long int *);
615 // this will be handled as part of the next argument
623 return true; // loading was successful
626 template<typename CharType
>
627 int wxPrintfConvSpec
<CharType
>::Process(CharType
*buf
, size_t lenMax
, wxPrintfArg
*p
, size_t written
)
629 // buffer to avoid dynamic memory allocation each time for small strings;
630 // note that this buffer is used only to hold results of number formatting,
631 // %s directly writes user's string in buf, without using szScratch
632 char szScratch
[wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
];
633 size_t lenScratch
= 0, lenCur
= 0;
635 #define APPEND_CH(ch) \
637 if ( lenCur == lenMax ) \
640 buf[lenCur++] = ch; \
646 lenScratch
= system_sprintf(szScratch
, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
, m_szFlags
, p
->pad_int
);
650 lenScratch
= system_sprintf(szScratch
, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
, m_szFlags
, p
->pad_longint
);
654 case wxPAT_LONGLONGINT
:
655 lenScratch
= system_sprintf(szScratch
, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
, m_szFlags
, p
->pad_longlongint
);
657 #endif // SIZEOF_LONG_LONG
660 lenScratch
= system_sprintf(szScratch
, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
, m_szFlags
, p
->pad_sizet
);
663 case wxPAT_LONGDOUBLE
:
664 lenScratch
= system_sprintf(szScratch
, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
, m_szFlags
, p
->pad_longdouble
);
668 lenScratch
= system_sprintf(szScratch
, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
, m_szFlags
, p
->pad_double
);
672 lenScratch
= system_sprintf(szScratch
, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
, m_szFlags
, p
->pad_pointer
);
679 if (m_type
== wxPAT_CHAR
)
681 else // m_type == wxPAT_WCHAR
689 for (i
= 1; i
< (size_t)m_nMinWidth
; i
++)
695 for (i
= 1; i
< (size_t)m_nMinWidth
; i
++)
706 if ( m_nMaxWidth
>= 6 )
709 else if (m_type
== wxPAT_PCHAR
)
710 s
.assign(static_cast<const char *>(p
->pad_str
));
711 else // m_type == wxPAT_PWCHAR
712 s
.assign(static_cast<const wchar_t *>(p
->pad_str
));
714 typename wxPrintfStringHelper
<CharType
>::ConvertedType
strbuf(
715 wxPrintfStringHelper
<CharType
>::Convert(s
));
717 // at this point we are sure that m_nMaxWidth is positive or
718 // null (see top of wxPrintfConvSpec::LoadArg)
719 int len
= wxMin((unsigned int)m_nMaxWidth
, wxStrlen(strbuf
));
725 for (i
= len
; i
< m_nMinWidth
; i
++)
729 len
= wxMin((unsigned int)len
, lenMax
-lenCur
);
730 wxStrncpy(buf
+lenCur
, strbuf
, len
);
735 for (i
= len
; i
< m_nMinWidth
; i
++)
742 *p
->pad_nint
= written
;
745 case wxPAT_NSHORTINT
:
746 *p
->pad_nshortint
= (short int)written
;
750 *p
->pad_nlongint
= written
;
758 // if we used system's sprintf() then we now need to append the s_szScratch
759 // buffer to the given one...
765 case wxPAT_LONGLONGINT
:
768 case wxPAT_LONGDOUBLE
:
771 wxASSERT(lenScratch
< wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN
);
772 // NB: 1) we can compare lenMax (for CharType*, i.e. possibly
773 // wchar_t*) with lenScratch (char*) because this code is
774 // formatting integers and that will have the same length
775 // even in UTF-8 (the only case when char* length may be
776 // more than wchar_t* length of the same string)
777 // 2) wxStrncpy converts the 2nd argument to 1st argument's
778 // type transparently if their types differ, so this code
779 // works for both instantiations
780 if (lenMax
< lenScratch
)
782 // fill output buffer and then return -1
783 wxStrncpy(buf
, szScratch
, lenMax
);
786 wxStrncpy(buf
, szScratch
, lenScratch
);
787 lenCur
+= lenScratch
;
791 break; // all other cases were completed previously
798 // helper that parses format string
799 template<typename CharType
>
800 struct wxPrintfConvSpecParser
802 typedef wxPrintfConvSpec
<CharType
> ConvSpec
;
804 wxPrintfConvSpecParser(const CharType
*fmt
)
808 nonposarg_present
= false;
810 memset(pspec
, 0, sizeof(pspec
));
812 // parse the format string
813 for ( const CharType
*toparse
= fmt
; *toparse
!= wxT('\0'); toparse
++ )
815 // skip everything except format specifications
816 if ( *toparse
!= '%' )
819 // also skip escaped percent signs
820 if ( toparse
[1] == '%' )
826 ConvSpec
*spec
= &specs
[nargs
];
829 // attempt to parse this format specification
830 if ( !spec
->Parse(toparse
) )
833 // advance to the end of this specifier
834 toparse
= spec
->m_pArgEnd
;
836 // special handling for specifications including asterisks: we need
837 // to reserve an extra slot (or two if asterisks were used for both
838 // width and precision) in specs array in this case
839 if ( const char *f
= strchr(spec
->m_szFlags
, '*') )
841 unsigned numAsterisks
= 1;
842 if ( strchr(++f
, '*') )
845 for ( unsigned n
= 0; n
< numAsterisks
; n
++ )
847 if ( nargs
++ == wxMAX_SVNPRINTF_ARGUMENTS
)
850 // TODO: we need to support specifiers of the form "%2$*1$s"
851 // (this is the same as "%*s") as if any positional arguments
852 // are used all asterisks must be positional as well but this
853 // requires a lot of changes in this code (basically we'd need
854 // to rewrite Parse() to return "*" and conversion itself as
856 if ( posarg_present
)
862 "Format string \"%s\" uses both positional "
863 "parameters and '*' but this is not currently "
864 "supported by this implementation, sorry.",
870 specs
[nargs
] = *spec
;
872 // make an entry for '*' and point to it from pspec
874 spec
->m_type
= wxPAT_STAR
;
875 pspec
[nargs
- 1] = spec
;
877 spec
= &specs
[nargs
];
882 // check if this is a positional or normal argument
883 if ( spec
->m_pos
> 0 )
885 // the positional arguments start from number 1 so we need
886 // to adjust the index
888 posarg_present
= true;
890 else // not a positional argument...
893 nonposarg_present
= true;
896 // this conversion specifier is tied to the pos-th argument...
897 pspec
[spec
->m_pos
] = spec
;
899 if ( nargs
++ == wxMAX_SVNPRINTF_ARGUMENTS
)
904 // warn if we lost any arguments (the program probably will crash
905 // anyhow because of stack corruption...)
906 if ( nargs
== wxMAX_SVNPRINTF_ARGUMENTS
)
912 "wxVsnprintf() currently supports only %d arguments, "
913 "but format string \"%s\" defines more of them.\n"
914 "You need to change wxMAX_SVNPRINTF_ARGUMENTS and "
915 "recompile if more are really needed.",
916 fmt
, wxMAX_SVNPRINTF_ARGUMENTS
922 // total number of valid elements in specs
925 // all format specifications in this format string in order of their
926 // appearance (which may be different from arguments order)
927 ConvSpec specs
[wxMAX_SVNPRINTF_ARGUMENTS
];
929 // pointer to specs array element for the N-th argument
930 ConvSpec
*pspec
[wxMAX_SVNPRINTF_ARGUMENTS
];
932 // true if any positional/non-positional parameters are used
940 #endif // _WX_PRIVATE_WXPRINTF_H_