X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/896e226aa260920835f70f4b2689d92cfc1615e8..80a779275ae04443c568dca919adb26cf6f5002c:/src/common/wxchar.cpp?ds=inline diff --git a/src/common/wxchar.cpp b/src/common/wxchar.cpp index 94b56cde9e..10bcd27cb4 100644 --- a/src/common/wxchar.cpp +++ b/src/common/wxchar.cpp @@ -1,18 +1,14 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: wxchar.cpp +// Name: src/common/wxchar.cpp // Purpose: wxChar implementation -// Author: Ove Kåven -// Modified by: Ron Lee +// Author: Ove Kaven +// Modified by: Ron Lee, Francesco Montorsi // Created: 09/04/99 // RCS-ID: $Id$ // Copyright: (c) wxWidgets copyright // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "wxchar.h" -#endif - // =========================================================================== // headers, declarations, constants // =========================================================================== @@ -21,9 +17,11 @@ #include "wx/wxprec.h" #ifdef __BORLANDC__ - #pragma hdrstop + #pragma hdrstop #endif +#include "wx/wxchar.h" + #define _ISOC9X_SOURCE 1 // to get vsscanf() #define _BSD_SOURCE 1 // to still get strdup() @@ -32,24 +30,24 @@ #include <string.h> #ifndef __WXWINCE__ -#include <time.h> -#include <locale.h> + #include <time.h> + #include <locale.h> #else -#include "wx/msw/wince/time.h" + #include "wx/msw/wince/time.h" #endif #ifndef WX_PRECOMP - #include "wx/defs.h" - #include "wx/wxchar.h" - #include "wx/string.h" - #include "wx/hash.h" + #include "wx/string.h" + #include "wx/hash.h" + #include "wx/utils.h" // for wxMin and wxMax + #include "wx/log.h" #endif #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H) #include <windef.h> - #include <winbase.h> - #include <winnls.h> - #include <winnt.h> + #include <winbase.h> + #include <winnls.h> + #include <winnt.h> #endif #if defined(__MWERKS__) && __MSL__ >= 0x6000 @@ -57,15 +55,11 @@ namespace std {} using namespace std ; #endif -#ifdef __WXMAC__ - #include "wx/mac/private.h" -#endif - #if wxUSE_WCHAR_T size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n) { // assume that we have mbsrtowcs() too if we have wcsrtombs() -#if HAVE_WCSRTOMBS +#ifdef HAVE_WCSRTOMBS mbstate_t mbstate; memset(&mbstate, 0, sizeof(mbstate_t)); #endif @@ -82,6 +76,12 @@ size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n) #endif } + // note that we rely on common (and required by Unix98 but unfortunately not + // C99) extension which allows to call mbs(r)towcs() with NULL output pointer + // to just get the size of the needed buffer -- this is needed as otherwise + // we have no idea about how much space we need and if the CRT doesn't + // support it (the only currently known example being Metrowerks, see + // wx/wxchar.h) we don't use its mbstowcs() at all #ifdef HAVE_WCSRTOMBS return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate); #else @@ -91,7 +91,7 @@ size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n) size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n) { -#if HAVE_WCSRTOMBS +#ifdef HAVE_WCSRTOMBS mbstate_t mbstate; memset(&mbstate, 0, sizeof(mbstate_t)); #endif @@ -102,14 +102,14 @@ size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n) if (n) *buf = '\0'; return 0; } -#if HAVE_WCSRTOMBS +#ifdef HAVE_WCSRTOMBS return wcsrtombs(buf, &pwz, n, &mbstate); #else return wxWcstombs(buf, pwz, n); #endif } -#if HAVE_WCSRTOMBS +#ifdef HAVE_WCSRTOMBS return wcsrtombs((char *) NULL, &pwz, 0, &mbstate); #else return wxWcstombs((char *) NULL, pwz, 0); @@ -161,42 +161,625 @@ bool WXDLLEXPORT wxOKlibc() // ---------------------------------------------------------------------------- // implement [v]snprintf() if the system doesn't provide a safe one +// or if the system's one does not support positional parameters +// (very useful for i18n purposes) // ---------------------------------------------------------------------------- #if !defined(wxVsnprintf_) -int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax, - const wxChar *format, va_list argptr) + +// wxUSE_STRUTILS says our wxVsnprintf_ implementation to use or not to +// use wxStrlen and wxStrncpy functions over one-char processing loops. +// +// Some benchmarking revealed that wxUSE_STRUTILS == 1 has the following +// effects: +// -> on Windows: +// when in ANSI mode, this setting does not change almost anything +// when in Unicode mode, it gives ~ 50% of slowdown ! +// -> on Linux: +// both in ANSI and Unicode mode it gives ~ 60% of speedup ! +// +#if defined(WIN32) && wxUSE_UNICODE +#define wxUSE_STRUTILS 0 +#else +#define wxUSE_STRUTILS 1 +#endif + +// some limits of our implementation +#define wxMAX_SVNPRINTF_ARGUMENTS 16 +#define wxMAX_SVNPRINTF_FLAGBUFFER_LEN 32 +#define wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN 512 + + +// wxVsnprintf() needs to use a *system* implementation of swnprintf() +// in order to perform some internal tasks. +// NB: we cannot just use wxSnprintf() because for some systems it maybe +// implemented later in this file using wxVsnprintf() and that would +// result in an endless recursion and thus in a stack overflow +#if wxUSE_UNICODE + #if defined(__WINDOWS__) && !defined(HAVE_SWPRINTF) + // all compilers under Windows should have swprintf() + #define HAVE_SWPRINTF + #endif + + // NB: MSVC 6 has only non-standard swprintf() declaration and while MSVC 7 + // and 7.1 do have the standard one, it's completely broken unless + // /Zc:wchar_t is used while the other one works so use it instead, and + // only VC8 has a working standard-compliant swprintf() + #if defined(__WXWINCE__) || \ + (defined(__VISUALC__) && __VISUALC__ < 1400) || \ + defined(__GNUWIN32__) || \ + defined(__BORLANDC__) + #ifndef HAVE_BROKEN_SWPRINTF_DECL + #define HAVE_BROKEN_SWPRINTF_DECL + #endif + #endif + + // problem: on some systems swprintf takes the 'max' argument while on + // others it doesn't + #if defined(HAVE_BROKEN_SWPRINTF_DECL) + // like when using sprintf(), since 'max' is not used, wxVsnprintf() + // should always ensure that 'buff' is big enough for all common needs + #define system_sprintf(buff, max, flags, data) \ + ::swprintf(buff, flags, data) + + #define SYSTEM_SPRINTF_IS_UNSAFE + #else + #if !defined(HAVE_SWPRINTF) + #error wxVsnprintf() needs a system swprintf() implementation! + #endif + + #define system_sprintf(buff, max, flags, data) \ + ::swprintf(buff, max, flags, data) + #endif +#else // !wxUSE_UNICODE + #if defined(__VISUALC__) || \ + (defined(__BORLANDC__) && __BORLANDC__ >= 0x540) + #define system_sprintf(buff, max, flags, data) \ + ::_snprintf(buff, max, flags, data) + #elif defined(HAVE_SNPRINTF) + #define system_sprintf(buff, max, flags, data) \ + ::snprintf(buff, max, flags, data) + #else // NB: at least sprintf() should always be available + // since 'max' is not used in this case, wxVsnprintf() should always + // ensure that 'buff' is big enough for all common needs + // (see wxMAX_SVNPRINTF_FLAGBUFFER_LEN and wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN) + #define system_sprintf(buff, max, flags, data) \ + ::sprintf(buff, flags, data) + + #define SYSTEM_SPRINTF_IS_UNSAFE + #endif +#endif // wxUSE_UNICODE/!wxUSE_UNICODE + + + +// the conversion specifiers accepted by wxVsnprintf_ +enum wxPrintfArgType { + wxPAT_INVALID = -1, + + wxPAT_INT, // %d, %i, %o, %u, %x, %X + wxPAT_LONGINT, // %ld, etc +#if SIZEOF_LONG_LONG + wxPAT_LONGLONGINT, // %Ld, etc +#endif + wxPAT_SIZET, // %Zd, etc + + wxPAT_DOUBLE, // %e, %E, %f, %g, %G + wxPAT_LONGDOUBLE, // %le, etc + + wxPAT_POINTER, // %p + + wxPAT_CHAR, // %hc (in ANSI mode: %c, too) + wxPAT_WCHAR, // %lc (in Unicode mode: %c, too) + + wxPAT_PCHAR, // %s (related to a char *) + wxPAT_PWCHAR, // %s (related to a wchar_t *) + + wxPAT_NINT, // %n + wxPAT_NSHORTINT, // %hn + wxPAT_NLONGINT // %ln +}; + +// an argument passed to wxVsnprintf_ +typedef union { + int pad_int; // %d, %i, %o, %u, %x, %X + long int pad_longint; // %ld, etc +#if SIZEOF_LONG_LONG + long long int pad_longlongint; // %Ld, etc +#endif + size_t pad_sizet; // %Zd, etc + + double pad_double; // %e, %E, %f, %g, %G + long double pad_longdouble; // %le, etc + + void *pad_pointer; // %p + + char pad_char; // %hc (in ANSI mode: %c, too) + wchar_t pad_wchar; // %lc (in Unicode mode: %c, too) + + char *pad_pchar; // %s (related to a char *) + wchar_t *pad_pwchar; // %s (related to a wchar_t *) + + int *pad_nint; // %n + short int *pad_nshortint; // %hn + long int *pad_nlongint; // %ln +} wxPrintfArg; + + +// Contains parsed data relative to a conversion specifier given to +// wxVsnprintf_ and parsed from the format string +// NOTE: in C++ there is almost no difference between struct & classes thus +// there is no performance gain by using a struct here... +class wxPrintfConvSpec { - // buffer to avoid dynamic memory allocation each time for small strings - char szScratch[1024]; +public: - // number of characters in the buffer so far, must be less than lenMax - size_t lenCur = 0; + // the position of the argument relative to this conversion specifier + size_t m_pos; + + // the type of this conversion specifier + wxPrintfArgType m_type; + + // the minimum and maximum width + // when one of this var is set to -1 it means: use the following argument + // in the stack as minimum/maximum width for this conversion specifier + int m_nMinWidth, m_nMaxWidth; - for ( size_t n = 0; ; n++ ) + // does the argument need to the be aligned to left ? + bool m_bAlignLeft; + + // pointer to the '%' of this conversion specifier in the format string + // NOTE: this points somewhere in the string given to the Parse() function - + // it's task of the caller ensure that memory is still valid ! + const wxChar *m_pArgPos; + + // pointer to the last character of this conversion specifier in the + // format string + // NOTE: this points somewhere in the string given to the Parse() function - + // it's task of the caller ensure that memory is still valid ! + const wxChar *m_pArgEnd; + + // a little buffer where formatting flags like #+\.hlqLZ are stored by Parse() + // for use in Process() + // NB: even if this buffer is used only for numeric conversion specifiers and + // thus could be safely declared as a char[] buffer, we want it to be wxChar + // so that in Unicode builds we can avoid to convert its contents to Unicode + // chars when copying it in user's buffer. + wxChar m_szFlags[wxMAX_SVNPRINTF_FLAGBUFFER_LEN]; + + +public: + + // we don't declare this as a constructor otherwise it would be called + // automatically and we don't want this: to be optimized, wxVsnprintf_ + // calls this function only on really-used instances of this class. + void Init(); + + // Parses the first conversion specifier in the given string, which must + // begin with a '%'. Returns false if the first '%' does not introduce a + // (valid) conversion specifier and thus should be ignored. + bool Parse(const wxChar *format); + + // Process this conversion specifier and puts the result in the given + // buffer. Returns the number of characters written in 'buf' or -1 if + // there's not enough space. + int Process(wxChar *buf, size_t lenMax, wxPrintfArg *p); + + // Loads the argument of this conversion specifier from given va_list. + bool LoadArg(wxPrintfArg *p, va_list &argptr); + +private: + // An helper function of LoadArg() which is used to handle the '*' flag + void ReplaceAsteriskWith(int w); +}; + +void wxPrintfConvSpec::Init() +{ + m_nMinWidth = 0; + m_nMaxWidth = 0xFFFF; + m_pos = 0; + m_bAlignLeft = false; + m_pArgPos = m_pArgEnd = NULL; + m_type = wxPAT_INVALID; + + // this character will never be removed from m_szFlags array and + // is important when calling sprintf() in wxPrintfConvSpec::Process() ! + m_szFlags[0] = wxT('%'); +} + +bool wxPrintfConvSpec::Parse(const wxChar *format) +{ + bool done = false; + + // temporary parse data + size_t flagofs = 1; + bool in_prec, prec_dot; + int ilen = 0; + + m_bAlignLeft = in_prec = prec_dot = false; + m_pArgPos = m_pArgEnd = format; + do { - const wxChar chCur = format[n]; +#define CHECK_PREC \ + if (in_prec && !prec_dot) \ + { \ + m_szFlags[flagofs++] = wxT('.'); \ + prec_dot = true; \ + } - if ( chCur == wxT('%') ) + // what follows '%'? + const wxChar ch = *(++m_pArgEnd); + switch ( ch ) { - static char s_szFlags[256] = "%"; - size_t flagofs = 1; - bool adj_left = false, - in_prec = false, - prec_dot = false, - done = false; - int ilen = 0; - size_t min_width = 0, - max_width = wxSTRING_MAXLEN; - do - { + case wxT('\0'): + return false; // not really an argument + + case wxT('%'): + return false; // not really an argument + + case wxT('#'): + case wxT('0'): + case wxT(' '): + case wxT('+'): + case wxT('\''): + CHECK_PREC + m_szFlags[flagofs++] = ch; + break; + + case wxT('-'): + CHECK_PREC + m_bAlignLeft = true; + m_szFlags[flagofs++] = ch; + break; + + case wxT('.'): + CHECK_PREC + in_prec = true; + prec_dot = false; + m_nMaxWidth = 0; + // dot will be auto-added to m_szFlags if non-negative + // number follows + break; + + case wxT('h'): + ilen = -1; + CHECK_PREC + m_szFlags[flagofs++] = ch; + break; + + case wxT('l'): + // NB: it's safe to use flagofs-1 as flagofs always start from 1 + if (m_szFlags[flagofs-1] == 'l') // 'll' modifier is the same as 'L' or 'q' + ilen = 2; + else + ilen = 1; + CHECK_PREC + m_szFlags[flagofs++] = ch; + break; + + case wxT('q'): + case wxT('L'): + ilen = 2; + CHECK_PREC + m_szFlags[flagofs++] = ch; + break; + + case wxT('Z'): + ilen = 3; + CHECK_PREC + m_szFlags[flagofs++] = ch; + break; + + case wxT('*'): + if (in_prec) + { + CHECK_PREC -#define CHECK_PREC \ - if (in_prec && !prec_dot) \ - { \ - s_szFlags[flagofs++] = '.'; \ - prec_dot = true; \ + // tell Process() to use the next argument + // in the stack as maxwidth... + m_nMaxWidth = -1; + } + else + { + // tell Process() to use the next argument + // in the stack as minwidth... + m_nMinWidth = -1; + } + + // save the * in our formatting buffer... + // will be replaced later by Process() + m_szFlags[flagofs++] = ch; + break; + + case wxT('1'): case wxT('2'): case wxT('3'): + case wxT('4'): case wxT('5'): case wxT('6'): + case wxT('7'): case wxT('8'): case wxT('9'): + { + int len = 0; + CHECK_PREC + while ( (*m_pArgEnd >= wxT('0')) && + (*m_pArgEnd <= wxT('9')) ) + { + m_szFlags[flagofs++] = (*m_pArgEnd); + len = len*10 + (*m_pArgEnd - wxT('0')); + m_pArgEnd++; + } + + if (in_prec) + m_nMaxWidth = len; + else + m_nMinWidth = len; + + m_pArgEnd--; // the main loop pre-increments n again + } + break; + + case wxT('$'): // a positional parameter (e.g. %2$s) ? + { + if (m_nMinWidth <= 0) + break; // ignore this formatting flag as no + // numbers are preceding it + + // remove from m_szFlags all digits previously added + do { + flagofs--; + } while (m_szFlags[flagofs] >= '1' && + m_szFlags[flagofs] <= '9'); + + // re-adjust the offset making it point to the + // next free char of m_szFlags + flagofs++; + + m_pos = m_nMinWidth; + m_nMinWidth = 0; + } + break; + + case wxT('d'): + case wxT('i'): + case wxT('o'): + case wxT('u'): + case wxT('x'): + case wxT('X'): + CHECK_PREC + m_szFlags[flagofs++] = ch; + m_szFlags[flagofs] = wxT('\0'); + if (ilen == 0) + m_type = wxPAT_INT; + else if (ilen == -1) + // NB: 'short int' value passed through '...' + // is promoted to 'int', so we have to get + // an int from stack even if we need a short + m_type = wxPAT_INT; + else if (ilen == 1) + m_type = wxPAT_LONGINT; + else if (ilen == 2) +#if SIZEOF_LONG_LONG + m_type = wxPAT_LONGLONGINT; +#else // !long long + m_type = wxPAT_LONGINT; +#endif // long long/!long long + else if (ilen == 3) + m_type = wxPAT_SIZET; + done = true; + break; + + case wxT('e'): + case wxT('E'): + case wxT('f'): + case wxT('g'): + case wxT('G'): + CHECK_PREC + m_szFlags[flagofs++] = ch; + m_szFlags[flagofs] = wxT('\0'); + if (ilen == 2) + m_type = wxPAT_LONGDOUBLE; + else + m_type = wxPAT_DOUBLE; + done = true; + break; + + case wxT('p'): + m_type = wxPAT_POINTER; + m_szFlags[flagofs++] = ch; + m_szFlags[flagofs] = '\0'; + done = true; + break; + + case wxT('c'): + if (ilen == -1) + { + // in Unicode mode %hc == ANSI character + // and in ANSI mode, %hc == %c == ANSI... + m_type = wxPAT_CHAR; + } + else if (ilen == 1) + { + // in ANSI mode %lc == Unicode character + // and in Unicode mode, %lc == %c == Unicode... + m_type = wxPAT_WCHAR; + } + else + { +#if wxUSE_UNICODE + // in Unicode mode, %c == Unicode character + m_type = wxPAT_WCHAR; +#else + // in ANSI mode, %c == ANSI character + m_type = wxPAT_CHAR; +#endif + } + done = true; + break; + + case wxT('s'): + if (ilen == -1) + { + // Unicode mode wx extension: we'll let %hs mean non-Unicode + // strings (when in ANSI mode, %s == %hs == ANSI string) + m_type = wxPAT_PCHAR; + } + else if (ilen == 1) + { + // in Unicode mode, %ls == %s == Unicode string + // in ANSI mode, %ls == Unicode string + m_type = wxPAT_PWCHAR; } + else + { +#if wxUSE_UNICODE + m_type = wxPAT_PWCHAR; +#else + m_type = wxPAT_PCHAR; +#endif + } + done = true; + break; + + case wxT('n'): + if (ilen == 0) + m_type = wxPAT_NINT; + else if (ilen == -1) + m_type = wxPAT_NSHORTINT; + else if (ilen >= 1) + m_type = wxPAT_NLONGINT; + done = true; + break; + + default: + // bad format, don't consider this an argument; + // leave it unchanged + return false; + } + + if (flagofs == wxMAX_SVNPRINTF_FLAGBUFFER_LEN) + { + wxLogDebug(wxT("Too many flags specified for a single conversion specifier!")); + return false; + } + } + while (!done); + + return true; // parsing was successful +} + + +void wxPrintfConvSpec::ReplaceAsteriskWith(int width) +{ + wxChar temp[wxMAX_SVNPRINTF_FLAGBUFFER_LEN]; + + // find the first * in our flag buffer + wxChar *pwidth = wxStrchr(m_szFlags, wxT('*')); + wxASSERT(pwidth); + + // save what follows the * (the +1 is to skip the asterisk itself!) + wxStrcpy(temp, pwidth+1); + if (width < 0) + { + pwidth[0] = wxT('-'); + pwidth++; + } + + // replace * with the actual integer given as width +#ifndef SYSTEM_SPRINTF_IS_UNSAFE + int maxlen = (m_szFlags + wxMAX_SVNPRINTF_FLAGBUFFER_LEN - pwidth) / + sizeof(wxChar); +#endif + int offset = system_sprintf(pwidth, maxlen, wxT("%d"), abs(width)); + + // restore after the expanded * what was following it + wxStrcpy(pwidth+offset, temp); +} + +bool wxPrintfConvSpec::LoadArg(wxPrintfArg *p, va_list &argptr) +{ + // did the '*' width/precision specifier was used ? + if (m_nMaxWidth == -1) + { + // take the maxwidth specifier from the stack + m_nMaxWidth = va_arg(argptr, int); + if (m_nMaxWidth < 0) + m_nMaxWidth = 0; + else + ReplaceAsteriskWith(m_nMaxWidth); + } + + if (m_nMinWidth == -1) + { + // take the minwidth specifier from the stack + m_nMinWidth = va_arg(argptr, int); + + ReplaceAsteriskWith(m_nMinWidth); + if (m_nMinWidth < 0) + { + m_bAlignLeft = !m_bAlignLeft; + m_nMinWidth = -m_nMinWidth; + } + } + + switch (m_type) { + case wxPAT_INT: + p->pad_int = va_arg(argptr, int); + break; + case wxPAT_LONGINT: + p->pad_longint = va_arg(argptr, long int); + break; +#if SIZEOF_LONG_LONG + case wxPAT_LONGLONGINT: + p->pad_longlongint = va_arg(argptr, long long int); + break; +#endif + case wxPAT_SIZET: + p->pad_sizet = va_arg(argptr, size_t); + break; + case wxPAT_DOUBLE: + p->pad_double = va_arg(argptr, double); + break; + case wxPAT_LONGDOUBLE: + p->pad_longdouble = va_arg(argptr, long double); + break; + case wxPAT_POINTER: + p->pad_pointer = va_arg(argptr, void *); + break; + + case wxPAT_CHAR: + p->pad_char = (char)va_arg(argptr, int); // char is promoted to int when passed through '...' + break; + case wxPAT_WCHAR: + p->pad_wchar = (wchar_t)va_arg(argptr, int); // char is promoted to int when passed through '...' + break; + + case wxPAT_PCHAR: + p->pad_pchar = va_arg(argptr, char *); + break; + case wxPAT_PWCHAR: + p->pad_pwchar = va_arg(argptr, wchar_t *); + break; + + case wxPAT_NINT: + p->pad_nint = va_arg(argptr, int *); + break; + case wxPAT_NSHORTINT: + p->pad_nshortint = va_arg(argptr, short int *); + break; + case wxPAT_NLONGINT: + p->pad_nlongint = va_arg(argptr, long int *); + break; + + case wxPAT_INVALID: + default: + return false; + } + + return true; // loading was successful +} + +int wxPrintfConvSpec::Process(wxChar *buf, size_t lenMax, wxPrintfArg *p) +{ + // buffer to avoid dynamic memory allocation each time for small strings; + // note that this buffer is used only to hold results of number formatting, + // %s directly writes user's string in buf, without using szScratch + wxChar szScratch[wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN]; + size_t lenScratch = 0, lenCur = 0; #define APPEND_CH(ch) \ { \ @@ -214,353 +797,391 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax, } \ } - // what follows '%'? - const wxChar ch = format[++n]; - switch ( ch ) + switch ( m_type ) + { + case wxPAT_INT: + lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_int); + break; + + case wxPAT_LONGINT: + lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longint); + break; + +#if SIZEOF_LONG_LONG + case wxPAT_LONGLONGINT: + lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longlongint); + break; +#endif // SIZEOF_LONG_LONG + + case wxPAT_SIZET: + lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_sizet); + break; + + case wxPAT_LONGDOUBLE: + lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longdouble); + break; + + case wxPAT_DOUBLE: + lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_double); + break; + + case wxPAT_POINTER: + lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_pointer); + break; + + case wxPAT_CHAR: + case wxPAT_WCHAR: + { + wxChar val = +#if wxUSE_UNICODE + p->pad_wchar; + + if (m_type == wxPAT_CHAR) { - case wxT('\0'): - APPEND_CH(_T('\0')); + // user passed a character explicitely indicated as ANSI... + const char buf[2] = { p->pad_char, 0 }; + val = wxString(buf, wxConvLibc)[0u]; - done = true; - break; + //wprintf(L"converting ANSI=>Unicode"); // for debug + } +#else + p->pad_char; - case wxT('%'): - APPEND_CH(_T('%')); - done = true; - break; +#if wxUSE_WCHAR_T + if (m_type == wxPAT_WCHAR) + { + // user passed a character explicitely indicated as Unicode... + const wchar_t buf[2] = { p->pad_wchar, 0 }; + val = wxString(buf, wxConvLibc)[0u]; - case wxT('#'): - case wxT('0'): - case wxT(' '): - case wxT('+'): - case wxT('\''): - CHECK_PREC - s_szFlags[flagofs++] = ch; - break; + //printf("converting Unicode=>ANSI"); // for debug + } +#endif +#endif - case wxT('-'): - CHECK_PREC - adj_left = true; - s_szFlags[flagofs++] = ch; - break; + size_t i; - case wxT('.'): - CHECK_PREC - in_prec = true; - prec_dot = false; - max_width = 0; - // dot will be auto-added to s_szFlags if non-negative - // number follows - break; + if (!m_bAlignLeft) + for (i = 1; i < (size_t)m_nMinWidth; i++) + APPEND_CH(_T(' ')); - case wxT('h'): - ilen = -1; - CHECK_PREC - s_szFlags[flagofs++] = ch; - break; + APPEND_CH(val); - case wxT('l'): - ilen = 1; - CHECK_PREC - s_szFlags[flagofs++] = ch; - break; + if (m_bAlignLeft) + for (i = 1; i < (size_t)m_nMinWidth; i++) + APPEND_CH(_T(' ')); + } + break; - case wxT('q'): - case wxT('L'): - ilen = 2; - CHECK_PREC - s_szFlags[flagofs++] = ch; - break; + case wxPAT_PCHAR: + case wxPAT_PWCHAR: + { + wxString s; + const wxChar *val = +#if wxUSE_UNICODE + p->pad_pwchar; - case wxT('Z'): - ilen = 3; - CHECK_PREC - s_szFlags[flagofs++] = ch; - break; + if (m_type == wxPAT_PCHAR) + { + // user passed a string explicitely indicated as ANSI... + val = s = wxString(p->pad_pchar, wxConvLibc); - case wxT('*'): - { - int len = va_arg(argptr, int); - if (in_prec) - { - if (len<0) break; - CHECK_PREC - max_width = len; - } - else - { - if (len<0) - { - adj_left = !adj_left; - s_szFlags[flagofs++] = '-'; - len = -len; - } - min_width = len; - } - flagofs += ::sprintf(s_szFlags+flagofs,"%d",len); - } - break; + //wprintf(L"converting ANSI=>Unicode"); // for debug + } +#else + p->pad_pchar; - case wxT('1'): case wxT('2'): case wxT('3'): - case wxT('4'): case wxT('5'): case wxT('6'): - case wxT('7'): case wxT('8'): case wxT('9'): - { - int len = 0; - CHECK_PREC - while ( (format[n] >= wxT('0')) && - (format[n] <= wxT('9')) ) - { - s_szFlags[flagofs++] = format[n]; - len = len*10 + (format[n] - wxT('0')); - n++; - } - - if (in_prec) - max_width = len; - else - min_width = len; - - n--; // the main loop pre-increments n again - } - break; +#if wxUSE_WCHAR_T + if (m_type == wxPAT_PWCHAR) + { + // user passed a string explicitely indicated as Unicode... + val = s = wxString(p->pad_pwchar, wxConvLibc); - case wxT('d'): - case wxT('i'): - case wxT('o'): - case wxT('u'): - case wxT('x'): - case wxT('X'): - CHECK_PREC - s_szFlags[flagofs++] = ch; - s_szFlags[flagofs] = '\0'; - if (ilen == 0 ) - { - int val = va_arg(argptr, int); - ::sprintf(szScratch, s_szFlags, val); - } - else if (ilen == -1) - { - // NB: 'short int' value passed through '...' - // is promoted to 'int', so we have to get - // an int from stack even if we need a short - short int val = (short int) va_arg(argptr, int); - ::sprintf(szScratch, s_szFlags, val); - } - else if (ilen == 1) - { - long int val = va_arg(argptr, long int); - ::sprintf(szScratch, s_szFlags, val); - } - else if (ilen == 2) - { -#if SIZEOF_LONG_LONG - long long int val = va_arg(argptr, long long int); - ::sprintf(szScratch, s_szFlags, val); -#else // !long long - long int val = va_arg(argptr, long int); - ::sprintf(szScratch, s_szFlags, val); -#endif // long long/!long long - } - else if (ilen == 3) - { - size_t val = va_arg(argptr, size_t); - ::sprintf(szScratch, s_szFlags, val); - } - - { - const wxMB2WXbuf tmp = - wxConvLibc.cMB2WX(szScratch); - APPEND_STR(tmp); - } - - done = true; - break; + //printf("converting Unicode=>ANSI"); // for debug + } +#endif +#endif + int len; - case wxT('e'): - case wxT('E'): - case wxT('f'): - case wxT('g'): - case wxT('G'): - CHECK_PREC - s_szFlags[flagofs++] = ch; - s_szFlags[flagofs] = '\0'; - if (ilen == 2) - { - long double val = va_arg(argptr, long double); - ::sprintf(szScratch, s_szFlags, val); - } - else - { - double val = va_arg(argptr, double); - ::sprintf(szScratch, s_szFlags, val); - } - - { - const wxMB2WXbuf tmp = - wxConvLibc.cMB2WX(szScratch); - APPEND_STR(tmp); - } - - done = true; - break; + if (val) + { +#if wxUSE_STRUTILS + // at this point we are sure that m_nMaxWidth is positive or null + // (see top of wxPrintfConvSpec::LoadArg) + len = wxMin((unsigned int)m_nMaxWidth, wxStrlen(val)); +#else + for ( len = 0; val[len] && (len < m_nMaxWidth); len++ ) + ; +#endif + } + else if (m_nMaxWidth >= 6) + { + val = wxT("(null)"); + len = 6; + } + else + { + val = wxEmptyString; + len = 0; + } - case wxT('p'): - { - void *val = va_arg(argptr, void *); - CHECK_PREC - s_szFlags[flagofs++] = ch; - s_szFlags[flagofs] = '\0'; - ::sprintf(szScratch, s_szFlags, val); + int i; - const wxMB2WXbuf tmp = - wxConvLibc.cMB2WX(szScratch); - APPEND_STR(tmp); + if (!m_bAlignLeft) + { + for (i = len; i < m_nMinWidth; i++) + APPEND_CH(_T(' ')); + } - done = true; - } - break; +#if wxUSE_STRUTILS + len = wxMin((unsigned int)len, lenMax-lenCur); + wxStrncpy(buf+lenCur, val, len); + lenCur += len; +#else + for (i = 0; i < len; i++) + APPEND_CH(val[i]); +#endif - case wxT('c'): - { - int val = va_arg(argptr, int); -#if wxUSE_UNICODE - if (ilen == -1) - { - const char buf[2] = { val, 0 }; - val = wxString(buf, wxConvLibc)[0u]; - } -#elif wxUSE_WCHAR_T - if (ilen == 1) - { - const wchar_t buf[2] = { val, 0 }; - val = wxString(buf, wxConvLibc)[0u]; - } + if (m_bAlignLeft) + { + for (i = len; i < m_nMinWidth; i++) + APPEND_CH(_T(' ')); + } + } + break; + + case wxPAT_NINT: + *p->pad_nint = lenCur; + break; + + case wxPAT_NSHORTINT: + *p->pad_nshortint = (short int)lenCur; + break; + + case wxPAT_NLONGINT: + *p->pad_nlongint = lenCur; + break; + + case wxPAT_INVALID: + default: + return -1; + } + +#ifdef HAVE_BROKEN_SWPRINTF_DECL + wxUnusedVar(lenScratch); // avoid dummy warnings #endif - size_t i; - if (!adj_left) - for (i = 1; i < min_width; i++) - APPEND_CH(_T(' ')); + // if we used system's sprintf() then we now need to append the s_szScratch + // buffer to the given one... + switch (m_type) + { + case wxPAT_INT: + case wxPAT_LONGINT: +#if SIZEOF_LONG_LONG + case wxPAT_LONGLONGINT: +#endif + case wxPAT_SIZET: + case wxPAT_LONGDOUBLE: + case wxPAT_DOUBLE: + case wxPAT_POINTER: +#if wxUSE_STRUTILS + { + wxASSERT( /* lenScratch >= 0 && */ lenScratch < wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN); + if (lenMax < lenScratch) + { + // fill output buffer and then return -1 + wxStrncpy(buf, szScratch, lenMax); + return -1; + } + wxStrncpy(buf, szScratch, lenScratch); + lenCur += lenScratch; + } +#else + { + APPEND_STR(szScratch); + } +#endif + break; - APPEND_CH(val); + default: + break; // all other cases were completed previously + } + + return lenCur; +} - if (adj_left) - for (i = 1; i < min_width; i++) - APPEND_CH(_T(' ')); +// differences from standard strncpy: +// 1) copies everything from 'source' except for '%%' sequence which is copied as '%' +// 2) returns the number of written characters in 'dest' as it could differ from given 'n' +// 3) much less optimized, unfortunately... +static int wxCopyStrWithPercents(wxChar *dest, const wxChar *source, size_t n) +{ + size_t written = 0; - done = true; - } - break; + if (n == 0) + return 0; - case wxT('s'): - { - const wxChar *val = NULL; -#if wxUSE_UNICODE - wxString s; - - if (ilen == -1) - { - // wx extension: we'll let %hs mean non-Unicode - // strings - char *v = va_arg(argptr, char *); - - if (v) - val = s = wxString(v, wxConvLibc); - } - else -#elif wxUSE_WCHAR_T - wxString s; - - if (ilen == 1) - { - // %ls means Unicode strings - wchar_t *v = va_arg(argptr, wchar_t *); - - if (v) - val = s = wxString(v, wxConvLibc); - } - else + size_t i; + for ( i = 0; i < n-1; source++, i++) + { + dest[written++] = *source; + if (*(source+1) == wxT('%')) + { + // skip this additional '%' character + source++; + i++; + } + } + + if (i < n) + // copy last character inconditionally + dest[written++] = *source; + + return written; +} + +int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax, + const wxChar *format, va_list argptr) +{ + // useful for debugging, to understand if we are really using this function + // rather than the system implementation +#if 0 + wprintf(L"Using wxVsnprintf_\n"); #endif - { - val = va_arg(argptr, wxChar *); - } - - size_t len = 0; - - if (val) - { - for ( len = 0; - val[len] && (len < max_width); - len++ ) - ; - } - else if (max_width >= 6) - { - val = wxT("(null)"); - len = 6; - } - else - { - val = wxEmptyString; - len = 0; - } - - size_t i; - - if (!adj_left) - for (i = len; i < min_width; i++) - APPEND_CH(_T(' ')); - - for (i = 0; i < len; i++) - APPEND_CH(val[i]); - - if (adj_left) - for (i = len; i < min_width; i++) - APPEND_CH(_T(' ')); - - done = true; - } - break; - case wxT('n'): - if (ilen == 0) - { - int *val = va_arg(argptr, int *); - *val = lenCur; - } - else if (ilen == -1) - { - short int *val = va_arg(argptr, short int *); - *val = lenCur; - } - else if (ilen >= 1) - { - long int *val = va_arg(argptr, long int *); - *val = lenCur; - } - done = true; - break; + // required memory: + wxPrintfConvSpec arg[wxMAX_SVNPRINTF_ARGUMENTS]; + wxPrintfArg argdata[wxMAX_SVNPRINTF_ARGUMENTS]; + wxPrintfConvSpec *pspec[wxMAX_SVNPRINTF_ARGUMENTS] = { NULL }; - default: - // bad format, leave unchanged - APPEND_CH(_T('%')); - APPEND_CH(ch); - done = true; - break; + size_t i; + + // number of characters in the buffer so far, must be less than lenMax + size_t lenCur = 0; + + size_t nargs = 0; + const wxChar *toparse = format; + + // parse the format string + bool posarg_present = false, nonposarg_present = false; + for (; *toparse != wxT('\0'); toparse++) + { + if (*toparse == wxT('%') ) + { + arg[nargs].Init(); + + // let's see if this is a (valid) conversion specifier... + if (arg[nargs].Parse(toparse)) + { + // ...yes it is + wxPrintfConvSpec *current = &arg[nargs]; + + // make toparse point to the end of this specifier + toparse = current->m_pArgEnd; + + if (current->m_pos > 0) + { + // the positionals start from number 1... adjust the index + current->m_pos--; + posarg_present = true; + } + else + { + // not a positional argument... + current->m_pos = nargs; + nonposarg_present = true; + } + + // this conversion specifier is tied to the pos-th argument... + pspec[current->m_pos] = current; + nargs++; + + if (nargs == wxMAX_SVNPRINTF_ARGUMENTS) + { + wxLogDebug(wxT("A single call to wxVsnprintf() has more than %d arguments; ") + wxT("ignoring all remaining arguments."), wxMAX_SVNPRINTF_ARGUMENTS); + break; // cannot handle any additional conv spec } } - while (!done); + else + { + // it's safe to look in the next character of toparse as at worst + // we'll hit its \0 + if (*(toparse+1) == wxT('%')) + toparse++; // the Parse() returned false because we've found a %% + } } - else + } + + if (posarg_present && nonposarg_present) + return -1; // format strings with both positional and + // non-positional conversion specifier are unsupported !! + + // on platforms where va_list is an array type, it is necessary to make a + // copy to be able to pass it to LoadArg as a reference. + bool ok = true; + va_list ap; + wxVaCopy(ap, argptr); + + // now load arguments from stack + for (i=0; i < nargs && ok; i++) + { + // !pspec[i] means that the user forgot a positional parameter (e.g. %$1s %$3s); + // LoadArg == false means that wxPrintfConvSpec::Parse failed to set the + // conversion specifier 'type' to a valid value... + ok = pspec[i] && pspec[i]->LoadArg(&argdata[i], ap); + } + + va_end(ap); + + // something failed while loading arguments from the variable list... + if (!ok) + return -1; + + // finally, process each conversion specifier with its own argument + toparse = format; + for (i=0; i < nargs; i++) + { + // copy in the output buffer the portion of the format string between + // last specifier and the current one + size_t tocopy = ( arg[i].m_pArgPos - toparse ); + if (lenCur+tocopy >= lenMax) { - APPEND_CH(chCur); + // not enough space in the output buffer ! + // copy until the end of remaining space and then stop + wxCopyStrWithPercents(buf+lenCur, toparse, lenMax - lenCur - 1); + buf[lenMax-1] = wxT('\0'); + return -1; } - // terminating NUL? - if ( !chCur ) - break; + lenCur += wxCopyStrWithPercents(buf+lenCur, toparse, tocopy); + + // process this specifier directly in the output buffer + int n = arg[i].Process(buf+lenCur, lenMax - lenCur, &argdata[arg[i].m_pos]); + if (n == -1) + { + buf[lenMax-1] = wxT('\0'); // be sure to always NUL-terminate the string + return -1; // not enough space in the output buffer ! + } + lenCur += n; + + // the +1 is because wxPrintfConvSpec::m_pArgEnd points to the last character + // of the format specifier, but we are not interested to it... + toparse = arg[i].m_pArgEnd + 1; } + // copy portion of the format string after last specifier + // NOTE: toparse is pointing to the character just after the last processed + // conversion specifier + // NOTE2: the +1 is because we want to copy also the '\0' + size_t tocopy = wxStrlen(format) + 1 - ( toparse - format ) ; + if (lenCur+tocopy >= lenMax) + return -1; // not enough space in the output buffer ! + + // the -1 is because of the '\0' + lenCur += wxCopyStrWithPercents(buf+lenCur, toparse, tocopy) - 1; + + wxASSERT(lenCur == wxStrlen(buf)); return lenCur; } @@ -978,6 +1599,10 @@ int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) int ret = vswprintf( str, size, wxFormatConverter(format), argptr ); + // VsnprintfTestCase reveals that glibc's implementation of vswprintf + // doesn't nul terminate on truncation. + str[size - 1] = 0; + va_end(argptr); return ret; @@ -1070,7 +1695,7 @@ WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); } WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); } #endif -#if defined(__DARWIN__) && ( MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2 ) +#ifdef wxNEED_WX_MBSTOWCS WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen) { @@ -1094,7 +1719,7 @@ WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen) return in - origin; } -WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen) +WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen) { if (!out) { @@ -1116,6 +1741,8 @@ WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen) return in - origin; } +#endif // wxNEED_WX_MBSTOWCS + #if defined(wxNEED_WX_CTYPE_H) #include <CoreFoundation/CoreFoundation.h> @@ -1147,8 +1774,6 @@ WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)toupper((char)(ch)); } #endif // wxNEED_WX_CTYPE_H -#endif // defined(__DARWIN__) and OSX <= 10.2 - #ifndef wxStrdupA WXDLLEXPORT char *wxStrdupA(const char *s) @@ -1451,8 +2076,8 @@ double WXDLLEXPORT wxAtof(const wxChar *psz) wxString str(psz); if (str.ToDouble(& d)) return d; - else - return 0.0; + + return 0.0; #else return atof(wxConvLibc.cWX2MB(psz)); #endif