X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/d4ea46dbad078ea99924c056796e032fa9a36e7a..0973b7df99407013717cc0cbe7fca4b3700cfafd:/src/common/wxchar.cpp diff --git a/src/common/wxchar.cpp b/src/common/wxchar.cpp index 7f532e5b36..089d645b82 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: +// Author: Ove Kaven +// Modified by: Ron Lee, Francesco Montorsi // Created: 09/04/99 // RCS-ID: $Id$ -// Copyright: (c) wxWindows copyright -// Licence: wxWindows license +// Copyright: (c) wxWidgets copyright +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ - #pragma implementation "wxchar.h" -#endif - // =========================================================================== // headers, declarations, constants // =========================================================================== @@ -21,7 +17,7 @@ #include "wx/wxprec.h" #ifdef __BORLANDC__ - #pragma hdrstop + #pragma hdrstop #endif #define _ISOC9X_SOURCE 1 // to get vsscanf() @@ -30,66 +26,98 @@ #include #include #include -#include -#include + +#ifndef __WXWINCE__ + #include + #include +#else + #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/wxchar.h" + #include "wx/string.h" + #include "wx/hash.h" #endif + #include "wx/utils.h" // for wxMin and wxMax #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H) #include - #include - #include - #include + #include + #include + #include +#endif + +#if defined(__MWERKS__) && __MSL__ >= 0x6000 +namespace std {} +using namespace std ; #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() +#ifdef HAVE_WCSRTOMBS + mbstate_t mbstate; + memset(&mbstate, 0, sizeof(mbstate_t)); +#endif + if (buf) { if (!n || !*psz) { if (n) *buf = wxT('\0'); return 0; } - return mbstowcs(buf, psz, n); +#ifdef HAVE_WCSRTOMBS + return mbsrtowcs(buf, &psz, n, &mbstate); +#else + return wxMbstowcs(buf, psz, n); +#endif } - // assume that we have mbsrtowcs() too if we have wcsrtombs() + // 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 - mbstate_t mbstate; return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate); -#else // !GNU libc - return mbstowcs((wchar_t *) NULL, psz, 0); -#endif // GNU +#else + return wxMbstowcs((wchar_t *) NULL, psz, 0); +#endif } size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n) { +#ifdef HAVE_WCSRTOMBS + mbstate_t mbstate; + memset(&mbstate, 0, sizeof(mbstate_t)); +#endif + if (buf) { if (!n || !*pwz) { // glibc2.1 chokes on null input if (n) *buf = '\0'; return 0; } - return wcstombs(buf, pwz, n); +#ifdef HAVE_WCSRTOMBS + return wcsrtombs(buf, &pwz, n, &mbstate); +#else + return wxWcstombs(buf, pwz, n); +#endif } -#if HAVE_WCSRTOMBS - mbstate_t mbstate; +#ifdef HAVE_WCSRTOMBS return wcsrtombs((char *) NULL, &pwz, 0, &mbstate); -#else // !GNU libc - return wcstombs((char *) NULL, pwz, 0); -#endif // GNU +#else + return wxWcstombs((char *) NULL, pwz, 0); +#endif } #endif // wxUSE_WCHAR_T bool WXDLLEXPORT wxOKlibc() { -#if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) +#if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__) // glibc 2.0 uses UTF-8 even when it shouldn't wchar_t res = 0; if ((MB_CUR_MAX == 2) && @@ -101,329 +129,930 @@ bool WXDLLEXPORT wxOKlibc() (strcasecmp(cur_locale + strlen(cur_locale) - 4, "utf8")) || (strcasecmp(cur_locale + strlen(cur_locale) - 5, "utf-8"))) { // nope, don't use libc conversion - return FALSE; + return false; } } #endif - return TRUE; + return true; } -#ifndef HAVE_WCSLEN -size_t WXDLLEXPORT wcslen(const wchar_t *s) -{ - size_t len = 0; - while (s[len]) len++; - return len; -} -#endif - // ============================================================================ // printf() functions business // ============================================================================ +// special test mode: define all functions below even if we don't really need +// them to be able to test them +#ifdef wxTEST_PRINTF + #undef wxFprintf + #undef wxPrintf + #undef wxSprintf + #undef wxVfprintf + #undef wxVsprintf + #undef wxVprintf + #undef wxVsnprintf_ + #undef wxSnprintf_ + + #define wxNEED_WPRINTF + + int wxVfprintf( FILE *stream, const wxChar *format, va_list argptr ); +#endif + // ---------------------------------------------------------------------------- // 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 64 +#define wxMAX_SVNPRINTF_FLAGBUFFER_LEN 32 + +// 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 pos; - for (size_t n = 0; format[n]; n++) - { - if (format[n] == wxT('%')) { - 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 { + // the type of this conversion specifier + wxPrintfArgType 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 min_width, max_width; + + // does the argument need to the be aligned to left ? + bool adj_left; + + // 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 *argpos; + + // 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 *argend; + + // a little buffer where formatting flags like #+\.hlqLZ are stored by Parse() + // for use in Process() + // NB: this buffer can be safely a char buffer instead of a wchar_t buffer + // since it's used only for numeric conversion specifier and always + // with sprintf(). + char 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() +{ + min_width = 0; + max_width = 0xFFFF; + pos = 0; + adj_left = false; + argpos = argend = NULL; + type = wxPAT_INVALID; + + // this character will never be removed from szFlags array and + // is important when calling sprintf() in wxPrintfConvSpec::Process() ! + szFlags[0] = '%'; +} + +bool wxPrintfConvSpec::Parse(const wxChar *format) +{ + bool done = false; + + // temporary parse data + size_t flagofs = 1; + bool in_prec, prec_dot; + int ilen = 0; + + adj_left = in_prec = prec_dot = false; + argpos = argend = format; + do + { #define CHECK_PREC \ - if (in_prec && !prec_dot) \ - { \ - s_szFlags[flagofs++] = '.'; \ - prec_dot = TRUE; \ + if (in_prec && !prec_dot) \ + { \ + szFlags[flagofs++] = (char)'.'; \ + prec_dot = true; \ + } + + // what follows '%'? + const wxChar ch = *(++argend); + switch ( ch ) + { + 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 + szFlags[flagofs++] = (char)ch; + break; + + case wxT('-'): + CHECK_PREC + adj_left = true; + szFlags[flagofs++] = (char)ch; + break; + + case wxT('.'): + CHECK_PREC + in_prec = true; + prec_dot = false; + max_width = 0; + // dot will be auto-added to szFlags if non-negative + // number follows + break; + + case wxT('h'): + ilen = -1; + CHECK_PREC + szFlags[flagofs++] = (char)ch; + break; + + case wxT('l'): + ilen = 1; + CHECK_PREC + szFlags[flagofs++] = (char)ch; + break; + + case wxT('q'): + case wxT('L'): + ilen = 2; + CHECK_PREC + szFlags[flagofs++] = (char)ch; + break; + + case wxT('Z'): + ilen = 3; + CHECK_PREC + szFlags[flagofs++] = (char)ch; + break; + + case wxT('*'): + if (in_prec) + { + CHECK_PREC + + // tell Process() to use the next argument + // in the stack as maxwidth... + max_width = -1; + } + else + { + // tell Process() to use the next argument + // in the stack as minwidth... + min_width = -1; } -#define APPEND_CH(ch) \ - if ( lenCur == lenMax ) \ - return -1; \ - \ - buf[lenCur++] = ch + // save the * in our formatting buffer... + // will be replaced later by Process() + szFlags[flagofs++] = (char)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 ( (*argend >= wxT('0')) && + (*argend <= wxT('9')) ) + { + szFlags[flagofs++] = (char)(*argend); + len = len*10 + (*argend - wxT('0')); + argend++; + } -#define APPEND_STR(s) \ - for ( const char *p = s; *p; p++ ) \ + if (in_prec) + max_width = len; + else + min_width = len; + + argend--; // the main loop pre-increments n again + } + break; + + case wxT('$'): // a positional parameter (e.g. %2$s) ? + { + if (min_width <= 0) + break; // ignore this formatting flag as no + // numbers are preceding it + + // remove from szFlags all digits previously added + do { + flagofs--; + } while (szFlags[flagofs] >= '1' && + szFlags[flagofs] <= '9'); + + // re-adjust the offset making it point to the + // next free char of szFlags + flagofs++; + + pos = min_width; + min_width = 0; + } + break; + + case wxT('d'): + case wxT('i'): + case wxT('o'): + case wxT('u'): + case wxT('x'): + case wxT('X'): + CHECK_PREC + szFlags[flagofs++] = (char)ch; + szFlags[flagofs] = (char)'\0'; + if (ilen == 0) + 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 + type = wxPAT_INT; + else if (ilen == 1) + type = wxPAT_LONGINT; + else if (ilen == 2) +#if SIZEOF_LONG_LONG + type = wxPAT_LONGLONGINT; +#else // !long long + type = wxPAT_LONGINT; +#endif // long long/!long long + else if (ilen == 3) + type = wxPAT_SIZET; + done = true; + break; + + case wxT('e'): + case wxT('E'): + case wxT('f'): + case wxT('g'): + case wxT('G'): + CHECK_PREC + szFlags[flagofs++] = (char)ch; + szFlags[flagofs] = (char)'\0'; + if (ilen == 2) + type = wxPAT_LONGDOUBLE; + else + type = wxPAT_DOUBLE; + done = true; + break; + + case wxT('p'): + type = wxPAT_POINTER; + done = true; + break; + + case wxT('c'): + if (ilen == -1) + { + // in Unicode mode %hc == ANSI character + // and in ANSI mode, %hc == %c == ANSI... + type = wxPAT_CHAR; + } + else if (ilen == 1) + { + // in ANSI mode %lc == Unicode character + // and in Unicode mode, %lc == %c == Unicode... + type = wxPAT_WCHAR; + } + else + { +#if wxUSE_UNICODE + // in Unicode mode, %c == Unicode character + type = wxPAT_WCHAR; +#else + // in ANSI mode, %c == ANSI character + 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) + type = wxPAT_PCHAR; + } + else if (ilen == 1) + { + // in Unicode mode, %ls == %s == Unicode string + // in ANSI mode, %ls == Unicode string + type = wxPAT_PWCHAR; + } + else + { +#if wxUSE_UNICODE + type = wxPAT_PWCHAR; +#else + type = wxPAT_PCHAR; +#endif + } + done = true; + break; + + case wxT('n'): + if (ilen == 0) + type = wxPAT_NINT; + else if (ilen == -1) + type = wxPAT_NSHORTINT; + else if (ilen >= 1) + type = wxPAT_NLONGINT; + done = true; + break; + + default: + // bad format, don't consider this an argument; + // leave it unchanged + return false; + } + } + while (!done); + + return true; // parsing was successful +} + + +void wxPrintfConvSpec::ReplaceAsteriskWith(int w) +{ + char temp[wxMAX_SVNPRINTF_FLAGBUFFER_LEN]; + + // find the first * in our flag buffer + char *pwidth = strchr(szFlags, '*'); + wxASSERT(pwidth); + + // save what follows the * (the +1 is to skip it!) + strcpy(temp, pwidth+1); + if (w < 0) { + pwidth[0] = '-'; + pwidth++; + } + + // replace * with the actual integer given as width + int offset = ::sprintf(pwidth,"%d",abs(w)); + + // restore after the expanded * what was following it + strcpy(pwidth+offset, temp); +} + +bool wxPrintfConvSpec::LoadArg(wxPrintfArg *p, va_list &argptr) +{ + // did the '*' width/precision specifier was used ? + if (max_width == -1) + { + // take the maxwidth specifier from the stack + max_width = va_arg(argptr, int); + if (max_width < 0) + max_width = 0; + else + ReplaceAsteriskWith(max_width); + } + + if (min_width == -1) + { + // take the minwidth specifier from the stack + min_width = va_arg(argptr, int); + + ReplaceAsteriskWith(min_width); + if (min_width < 0) + { + adj_left = !adj_left; + min_width = -min_width; + } + } + + switch (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 + static char szScratch[1024]; + size_t lenCur = 0; + +#define APPEND_CH(ch) \ { \ - APPEND_CH((wchar_t)(*p)); \ + if ( lenCur == lenMax ) \ + return -1; \ + \ + buf[lenCur++] = ch; \ } -#define APPEND_WSTR(s) \ - for ( const wchar_t *p = s; *p; p++ ) \ +#define APPEND_STR(s) \ { \ - APPEND_CH(*p); \ + for ( const wxChar *p = s; *p; p++ ) \ + { \ + APPEND_CH(*p); \ + } \ } - switch (format[++n]) { - case wxT('\0'): - APPEND_CH(_T('\0')); + switch ( type ) + { + case wxPAT_INT: + ::sprintf(szScratch, szFlags, p->pad_int); + break; - done = TRUE; - break; + case wxPAT_LONGINT: + ::sprintf(szScratch, szFlags, p->pad_longint); + break; - case wxT('%'): - APPEND_CH(_T('%')); - done = TRUE; - break; +#if SIZEOF_LONG_LONG + case wxPAT_LONGLONGINT: + ::sprintf(szScratch, szFlags, p->pad_longlongint); + break; +#endif // SIZEOF_LONG_LONG - case wxT('#'): - case wxT('0'): - case wxT(' '): - case wxT('+'): - case wxT('\''): - CHECK_PREC - s_szFlags[flagofs++] = format[n]; - break; + case wxPAT_SIZET: + ::sprintf(szScratch, szFlags, p->pad_sizet); + break; - case wxT('-'): - CHECK_PREC - adj_left = TRUE; - s_szFlags[flagofs++] = format[n]; - break; + case wxPAT_LONGDOUBLE: + ::sprintf(szScratch, szFlags, p->pad_longdouble); + break; - 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; + case wxPAT_DOUBLE: + ::sprintf(szScratch, szFlags, p->pad_double); + break; - case wxT('h'): - ilen = -1; - CHECK_PREC - s_szFlags[flagofs++] = format[n]; - break; + case wxPAT_POINTER: + ::sprintf(szScratch, szFlags, p->pad_pointer); + break; - case wxT('l'): - ilen = 1; - CHECK_PREC - s_szFlags[flagofs++] = format[n]; - break; + case wxPAT_CHAR: + case wxPAT_WCHAR: + { + wxChar val = +#if wxUSE_UNICODE + p->pad_wchar; - case wxT('q'): - case wxT('L'): - ilen = 2; - CHECK_PREC - s_szFlags[flagofs++] = format[n]; - break; + if (type == wxPAT_CHAR) { + // user passed a character explicitely indicated as ANSI... + const char buf[2] = { p->pad_char, 0 }; + val = wxString(buf, wxConvLibc)[0u]; + } +#else + p->pad_char; - case wxT('Z'): - ilen = 3; - CHECK_PREC - s_szFlags[flagofs++] = format[n]; - break; +#if wxUSE_WCHAR_T + if (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]; + } +#endif +#endif - 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; + size_t i; - 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 (!adj_left) + for (i = 1; i < (size_t)min_width; i++) + APPEND_CH(_T(' ')); - case wxT('d'): - case wxT('i'): - case wxT('o'): - case wxT('u'): - case wxT('x'): - case wxT('X'): - CHECK_PREC - s_szFlags[flagofs++] = format[n]; - s_szFlags[flagofs] = '\0'; - if (ilen == 0 ) { - int val = va_arg(argptr, int); - ::sprintf(szScratch, s_szFlags, val); - } - else if (ilen == -1) { - short int val = va_arg(argptr, short 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); + APPEND_CH(val); + + if (adj_left) + for (i = 1; i < (size_t)min_width; i++) + APPEND_CH(_T(' ')); + } + break; + + case wxPAT_PCHAR: + case wxPAT_PWCHAR: + { + wxString s; + const wxChar *val = +#if wxUSE_UNICODE + p->pad_pwchar; + + if (type == wxPAT_PCHAR) { + // user passed a string explicitely indicated as ANSI... + val = s = wxString(p->pad_pchar, wxConvLibc); + } +#else + p->pad_pchar; + +#if wxUSE_WCHAR_T + if (type == wxPAT_PWCHAR) { + // user passed a string explicitely indicated as Unicode... + val = s = wxString(p->pad_pwchar, wxConvLibc); + } +#endif +#endif + int len; + + if (val) + { +#if wxUSE_STRUTILS + // at this point we are sure that max_width is positive or null + // (see top of wxPrintfConvSpec::LoadArg) + len = wxMin((unsigned int)max_width, wxStrlen(val)); #else - long int val = va_arg(argptr, long int); - ::sprintf(szScratch, s_szFlags, val); + for ( len = 0; val[len] && (len < max_width); len++ ) + ; #endif - } - else if (ilen == 3) { - size_t val = va_arg(argptr, size_t); - ::sprintf(szScratch, s_szFlags, val); - } + } + else if (max_width >= 6) + { + val = wxT("(null)"); + len = 6; + } + else + { + val = wxEmptyString; + len = 0; + } - APPEND_STR(szScratch); + int i; - done = TRUE; - break; + if (!adj_left) + { + for (i = len; i < min_width; i++) + APPEND_CH(_T(' ')); + } - case wxT('e'): - case wxT('E'): - case wxT('f'): - case wxT('g'): - case wxT('G'): - CHECK_PREC - s_szFlags[flagofs++] = format[n]; - 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); - } - - APPEND_STR(szScratch); - - done = TRUE; - break; +#if wxUSE_STRUTILS + // at this point we are sure that max_width is positive or null + // (see top of wxPrintfConvSpec::LoadArg) + 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('p'): - { - void *val = va_arg(argptr, void *); - CHECK_PREC - s_szFlags[flagofs++] = format[n]; - s_szFlags[flagofs] = '\0'; - ::sprintf(szScratch, s_szFlags, val); + if (adj_left) + { + for (i = len; i < min_width; i++) + APPEND_CH(_T(' ')); + } + } + break; - APPEND_STR(szScratch); + case wxPAT_NINT: + *p->pad_nint = lenCur; + break; - done = TRUE; - } - break; + case wxPAT_NSHORTINT: + *p->pad_nshortint = (short int)lenCur; + break; - case wxT('c'): - { - wxChar val = va_arg(argptr, int); - // we don't need to honor padding here, do we? - APPEND_CH(val); + case wxPAT_NLONGINT: + *p->pad_nlongint = lenCur; + break; - done = TRUE; - } - break; + case wxPAT_INVALID: + default: + return -1; + } - case wxT('s'): - if (ilen == -1) { - // wx extension: we'll let %hs mean non-Unicode strings - char *val = va_arg(argptr, char *); -#if wxUSE_UNICODE - // ASCII->Unicode constructor handles max_width right - wxString s(val, wxConvLibc, max_width); + // if we used system's sprintf() then we now need to append the s_szScratch + // buffer to the given one... + switch (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 + { + const wxMB2WXbuf tmp = wxConvLibc.cMB2WX(szScratch); + size_t len = wxMin(lenMax, wxStrlen(tmp)); + wxStrncpy(buf, tmp, len); + lenCur += len; + } #else - size_t len = wxSTRING_MAXLEN; - if (val) { - for (len = 0; val[len] && (len= 1) { - long int *val = va_arg(argptr, long int *); - *val = lenCur; - } - done = TRUE; - break; + default: + break; // all other cases were completed previously + } - default: - if (wxIsalpha(format[n])) - // probably some flag not taken care of here yet - s_szFlags[flagofs++] = format[n]; - else { - // bad format - APPEND_CH(_T('%')); // just to pass the glibc tst-printf.c - n--; - done = TRUE; - } - break; - } - } while (!done); + return lenCur; +} + +// 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; + + if (n == 0) + return 0; + + size_t i; + for ( i = 0; i < n-1; source++, i++) + { + dest[written++] = *source; + if (*(source+1) == wxT('%')) + { + // skip this additional '%' character + source++; + i++; } - else + } + + 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) +{ + // cached data + static wxPrintfConvSpec arg[wxMAX_SVNPRINTF_ARGUMENTS]; + static wxPrintfArg argdata[wxMAX_SVNPRINTF_ARGUMENTS]; + static wxPrintfConvSpec *pspec[wxMAX_SVNPRINTF_ARGUMENTS] = { NULL }; + + 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('%') ) { - APPEND_CH(format[n]); + 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->argend; + + if (current->pos > 0) { + // the positionals start from number 1... adjust the index + current->pos--; + posarg_present = true; + } else { + // not a positional argument... + current->pos = nargs; + nonposarg_present = true; + } + + // this conversion specifier is tied to the pos-th argument... + pspec[current->pos] = current; + nargs++; + + if (nargs == wxMAX_SVNPRINTF_ARGUMENTS) + break; // cannot handle any additional conv spec + } } } + 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] if user forgot a positional parameter (e.g. %$1s %$3s) ? + // or LoadArg false if wxPrintfConvSpec::Parse failed to set its '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].argpos - toparse ); + if (lenCur+tocopy >= lenMax) + return -1; // not enough space in the output buffer ! + + 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].pos]); + if (n == -1) + return -1; // not enough space in the output buffer ! + lenCur += n; + + // the +1 is because wxPrintfConvSpec::argend points to the last character + // of the format specifier, but we are not interested to it... + toparse = arg[i].argend + 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; + + // clean the static array portion used... + // NOTE: other arrays do not need cleanup! + memset(pspec, 0, sizeof(wxPrintfConvSpec*)*nargs); + + wxASSERT(lenCur == wxStrlen(buf)); return lenCur; } @@ -447,27 +1076,60 @@ int WXDLLEXPORT wxSnprintf_(wxChar *buf, size_t len, const wxChar *format, ...) } #endif // wxSnprintf_ +#if defined(__DMC__) + /* Digital Mars adds count to _stprintf (C99) so convert */ + #if wxUSE_UNICODE + int wxSprintf (wchar_t * __RESTRICT s, const wchar_t * __RESTRICT format, ... ) + { + va_list arglist; + + va_start( arglist, format ); + int iLen = swprintf ( s, -1, format, arglist ); + va_end( arglist ); + return iLen ; + } + + #endif // wxUSE_UNICODE + +#endif //__DMC__ + // ---------------------------------------------------------------------------- // implement the standard IO functions for wide char if libc doesn't have them // ---------------------------------------------------------------------------- -#ifdef wxNEED_FPUTWC - +#ifdef wxNEED_FPUTS int wxFputs(const wchar_t *ws, FILE *stream) { // counting the number of wide characters written isn't worth the trouble, // simply distinguish between ok and error return fputs(wxConvLibc.cWC2MB(ws), stream) == -1 ? -1 : 0; } +#endif // wxNEED_FPUTS + +#ifdef wxNEED_PUTS +int wxPuts(const wxChar *ws) +{ + int rc = wxFputs(ws, stdout); + if ( rc != -1 ) + { + if ( wxFputs(L"\n", stdout) == -1 ) + return -1; + + rc++; + } + + return rc; +} +#endif // wxNEED_PUTS +#ifdef wxNEED_PUTC int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream) { wchar_t ws[2] = { wc, L'\0' }; return wxFputs(ws, stream); } - -#endif // wxNEED_FPUTWC +#endif // wxNEED_PUTC // NB: we only implement va_list functions here, the ones taking ... are // defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse @@ -475,21 +1137,31 @@ int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream) #ifdef wxNEED_WPRINTF // TODO: implement the scanf() functions -int vwscanf(const wchar_t *format, va_list argptr) +int vwscanf(const wxChar *format, va_list argptr) { wxFAIL_MSG( _T("TODO") ); return -1; } -int vswscanf(const wchar_t *ws, const wchar_t *format, va_list argptr) +int vswscanf(const wxChar *ws, const wxChar *format, va_list argptr) { - wxFAIL_MSG( _T("TODO") ); - - return -1; + // The best we can do without proper Unicode support in glibc is to + // convert the strings into MB representation and run ANSI version + // of the function. This doesn't work with %c and %s because of difference + // in size of char and wchar_t, though. + + wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1, + _T("incomplete vswscanf implementation doesn't allow %s") ); + wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1, + _T("incomplete vswscanf implementation doesn't allow %c") ); + + va_list argcopy; + wxVaCopy(argcopy, argptr); + return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argcopy); } -int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr) +int vfwscanf(FILE *stream, const wxChar *format, va_list argptr) { wxFAIL_MSG( _T("TODO") ); @@ -498,7 +1170,7 @@ int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr) #define vswprintf wxVsnprintf_ -int vfwprintf(FILE *stream, const wchar_t *format, va_list argptr) +int vfwprintf(FILE *stream, const wxChar *format, va_list argptr) { wxString s; int rc = s.PrintfV(format, argptr); @@ -506,14 +1178,14 @@ int vfwprintf(FILE *stream, const wchar_t *format, va_list argptr) if ( rc != -1 ) { // we can't do much better without Unicode support in libc... - if ( fprintf(stream, s.mb_str()) == -1 ) + if ( fprintf(stream, "%s", (const char*)s.mb_str() ) == -1 ) return -1; } return rc; } -int vwprintf(const wchar_t *format, va_list argptr) +int vwprintf(const wxChar *format, va_list argptr) { return wxVfprintf(stdout, format, argptr); } @@ -551,7 +1223,7 @@ int vwprintf(const wchar_t *format, va_list argptr) So to use native functions in order to get our semantics we must do the following translations in Unicode mode (nothing to do in ANSI mode): - wxWindows specifier POSIX specifier + wxWidgets specifier POSIX specifier ---------------------------------------- %hc, %C, %hC %c @@ -621,10 +1293,10 @@ private: ch == _T('0') || ch == _T(' ') || ch == _T('#'); } - void SkipDigits(const wxChar **ppc) + void SkipDigits(const wxChar **ptpc) { - while ( **ppc >= _T('0') && **ppc <= _T('9') ) - CopyFmtChar(*(*ppc)++); + while ( **ptpc >= _T('0') && **ptpc <= _T('9') ) + CopyFmtChar(*(*ptpc)++); } // the translated format @@ -659,7 +1331,11 @@ wxFormatConverter::wxFormatConverter(const wxChar *format) // precision? if ( *format == _T('.') ) { - SkipDigits(&format); + CopyFmtChar(*format++); + if ( *format == _T('*') ) + CopyFmtChar(*format++); + else + SkipDigits(&format); } // next we can have a size modifier @@ -706,23 +1382,14 @@ wxFormatConverter::wxFormatConverter(const wxChar *format) case _T('c'): case _T('s'): // %c -> %lc but %hc stays %hc and %lc is still %lc - switch ( size ) - { - case Default: - InsertFmtChar(_T('l')); - break; - - case Short: - CopyFmtChar(_T('h')); - break; - - case Long: - ; - } + if ( size == Default) + InsertFmtChar(_T('l')); // fall through default: // nothing special to do + if ( size != Default ) + CopyFmtChar(*(format - 1)); CopyFmtChar(*format++); } } @@ -734,13 +1401,21 @@ wxFormatConverter::wxFormatConverter(const wxChar *format) #define wxFormatConverter(x) (x) #endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION +#ifdef __WXDEBUG__ +// For testing the format converter +wxString wxConvertFormat(const wxChar *format) +{ + return wxString(wxFormatConverter(format)); +} +#endif + // ---------------------------------------------------------------------------- // wxPrintf(), wxScanf() and relatives // ---------------------------------------------------------------------------- #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF) -int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2 +int wxScanf( const wxChar *format, ... ) { va_list argptr; va_start(argptr, format); @@ -752,7 +1427,7 @@ int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2 return ret; } -int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3 +int wxSscanf( const wxChar *str, const wxChar *format, ... ) { va_list argptr; va_start(argptr, format); @@ -764,11 +1439,10 @@ int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3 return ret; } -int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3 +int wxFscanf( FILE *stream, const wxChar *format, ... ) { va_list argptr; va_start(argptr, format); - int ret = vfwscanf(stream, wxFormatConverter(format), argptr); va_end(argptr); @@ -776,11 +1450,11 @@ int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3 return ret; } -int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2 +int wxPrintf( const wxChar *format, ... ) { va_list argptr; va_start(argptr, format); - + int ret = vwprintf( wxFormatConverter(format), argptr ); va_end(argptr); @@ -789,7 +1463,7 @@ int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2 } #ifndef wxSnprintf -int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_4 +int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) { va_list argptr; va_start(argptr, format); @@ -802,20 +1476,22 @@ int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_ } #endif // wxSnprintf -int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3 +int wxSprintf( wxChar *str, const wxChar *format, ... ) { va_list argptr; va_start(argptr, format); - // callers of wxSprintf() deserve what they get - int ret = vswprintf( str, UINT_MAX, wxFormatConverter(format), argptr ); + // note that wxString::FormatV() uses wxVsnprintf(), not wxSprintf(), so + // it's safe to implement this one in terms of it + wxString s(wxString::FormatV(format, argptr)); + wxStrcpy(str, s); va_end(argptr); - return ret; + return s.length(); } -int wxFprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3 +int wxFprintf( FILE *stream, const wxChar *format, ... ) { va_list argptr; va_start( argptr, format ); @@ -852,11 +1528,13 @@ int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list argptr int wxVsprintf( wxChar *str, const wxChar *format, va_list argptr ) { // same as for wxSprintf() - return vswprintf(str, UINT_MAX, wxFormatConverter(format), argptr); + return vswprintf(str, INT_MAX / 4, wxFormatConverter(format), argptr); } #endif // wxNEED_PRINTF_CONVERSION +#if wxUSE_WCHAR_T + // ---------------------------------------------------------------------------- // ctype.h stuff (currently unused) // ---------------------------------------------------------------------------- @@ -871,7 +1549,7 @@ inline WORD wxMSW_ctype(wxChar ch) WXDLLEXPORT int wxIsalnum(wxChar ch) { return IsCharAlphaNumeric(ch); } WXDLLEXPORT int wxIsalpha(wxChar ch) { return IsCharAlpha(ch); } -WXDLLEXPORT int wxIsctrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; } +WXDLLEXPORT int wxIscntrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; } WXDLLEXPORT int wxIsdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_DIGIT; } WXDLLEXPORT int wxIsgraph(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); } WXDLLEXPORT int wxIslower(wxChar ch) { return IsCharLower(ch); } @@ -884,15 +1562,105 @@ WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); } WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); } #endif -#ifndef wxStrdup -WXDLLEXPORT wxChar * wxStrdup(const wxChar *psz) +#ifdef wxNEED_WX_MBSTOWCS + +WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen) +{ + if (!out) + { + size_t outsize = 0; + while(*in++) + outsize++; + return outsize; + } + + const char* origin = in; + + while (outlen-- && *in) + { + *out++ = (wchar_t) *in++; + } + + *out = '\0'; + + return in - origin; +} + +WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen) { - size_t size = (wxStrlen(psz) + 1) * sizeof(wxChar); - wxChar *ret = (wxChar *) malloc(size); - memcpy(ret, psz, size); + if (!out) + { + size_t outsize = 0; + while(*in++) + outsize++; + return outsize; + } + + const wchar_t* origin = in; + + while (outlen-- && *in) + { + *out++ = (char) *in++; + } + + *out = '\0'; + + return in - origin; +} + +#endif // wxNEED_WX_MBSTOWCS + +#if defined(wxNEED_WX_CTYPE_H) + +#include + +#define cfalnumset CFCharacterSetGetPredefined(kCFCharacterSetAlphaNumeric) +#define cfalphaset CFCharacterSetGetPredefined(kCFCharacterSetLetter) +#define cfcntrlset CFCharacterSetGetPredefined(kCFCharacterSetControl) +#define cfdigitset CFCharacterSetGetPredefined(kCFCharacterSetDecimalDigit) +//CFCharacterSetRef cfgraphset = kCFCharacterSetControl && !' ' +#define cflowerset CFCharacterSetGetPredefined(kCFCharacterSetLowercaseLetter) +//CFCharacterSetRef cfprintset = !kCFCharacterSetControl +#define cfpunctset CFCharacterSetGetPredefined(kCFCharacterSetPunctuation) +#define cfspaceset CFCharacterSetGetPredefined(kCFCharacterSetWhitespaceAndNewline) +#define cfupperset CFCharacterSetGetPredefined(kCFCharacterSetUppercaseLetter) + +WXDLLEXPORT int wxIsalnum(wxChar ch) { return CFCharacterSetIsCharacterMember(cfalnumset, ch); } +WXDLLEXPORT int wxIsalpha(wxChar ch) { return CFCharacterSetIsCharacterMember(cfalphaset, ch); } +WXDLLEXPORT int wxIscntrl(wxChar ch) { return CFCharacterSetIsCharacterMember(cfcntrlset, ch); } +WXDLLEXPORT int wxIsdigit(wxChar ch) { return CFCharacterSetIsCharacterMember(cfdigitset, ch); } +WXDLLEXPORT int wxIsgraph(wxChar ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch) && ch != ' '; } +WXDLLEXPORT int wxIslower(wxChar ch) { return CFCharacterSetIsCharacterMember(cflowerset, ch); } +WXDLLEXPORT int wxIsprint(wxChar ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch); } +WXDLLEXPORT int wxIspunct(wxChar ch) { return CFCharacterSetIsCharacterMember(cfpunctset, ch); } +WXDLLEXPORT int wxIsspace(wxChar ch) { return CFCharacterSetIsCharacterMember(cfspaceset, ch); } +WXDLLEXPORT int wxIsupper(wxChar ch) { return CFCharacterSetIsCharacterMember(cfupperset, ch); } +WXDLLEXPORT int wxIsxdigit(wxChar ch) { return wxIsdigit(ch) || (ch>='a' && ch<='f') || (ch>='A' && ch<='F'); } +WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)tolower((char)(ch)); } +WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)toupper((char)(ch)); } + +#endif // wxNEED_WX_CTYPE_H + +#ifndef wxStrdupA + +WXDLLEXPORT char *wxStrdupA(const char *s) +{ + return strcpy((char *)malloc(strlen(s) + 1), s); +} + +#endif // wxStrdupA + +#ifndef wxStrdupW + +WXDLLEXPORT wchar_t * wxStrdupW(const wchar_t *pwz) +{ + size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t); + wchar_t *ret = (wchar_t *) malloc(size); + memcpy(ret, pwz, size); return ret; } -#endif + +#endif // wxStrdupW #ifndef wxStricmp int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2) @@ -909,7 +1677,8 @@ int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2) #ifndef wxStricmp int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n) { - register wxChar c1, c2; + // initialize the variables just to suppress stupid gcc warning + register wxChar c1 = 0, c2 = 0; while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++; if (n) { if (c1 < c2) return -1; @@ -919,32 +1688,23 @@ int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n) } #endif -#ifndef wxStrtok -WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr) +#ifndef wxSetlocale +WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale) { - if (!psz) psz = *save_ptr; - psz += wxStrspn(psz, delim); - if (!*psz) { - *save_ptr = (wxChar *)NULL; - return (wxChar *)NULL; - } - wxChar *ret = psz; - psz = wxStrpbrk(psz, delim); - if (!psz) *save_ptr = (wxChar*)NULL; - else { - *psz = wxT('\0'); - *save_ptr = psz + 1; - } - return ret; + char *localeOld = setlocale(category, wxConvLibc.cWX2MB(locale)); + + return wxWCharBuffer(wxConvLibc.cMB2WC(localeOld)); } #endif -#ifndef wxSetlocale -WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale) +#if wxUSE_WCHAR_T && !defined(HAVE_WCSLEN) +WXDLLEXPORT size_t wxWcslen(const wchar_t *s) { - char *localeOld = setlocale(category, wxConvLocal.cWX2MB(locale)); + size_t n = 0; + while ( *s++ ) + n++; - return wxWCharBuffer(wxConvLocal.cMB2WC(localeOld)); + return n; } #endif @@ -953,6 +1713,12 @@ WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale) // ---------------------------------------------------------------------------- #ifdef wxNEED_WX_STRING_H + +// RN: These need to be c externed for the regex lib +#ifdef __cplusplus +extern "C" { +#endif + WXDLLEXPORT wxChar * wxStrcat(wxChar *dest, const wxChar *src) { wxChar *ret = dest; @@ -988,6 +1754,16 @@ WXDLLEXPORT wxChar * wxStrcpy(wxChar *dest, const wxChar *src) return ret; } +WXDLLEXPORT size_t wxStrlen_(const wxChar *s) +{ + size_t n = 0; + while ( *s++ ) + n++; + + return n; +} + + WXDLLEXPORT wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n) { wxChar *ret = dest; @@ -1045,7 +1821,7 @@ WXDLLEXPORT size_t wxStrspn(const wxChar *s, const wxChar *accept) WXDLLEXPORT const wxChar *wxStrstr(const wxChar *haystack, const wxChar *needle) { - wxCHECK_RET( needle, NULL, _T("NULL argument in wxStrstr") ); + wxASSERT_MSG( needle != NULL, _T("NULL argument in wxStrstr") ); // VZ: this is not exactly the most efficient string search algorithm... @@ -1062,6 +1838,10 @@ WXDLLEXPORT const wxChar *wxStrstr(const wxChar *haystack, const wxChar *needle) return NULL; } +#ifdef __cplusplus +} +#endif + WXDLLEXPORT double wxStrtod(const wxChar *nptr, wxChar **endptr) { const wxChar *start = nptr; @@ -1081,7 +1861,7 @@ WXDLLEXPORT double wxStrtod(const wxChar *nptr, wxChar **endptr) } wxString data(nptr, nptr-start); - wxWX2MBbuf dat = data.mb_str(wxConvLocal); + wxWX2MBbuf dat = data.mb_str(wxConvLibc); char *rdat = wxMBSTRINGCAST dat; double ret = strtod(dat, &rdat); @@ -1108,8 +1888,8 @@ WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base) while ((wxIsdigit(*nptr) && (*nptr - wxT('0') < base)) || (wxIsalpha(*nptr) && (wxToupper(*nptr) - wxT('A') + 10 < base))) nptr++; - wxString data(nptr, nptr-start); - wxWX2MBbuf dat = data.mb_str(wxConvLocal); + wxString data(start, nptr-start); + wxWX2MBbuf dat = data.mb_str(wxConvLibc); char *rdat = wxMBSTRINGCAST dat; long int ret = strtol(dat, &rdat, base); @@ -1117,6 +1897,12 @@ WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base) return ret; } + +WXDLLEXPORT unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base) +{ + return (unsigned long int) wxStrtol(nptr, endptr, base); +} + #endif // wxNEED_WX_STRING_H #ifdef wxNEED_WX_STDIO_H @@ -1152,80 +1938,165 @@ WXDLLEXPORT int wxRename(const wxChar *oldpath, const wxChar *newpath) #ifndef wxAtof double WXDLLEXPORT wxAtof(const wxChar *psz) { - return atof(wxConvLocal.cWX2MB(psz)); +#ifdef __WXWINCE__ + double d; + wxString str(psz); + if (str.ToDouble(& d)) + return d; + + return 0.0; +#else + return atof(wxConvLibc.cWX2MB(psz)); +#endif } #endif #ifdef wxNEED_WX_STDLIB_H int WXDLLEXPORT wxAtoi(const wxChar *psz) { - return atoi(wxConvLocal.cWX2MB(psz)); + return atoi(wxConvLibc.cWX2MB(psz)); } long WXDLLEXPORT wxAtol(const wxChar *psz) { - return atol(wxConvLocal.cWX2MB(psz)); + return atol(wxConvLibc.cWX2MB(psz)); } wxChar * WXDLLEXPORT wxGetenv(const wxChar *name) { - static wxHashTable env; - - // check if we already have stored the converted env var - wxObject *data = env.Get(name); - if (!data) - { - // nope, retrieve it, #if wxUSE_UNICODE - wxCharBuffer buffer = wxConvLocal.cWX2MB(name); - // printf( "buffer %s\n", (const char*) buffer ); - const char *val = getenv( (const char *)buffer ); + // NB: buffer returned by getenv() is allowed to be overwritten next + // time getenv() is called, so it is OK to use static string + // buffer to hold the data. + static wxWCharBuffer value((wxChar*)NULL); + value = wxConvLibc.cMB2WX(getenv(wxConvLibc.cWX2MB(name))); + return value.data(); #else - const char *val = getenv( name ); + return getenv(name); #endif +} - if (!val) return (wxChar *)NULL; - // printf( "home %s\n", val ); +int WXDLLEXPORT wxSystem(const wxChar *psz) +{ + return system(wxConvLibc.cWX2MB(psz)); +} - // convert it, -#ifdef wxUSE_UNICODE - data = (wxObject *)new wxString(val, wxConvLocal); -#else - data = (wxObject *)new wxString(val); -#endif +#endif // wxNEED_WX_STDLIB_H - // and store it - env.Put(name, data); - } - // return converted env var - return (wxChar *)((wxString *)data)->c_str(); +#ifdef wxNEED_WX_TIME_H +WXDLLEXPORT size_t +wxStrftime(wxChar *s, size_t maxsize, const wxChar *fmt, const struct tm *tm) +{ + if ( !maxsize ) + return 0; + + wxCharBuffer buf(maxsize); + + wxCharBuffer bufFmt(wxConvLibc.cWX2MB(fmt)); + if ( !bufFmt ) + return 0; + + size_t ret = strftime(buf.data(), maxsize, bufFmt, tm); + if ( !ret ) + return 0; + + wxWCharBuffer wbuf = wxConvLibc.cMB2WX(buf); + if ( !wbuf ) + return 0; + + wxStrncpy(s, wbuf, maxsize); + return wxStrlen(s); } +#endif // wxNEED_WX_TIME_H -int WXDLLEXPORT wxSystem(const wxChar *psz) +#ifndef wxCtime +WXDLLEXPORT wxChar *wxCtime(const time_t *timep) { - return system(wxConvLocal.cWX2MB(psz)); + // normally the string is 26 chars but give one more in case some broken + // DOS compiler decides to use "\r\n" instead of "\n" at the end + static wxChar buf[27]; + + // ctime() is guaranteed to return a string containing only ASCII + // characters, as its format is always the same for any locale + wxStrncpy(buf, wxString::FromAscii(ctime(timep)), WXSIZEOF(buf)); + buf[WXSIZEOF(buf) - 1] = _T('\0'); + + return buf; } +#endif // wxCtime -#endif +#endif // wxUSE_WCHAR_T -#ifdef wxNEED_WX_TIME_H -WXDLLEXPORT size_t wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const struct tm *tm) +// ---------------------------------------------------------------------------- +// functions which we may need even if !wxUSE_WCHAR_T +// ---------------------------------------------------------------------------- + +#ifndef wxStrtok + +WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr) { - if (!max) return 0; + if (!psz) + { + psz = *save_ptr; + if ( !psz ) + return NULL; + } - char *buf = (char *)malloc(max); - size_t ret = strftime(buf, max, wxConvLocal.cWX2MB(fmt), tm); - if (ret) + psz += wxStrspn(psz, delim); + if (!*psz) { - wxStrcpy(s, wxConvLocal.cMB2WX(buf)); - free(buf); - return wxStrlen(s); + *save_ptr = (wxChar *)NULL; + return (wxChar *)NULL; + } + + wxChar *ret = psz; + psz = wxStrpbrk(psz, delim); + if (!psz) + { + *save_ptr = (wxChar*)NULL; } else { - free(buf); - *s = 0; - return 0; - } + *psz = wxT('\0'); + *save_ptr = psz + 1; + } + + return ret; } + +#endif // wxStrtok + +// ---------------------------------------------------------------------------- +// missing C RTL functions +// ---------------------------------------------------------------------------- + +#ifdef wxNEED_STRDUP + +char *strdup(const char *s) +{ + char *dest = (char*) malloc( strlen( s ) + 1 ) ; + if ( dest ) + strcpy( dest , s ) ; + return dest ; +} +#endif // wxNEED_STRDUP + +#if defined(__WXWINCE__) && (_WIN32_WCE <= 211) + +void *calloc( size_t num, size_t size ) +{ + void** ptr = (void **)malloc(num * size); + memset( ptr, 0, num * size); + return ptr; +} + +#endif // __WXWINCE__ <= 211 + +#ifdef __WXWINCE__ + +int wxRemove(const wxChar *path) +{ + return ::DeleteFile(path) == 0; +} + #endif