* Changed char to wxChar in operators.

[wxWidgets.git] / src / common / string.cpp

diff --git a/src/common/string.cpp b/src/common/string.cpp
index 4d806122807b084dbaf9580f99e245f233bbd408..783035d9609b577c2e813fd067d0c2effa72eeed 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -56,6 +56,11 @@
   IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
 #endif  //WXSTRING_IS_WXOBJECT
 
   IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
 #endif  //WXSTRING_IS_WXOBJECT
 

+#if wxUSE_UNICODE
+#undef wxUSE_EXPERIMENTAL_PRINTF
+#define wxUSE_EXPERIMENTAL_PRINTF 1
+#endif
+

 // allocating extra space for each string consumes more memory but speeds up
 // the concatenation operations (nLen is the current string's length)
 // NB: EXTRA_ALLOC must be >= 0!
 // allocating extra space for each string consumes more memory but speeds up
 // the concatenation operations (nLen is the current string's length)
 // NB: EXTRA_ALLOC must be >= 0!


@@ -89,6 +94,13 @@ extern const wxChar WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
 // conditional compilation
 // ----------------------------------------------------------------------------
 
 // conditional compilation
 // ----------------------------------------------------------------------------
 

+#if !defined(__WXSW__) && wxUSE_UNICODE
+  #ifdef wxUSE_EXPERIMENTAL_PRINTF
+    #undef wxUSE_EXPERIMENTAL_PRINTF
+  #endif
+  #define wxUSE_EXPERIMENTAL_PRINTF 1
+#endif
+

 // we want to find out if the current platform supports vsnprintf()-like
 // function: for Unix this is done with configure, for Windows we test the
 // compiler explicitly.
 // we want to find out if the current platform supports vsnprintf()-like
 // function: for Unix this is done with configure, for Windows we test the
 // compiler explicitly.


@@ -113,7 +125,7 @@ extern const wxChar WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
     #elif defined(__GNUG__) && !defined(__UNIX__)
         #warning "Using sprintf() because no snprintf()-like function defined"
     #elif defined(__MWERKS__)
     #elif defined(__GNUG__) && !defined(__UNIX__)
         #warning "Using sprintf() because no snprintf()-like function defined"
     #elif defined(__MWERKS__)

-           #warning "Using sprintf() because no snprintf()-like function defined"
+             #warning "Using sprintf() because no snprintf()-like function defined"

     #endif //compiler
 #endif // no vsnprintf
 
     #endif //compiler
 #endif // no vsnprintf
 


@@ -126,7 +138,7 @@ extern const wxChar WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
 // global functions
 // ----------------------------------------------------------------------------
 
 // global functions
 // ----------------------------------------------------------------------------
 

-#ifdef  wxSTD_STRING_COMPATIBILITY
+#if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM

 
 // MS Visual C++ version 5.0 provides the new STL headers as well as the old
 // iostream ones.
 
 // MS Visual C++ version 5.0 provides the new STL headers as well as the old
 // iostream ones.


@@ -256,15 +268,14 @@ wxString::wxString(const void *pStart, const void *pEnd)
 wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
 {
   // first get necessary size
 wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
 {
   // first get necessary size

-
-  size_t nLen = conv.MB2WC((wchar_t *) NULL, psz, 0);
+  size_t nLen = psz ? conv.MB2WC((wchar_t *) NULL, psz, 0) : 0;

 
   // nLength is number of *Unicode* characters here!
 
   // nLength is number of *Unicode* characters here!

-  if (nLen > nLength)
+  if ((nLen != (size_t)-1) && (nLen > nLength))

     nLen = nLength;
 
   // empty?
     nLen = nLength;
 
   // empty?

-  if ( nLen != 0 ) {
+  if ( (nLen != 0) && (nLen != (size_t)-1) ) {

     AllocBuffer(nLen);
     conv.MB2WC(m_pchData, psz, nLen);
   }
     AllocBuffer(nLen);
     conv.MB2WC(m_pchData, psz, nLen);
   }


@@ -275,15 +286,15 @@ wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
 
 #else
 
 
 #else
 

+#if wxUSE_WCHAR_T

 // from wide string
 wxString::wxString(const wchar_t *pwz)
 {
   // first get necessary size
 // from wide string
 wxString::wxString(const wchar_t *pwz)
 {
   // first get necessary size

-
-  size_t nLen = wxWC2MB((char *) NULL, pwz, 0);
+  size_t nLen = pwz ? wxWC2MB((char *) NULL, pwz, 0) : 0;

 
   // empty?
 
   // empty?

-  if ( nLen != 0 ) {
+  if ( (nLen != 0) && (nLen != (size_t)-1) ) {

     AllocBuffer(nLen);
     wxWC2MB(m_pchData, pwz, nLen);
   }
     AllocBuffer(nLen);
     wxWC2MB(m_pchData, pwz, nLen);
   }


@@ -291,6 +302,7 @@ wxString::wxString(const wchar_t *pwz)
     Init();
   }
 }
     Init();
   }
 }

+#endif

 
 #endif
 
 
 #endif
 


@@ -497,12 +509,14 @@ wxString& wxString::operator=(const unsigned char* psz)
   return *this;
 }
 
   return *this;
 }
 

+#if wxUSE_WCHAR_T

 wxString& wxString::operator=(const wchar_t *pwz)
 {
   wxString str(pwz);
   *this = str;
   return *this;
 }
 wxString& wxString::operator=(const wchar_t *pwz)
 {
   wxString str(pwz);
   *this = str;
   return *this;
 }

+#endif

 
 #endif
 
 
 #endif
 


@@ -983,14 +997,17 @@ int wxString::Printf(const wxChar *pszFormat, ...)
 int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
 {
   // static buffer to avoid dynamic memory allocation each time
 int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
 {
   // static buffer to avoid dynamic memory allocation each time

-  static char s_szScratch[1024];
+  char s_szScratch[1024]; // using static buffer causes internal compiler err
+#if 0

 #if wxUSE_THREADS
   // protect the static buffer
   static wxCriticalSection critsect;
   wxCriticalSectionLocker lock(critsect);
 #endif
 #if wxUSE_THREADS
   // protect the static buffer
   static wxCriticalSection critsect;
   wxCriticalSectionLocker lock(critsect);
 #endif

+#endif

 
 

-#if 1 // the new implementation
+#if wxUSE_EXPERIMENTAL_PRINTF
+// the new implementation

 
   Reinit();
   for (size_t n = 0; pszFormat[n]; n++)
 
   Reinit();
   for (size_t n = 0; pszFormat[n]; n++)


@@ -998,225 +1015,225 @@ int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
       static char s_szFlags[256] = "%";
       size_t flagofs = 1;
       bool adj_left = FALSE, in_prec = FALSE,
       static char s_szFlags[256] = "%";
       size_t flagofs = 1;
       bool adj_left = FALSE, in_prec = FALSE,

-          prec_dot = FALSE, done = FALSE;
+           prec_dot = FALSE, done = FALSE;

       int ilen = 0;
       size_t min_width = 0, max_width = wxSTRING_MAXLEN;
       do {
 #define CHECK_PREC if (in_prec && !prec_dot) { s_szFlags[flagofs++] = '.'; prec_dot = TRUE; }
       int ilen = 0;
       size_t min_width = 0, max_width = wxSTRING_MAXLEN;
       do {
 #define CHECK_PREC if (in_prec && !prec_dot) { s_szFlags[flagofs++] = '.'; prec_dot = TRUE; }

-       switch (pszFormat[++n]) {
-       case _T('\0'):
-         done = TRUE;
-         break;
-       case _T('%'):
-         *this += _T('%');
-         done = TRUE;
-         break;
-       case _T('#'):
-       case _T('0'):
-       case _T(' '):
-       case _T('+'):
-       case _T('\''):
-         CHECK_PREC
-         s_szFlags[flagofs++] = pszFormat[n];
-         break;
-       case _T('-'):
-         CHECK_PREC
-         adj_left = TRUE;
-         s_szFlags[flagofs++] = pszFormat[n];
-         break;
-       case _T('.'):
-         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 _T('h'):
-         ilen = -1;
-         CHECK_PREC
-         s_szFlags[flagofs++] = pszFormat[n];
-         break;
-       case _T('l'):
-         ilen = 1;
-         CHECK_PREC
-         s_szFlags[flagofs++] = pszFormat[n];
-         break;
-       case _T('q'):
-       case _T('L'):
-         ilen = 2;
-         CHECK_PREC
-         s_szFlags[flagofs++] = pszFormat[n];
-         break;
-       case _T('Z'):
-         ilen = 3;
-         CHECK_PREC
-         s_szFlags[flagofs++] = pszFormat[n];
-         break;
-       case _T('*'):
-         {
-           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;
-       case _T('1'): case _T('2'): case _T('3'):
-       case _T('4'): case _T('5'): case _T('6'):
-       case _T('7'): case _T('8'): case _T('9'):
-         {
-           int len = 0;
-           CHECK_PREC
-           while ((pszFormat[n]>=_T('0')) && (pszFormat[n]<=_T('9'))) {
-             s_szFlags[flagofs++] = pszFormat[n];
-             len = len*10 + (pszFormat[n] - _T('0'));
-             n++;
-           }
-           if (in_prec) max_width = len;
-           else min_width = len;
-           n--; // the main loop pre-increments n again
-         }
-         break;
-       case _T('d'):
-       case _T('i'):
-       case _T('o'):
-       case _T('u'):
-       case _T('x'):
-       case _T('X'):
-         CHECK_PREC
-         s_szFlags[flagofs++] = pszFormat[n];
-         s_szFlags[flagofs] = '\0';
-         if (ilen == 0 ) {
-           int val = va_arg(argptr, int);
-           ::sprintf(s_szScratch, s_szFlags, val);
-         }
-         else if (ilen == -1) {
-           short int val = va_arg(argptr, short int);
-           ::sprintf(s_szScratch, s_szFlags, val);
-         }
-         else if (ilen == 1) {
-           long int val = va_arg(argptr, long int);
-           ::sprintf(s_szScratch, s_szFlags, val);
-         }
-         else if (ilen == 2) {
+        switch (pszFormat[++n]) {
+        case _T('\0'):
+          done = TRUE;
+          break;
+        case _T('%'):
+          *this += _T('%');
+          done = TRUE;
+          break;
+        case _T('#'):
+        case _T('0'):
+        case _T(' '):
+        case _T('+'):
+        case _T('\''):
+          CHECK_PREC
+          s_szFlags[flagofs++] = pszFormat[n];
+          break;
+        case _T('-'):
+          CHECK_PREC
+          adj_left = TRUE;
+          s_szFlags[flagofs++] = pszFormat[n];
+          break;
+        case _T('.'):
+          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 _T('h'):
+          ilen = -1;
+          CHECK_PREC
+          s_szFlags[flagofs++] = pszFormat[n];
+          break;
+        case _T('l'):
+          ilen = 1;
+          CHECK_PREC
+          s_szFlags[flagofs++] = pszFormat[n];
+          break;
+        case _T('q'):
+        case _T('L'):
+          ilen = 2;
+          CHECK_PREC
+          s_szFlags[flagofs++] = pszFormat[n];
+          break;
+        case _T('Z'):
+          ilen = 3;
+          CHECK_PREC
+          s_szFlags[flagofs++] = pszFormat[n];
+          break;
+        case _T('*'):
+          {
+            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;
+        case _T('1'): case _T('2'): case _T('3'):
+        case _T('4'): case _T('5'): case _T('6'):
+        case _T('7'): case _T('8'): case _T('9'):
+          {
+            int len = 0;
+            CHECK_PREC
+            while ((pszFormat[n]>=_T('0')) && (pszFormat[n]<=_T('9'))) {
+              s_szFlags[flagofs++] = pszFormat[n];
+              len = len*10 + (pszFormat[n] - _T('0'));
+              n++;
+            }
+            if (in_prec) max_width = len;
+            else min_width = len;
+            n--; // the main loop pre-increments n again
+          }
+          break;
+        case _T('d'):
+        case _T('i'):
+        case _T('o'):
+        case _T('u'):
+        case _T('x'):
+        case _T('X'):
+          CHECK_PREC
+          s_szFlags[flagofs++] = pszFormat[n];
+          s_szFlags[flagofs] = '\0';
+          if (ilen == 0 ) {
+            int val = va_arg(argptr, int);
+            ::sprintf(s_szScratch, s_szFlags, val);
+          }
+          else if (ilen == -1) {
+            short int val = va_arg(argptr, short int);
+            ::sprintf(s_szScratch, s_szFlags, val);
+          }
+          else if (ilen == 1) {
+            long int val = va_arg(argptr, long int);
+            ::sprintf(s_szScratch, s_szFlags, val);
+          }
+          else if (ilen == 2) {

 #if SIZEOF_LONG_LONG
 #if SIZEOF_LONG_LONG

-           long long int val = va_arg(argptr, long long int);
-           ::sprintf(s_szScratch, s_szFlags, val);
+            long long int val = va_arg(argptr, long long int);
+            ::sprintf(s_szScratch, s_szFlags, val);

 #else
 #else

-           long int val = va_arg(argptr, long int);
-           ::sprintf(s_szScratch, s_szFlags, val);
+            long int val = va_arg(argptr, long int);
+            ::sprintf(s_szScratch, s_szFlags, val);

 #endif
 #endif

-         }
-         else if (ilen == 3) {
-           size_t val = va_arg(argptr, size_t);
-           ::sprintf(s_szScratch, s_szFlags, val);
-         }
-         *this += wxString(s_szScratch);
-         done = TRUE;
-         break;
-       case _T('e'):
-       case _T('E'):
-       case _T('f'):
-       case _T('g'):
-       case _T('G'):
-         CHECK_PREC
-         s_szFlags[flagofs++] = pszFormat[n];
-         s_szFlags[flagofs] = '\0';
-         if (ilen == 2) {
-           long double val = va_arg(argptr, long double);
-           ::sprintf(s_szScratch, s_szFlags, val);
-         } else {
-           double val = va_arg(argptr, double);
-           ::sprintf(s_szScratch, s_szFlags, val);
-         }
-         *this += wxString(s_szScratch);
-         done = TRUE;
-         break;
-       case _T('p'):
-         {
-           void *val = va_arg(argptr, void *);
-           CHECK_PREC
-           s_szFlags[flagofs++] = pszFormat[n];
-           s_szFlags[flagofs] = '\0';
-           ::sprintf(s_szScratch, s_szFlags, val);
-           *this += wxString(s_szScratch);
-           done = TRUE;
-         }
-         break;
-       case _T('c'):
-         {
-           wxChar val = va_arg(argptr, int);
-           // we don't need to honor padding here, do we?
-           *this += val;
-           done = TRUE;
-         }
-         break;
-       case _T('s'):
-         if (ilen == -1) {
-           // wx extension: we'll let %hs mean non-Unicode strings
-           char *val = va_arg(argptr, char *);
+          }
+          else if (ilen == 3) {
+            size_t val = va_arg(argptr, size_t);
+            ::sprintf(s_szScratch, s_szFlags, val);
+          }
+          *this += wxString(s_szScratch);
+          done = TRUE;
+          break;
+        case _T('e'):
+        case _T('E'):
+        case _T('f'):
+        case _T('g'):
+        case _T('G'):
+          CHECK_PREC
+          s_szFlags[flagofs++] = pszFormat[n];
+          s_szFlags[flagofs] = '\0';
+          if (ilen == 2) {
+            long double val = va_arg(argptr, long double);
+            ::sprintf(s_szScratch, s_szFlags, val);
+          } else {
+            double val = va_arg(argptr, double);
+            ::sprintf(s_szScratch, s_szFlags, val);
+          }
+          *this += wxString(s_szScratch);
+          done = TRUE;
+          break;
+        case _T('p'):
+          {
+            void *val = va_arg(argptr, void *);
+            CHECK_PREC
+            s_szFlags[flagofs++] = pszFormat[n];
+            s_szFlags[flagofs] = '\0';
+            ::sprintf(s_szScratch, s_szFlags, val);
+            *this += wxString(s_szScratch);
+            done = TRUE;
+          }
+          break;
+        case _T('c'):
+          {
+            wxChar val = va_arg(argptr, int);
+            // we don't need to honor padding here, do we?
+            *this += val;
+            done = TRUE;
+          }
+          break;
+        case _T('s'):
+          if (ilen == -1) {
+            // wx extension: we'll let %hs mean non-Unicode strings
+            char *val = va_arg(argptr, char *);

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-           // ASCII->Unicode constructor handles max_width right
-           wxString s(val, wxConv_libc, max_width);
+            // ASCII->Unicode constructor handles max_width right
+            wxString s(val, wxConvLibc, max_width);

 #else
 #else

-           size_t len = wxSTRING_MAXLEN;
-           if (val) {
-             for (len = 0; val[len] && (len<max_width); len++);
-           } else val = _T("(null)");
-           wxString s(val, len);
+            size_t len = wxSTRING_MAXLEN;
+            if (val) {
+              for (len = 0; val[len] && (len<max_width); len++);
+            } else val = _T("(null)");
+            wxString s(val, len);

 #endif
 #endif

-           if (s.Len() < min_width)
-             s.Pad(min_width - s.Len(), _T(' '), adj_left);
-           *this += s;
-         } else {
-           wxChar *val = va_arg(argptr, wxChar *);
-           size_t len = wxSTRING_MAXLEN;
-           if (val) {
-             for (len = 0; val[len] && (len<max_width); len++);
-           } else val = _T("(null)");
-           wxString s(val, len);
-           if (s.Len() < min_width)
-             s.Pad(min_width - s.Len(), _T(' '), adj_left);
-           *this += s;
-           done = TRUE;
-         }
-         break;
-       case _T('n'):
-         if (ilen == 0) {
-           int *val = va_arg(argptr, int *);
-           *val = Len();
-         }
-         else if (ilen == -1) {
-           short int *val = va_arg(argptr, short int *);
-           *val = Len();
-         }
-         else if (ilen >= 1) {
-           long int *val = va_arg(argptr, long int *);
-           *val = Len();
-         }
-         done = TRUE;
-         break;
-       default:
-         if (wxIsalpha(pszFormat[n]))
-           // probably some flag not taken care of here yet
-           s_szFlags[flagofs++] = pszFormat[n];
-         else {
-           // bad format
-           *this += _T('%'); // just to pass the glibc tst-printf.c
-           n--;
-           done = TRUE;
-         }
-         break;
-       }
+            if (s.Len() < min_width)
+              s.Pad(min_width - s.Len(), _T(' '), adj_left);
+            *this += s;
+          } else {
+            wxChar *val = va_arg(argptr, wxChar *);
+            size_t len = wxSTRING_MAXLEN;
+            if (val) {
+              for (len = 0; val[len] && (len<max_width); len++);
+            } else val = _T("(null)");
+            wxString s(val, len);
+            if (s.Len() < min_width)
+              s.Pad(min_width - s.Len(), _T(' '), adj_left);
+            *this += s;
+          }
+          done = TRUE;
+          break;
+        case _T('n'):
+          if (ilen == 0) {
+            int *val = va_arg(argptr, int *);
+            *val = Len();
+          }
+          else if (ilen == -1) {
+            short int *val = va_arg(argptr, short int *);
+            *val = Len();
+          }
+          else if (ilen >= 1) {
+            long int *val = va_arg(argptr, long int *);
+            *val = Len();
+          }
+          done = TRUE;
+          break;
+        default:
+          if (wxIsalpha(pszFormat[n]))
+            // probably some flag not taken care of here yet
+            s_szFlags[flagofs++] = pszFormat[n];
+          else {
+            // bad format
+            *this += _T('%'); // just to pass the glibc tst-printf.c
+            n--;
+            done = TRUE;
+          }
+          break;
+        }

 #undef CHECK_PREC
       } while (!done);
     } else *this += pszFormat[n];
 #undef CHECK_PREC
       } while (!done);
     } else *this += pszFormat[n];


@@ -1408,7 +1425,7 @@ size_t wxString::rfind(const wxString& str, size_t nStart) const
   wxASSERT( str.GetStringData()->IsValid() );
   wxASSERT( nStart <= Len() );
 
   wxASSERT( str.GetStringData()->IsValid() );
   wxASSERT( nStart <= Len() );
 

-  // # could be quicker than that
+  // TODO could be made much quicker than that

   const wxChar *p = c_str() + (nStart == npos ? Len() : nStart);
   while ( p >= c_str() + str.Len() ) {
     if ( wxStrncmp(p - str.Len(), str, str.Len()) == 0 )
   const wxChar *p = c_str() + (nStart == npos ? Len() : nStart);
   while ( p >= c_str() + str.Len() ) {
     if ( wxStrncmp(p - str.Len(), str, str.Len()) == 0 )


@@ -1423,19 +1440,131 @@ size_t wxString::rfind(const wxString& str, size_t nStart) const
 #if !defined(__VISUALC__) || defined(__WIN32__)
 size_t wxString::rfind(const wxChar* sz, size_t nStart, size_t n) const
 {
 #if !defined(__VISUALC__) || defined(__WIN32__)
 size_t wxString::rfind(const wxChar* sz, size_t nStart, size_t n) const
 {

-  return rfind(wxString(sz, n == npos ? 0 : n), nStart);
+    return rfind(wxString(sz, n == npos ? 0 : n), nStart);

 }
 
 size_t wxString::rfind(wxChar ch, size_t nStart) const
 {
 }
 
 size_t wxString::rfind(wxChar ch, size_t nStart) const
 {

-  wxASSERT( nStart <= Len() );
+    if ( nStart == npos )
+    {
+        nStart = Len();
+    }
+    else
+    {
+        wxASSERT( nStart <= Len() );
+    }

 
 

-  const wxChar *p = wxStrrchr(c_str() + nStart, ch);
+    const wxChar *p = wxStrrchr(c_str(), ch);

 
 

-  return p == NULL ? npos : p - c_str();
+    if ( p == NULL )
+        return npos;
+
+    size_t result = p - c_str();
+    return ( result > nStart ) ? npos : result;

 }
 #endif // VC++ 1.5
 
 }
 #endif // VC++ 1.5
 

+size_t wxString::find_first_of(const wxChar* sz, size_t nStart) const
+{
+    const wxChar *start = c_str() + nStart;
+    const wxChar *firstOf = wxStrpbrk(start, sz);
+    if ( firstOf )
+        return firstOf - start;
+    else
+        return npos;
+}
+
+size_t wxString::find_last_of(const wxChar* sz, size_t nStart) const
+{
+    if ( nStart == npos )
+    {
+        nStart = Len();
+    }
+    else
+    {
+        wxASSERT( nStart <= Len() );
+    }
+
+    for ( const wxChar *p = c_str() + length() - 1; p >= c_str(); p-- )
+    {
+        if ( wxStrchr(sz, *p) )
+            return p - c_str();
+    }
+
+    return npos;
+}
+
+size_t wxString::find_first_not_of(const wxChar* sz, size_t nStart) const
+{
+    if ( nStart == npos )
+    {
+        nStart = Len();
+    }
+    else
+    {
+        wxASSERT( nStart <= Len() );
+    }
+
+    size_t nAccept = wxStrspn(c_str() + nStart, sz);
+    if ( nAccept >= length() - nStart )
+        return npos;
+    else
+        return nAccept;
+}
+
+size_t wxString::find_first_not_of(wxChar ch, size_t nStart) const
+{
+    wxASSERT( nStart <= Len() );
+
+    for ( const wxChar *p = c_str() + nStart; *p; p++ )
+    {
+        if ( *p != ch )
+            return p - c_str();
+    }
+
+    return npos;
+}
+
+size_t wxString::find_last_not_of(const wxChar* sz, size_t nStart) const
+{
+    if ( nStart == npos )
+    {
+        nStart = Len();
+    }
+    else
+    {
+        wxASSERT( nStart <= Len() );
+    }
+
+    for ( const wxChar *p = c_str() + nStart - 1; p >= c_str(); p-- )
+    {
+        if ( !wxStrchr(sz, *p) )
+            return p - c_str();
+    }
+
+    return npos;
+}
+
+size_t wxString::find_last_not_of(wxChar ch, size_t nStart) const
+{
+    if ( nStart == npos )
+    {
+        nStart = Len();
+    }
+    else
+    {
+        wxASSERT( nStart <= Len() );
+    }
+
+    for ( const wxChar *p = c_str() + nStart - 1; p >= c_str(); p-- )
+    {
+        if ( *p != ch )
+            return p - c_str();
+    }
+
+    return npos;
+}
+

 wxString wxString::substr(size_t nStart, size_t nLen) const
 {
   // npos means 'take all'
 wxString wxString::substr(size_t nStart, size_t nLen) const
 {
   // npos means 'take all'


@@ -1803,13 +1932,18 @@ void wxArrayString::DoSort()
 // MBConv
 // ============================================================================
 
 // MBConv
 // ============================================================================
 

-WXDLLEXPORT_DATA(wxMBConv *) wxConv_current = &wxConv_libc;
+WXDLLEXPORT_DATA(wxMBConv *) wxConvCurrent = &wxConvLibc;
+#if !wxUSE_WCHAR_T
+WXDLLEXPORT_DATA(wxMBConv) wxConvLibc, wxConvFile;
+#endif
+
+#if wxUSE_WCHAR_T

 
 // ----------------------------------------------------------------------------
 // standard libc conversion
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // standard libc conversion
 // ----------------------------------------------------------------------------
 

-WXDLLEXPORT_DATA(wxMBConv) wxConv_libc;
+WXDLLEXPORT_DATA(wxMBConv) wxConvLibc;

 
 size_t wxMBConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {
 
 size_t wxMBConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {


@@ -1825,15 +1959,15 @@ size_t wxMBConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 // standard file conversion
 // ----------------------------------------------------------------------------
 
 // standard file conversion
 // ----------------------------------------------------------------------------
 

-WXDLLEXPORT_DATA(wxMBConv_file) wxConv_file;
+WXDLLEXPORT_DATA(wxMBConvFile) wxConvFile;

 
 // just use the libc conversion for now
 
 // just use the libc conversion for now

-size_t wxMBConv_file::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+size_t wxMBConvFile::MB2WC(wchar_t *buf, const char *psz, size_t n) const

 {
   return wxMB2WC(buf, psz, n);
 }
 
 {
   return wxMB2WC(buf, psz, n);
 }
 

-size_t wxMBConv_file::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+size_t wxMBConvFile::WC2MB(char *buf, const wchar_t *psz, size_t n) const

 {
   return wxWC2MB(buf, psz, n);
 }
 {
   return wxWC2MB(buf, psz, n);
 }


@@ -1842,12 +1976,12 @@ size_t wxMBConv_file::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 // standard gdk conversion
 // ----------------------------------------------------------------------------
 
 // standard gdk conversion
 // ----------------------------------------------------------------------------
 

-#ifdef __WXGTK__
-WXDLLEXPORT_DATA(wxMBConv_gdk) wxConv_gdk;
+#ifdef __WXGTK12__
+WXDLLEXPORT_DATA(wxMBConvGdk) wxConvGdk;

 
 #include <gdk/gdk.h>
 
 
 #include <gdk/gdk.h>
 

-size_t wxMBConv_gdk::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+size_t wxMBConvGdk::MB2WC(wchar_t *buf, const char *psz, size_t n) const

 {
   if (buf) {
     return gdk_mbstowcs((GdkWChar *)buf, psz, n);
 {
   if (buf) {
     return gdk_mbstowcs((GdkWChar *)buf, psz, n);


@@ -1859,7 +1993,7 @@ size_t wxMBConv_gdk::MB2WC(wchar_t *buf, const char *psz, size_t n) const
   }
 }
 
   }
 }
 

-size_t wxMBConv_gdk::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+size_t wxMBConvGdk::WC2MB(char *buf, const wchar_t *psz, size_t n) const

 {
   char *mbstr = gdk_wcstombs((GdkWChar *)psz);
   size_t len = mbstr ? strlen(mbstr) : 0;
 {
   char *mbstr = gdk_wcstombs((GdkWChar *)psz);
   size_t len = mbstr ? strlen(mbstr) : 0;


@@ -1870,21 +2004,35 @@ size_t wxMBConv_gdk::WC2MB(char *buf, const wchar_t *psz, size_t n) const
   }
   return len;
 }
   }
   return len;
 }

-#endif
+#endif // GTK > 1.0

 
 // ----------------------------------------------------------------------------
 // UTF-7
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // UTF-7
 // ----------------------------------------------------------------------------
 

-WXDLLEXPORT_DATA(wxMBConv_UTF7) wxConv_UTF7;
+WXDLLEXPORT_DATA(wxMBConvUTF7) wxConvUTF7;
+
+#if 0
+static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                        "abcdefghijklmnopqrstuvwxyz"
+                        "0123456789'(),-./:?";
+static char utf7_setO[]="!\"#$%&*;<=>@[]^_`{|}";
+static char utf7_setB[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                        "abcdefghijklmnopqrstuvwxyz"
+                        "0123456789+/";
+#endif

 
 // TODO: write actual implementations of UTF-7 here
 
 // TODO: write actual implementations of UTF-7 here

-size_t wxMBConv_UTF7::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf),
+                           const char * WXUNUSED(psz),
+                           size_t WXUNUSED(n)) const

 {
   return 0;
 }
 
 {
   return 0;
 }
 

-size_t wxMBConv_UTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
+                           const wchar_t * WXUNUSED(psz),
+                           size_t WXUNUSED(n)) const

 {
   return 0;
 }
 {
   return 0;
 }


@@ -1893,17 +2041,74 @@ size_t wxMBConv_UTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 // UTF-8
 // ----------------------------------------------------------------------------
 
 // UTF-8
 // ----------------------------------------------------------------------------
 

-WXDLLEXPORT_DATA(wxMBConv_UTF8) wxConv_UTF8;
+WXDLLEXPORT_DATA(wxMBConvUTF8) wxConvUTF8;
+
+static unsigned long utf8_max[]={0x7f,0x7ff,0xffff,0x1fffff,0x3ffffff,0x7fffffff,0xffffffff};

 
 

-// TODO: write actual implementations of UTF-8 here
-size_t wxMBConv_UTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
+size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const

 {
 {

-  return wxMB2WC(buf, psz, n);
+  size_t len = 0;
+
+  while (*psz && ((!buf) || (len<n))) {
+    unsigned char cc=*psz++, fc=cc;
+    unsigned cnt;
+    for (cnt=0; fc&0x80; cnt++) fc<<=1;
+    if (!cnt) {
+      // plain ASCII char
+      if (buf) *buf++=cc;
+      len++;
+    } else {
+      cnt--;
+      if (!cnt) {
+        // invalid UTF-8 sequence
+        return (size_t)-1;
+      } else {
+        unsigned ocnt=cnt-1;
+        unsigned long res=cc&(0x3f>>cnt);
+        while (cnt--) {
+          cc = *psz++;
+          if ((cc&0xC0)!=0x80) {
+            // invalid UTF-8 sequence
+            return (size_t)-1;
+          }
+          res=(res<<6)|(cc&0x3f);
+        }
+        if (res<=utf8_max[ocnt]) {
+          // illegal UTF-8 encoding
+          return (size_t)-1;
+        }
+        if (buf) *buf++=res;
+        len++;
+      }
+    }
+  }
+  if (buf && (len<n)) *buf = 0;
+  return len;

 }
 
 }
 

-size_t wxMBConv_UTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
+size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const

 {
 {

-  return wxWC2MB(buf, psz, n);
+  size_t len = 0;
+
+  while (*psz && ((!buf) || (len<n))) {
+    unsigned long cc=(*psz++)&0x7fffffff;
+    unsigned cnt;
+    for (cnt=0; cc>utf8_max[cnt]; cnt++);
+    if (!cnt) {
+      // plain ASCII char
+      if (buf) *buf++=cc;
+      len++;
+    } else {
+      len+=cnt+1;
+      if (buf) {
+        *buf++=(-128>>cnt)|((cc>>(cnt*6))&(0x3f>>cnt));
+        while (cnt--)
+          *buf++=0x80|((cc>>(cnt*6))&0x3f);
+      }
+    }
+  }
+  if (buf && (len<n)) *buf = 0;
+  return len;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1935,9 +2140,13 @@ static void wxLoadCharacterSets(void)
 {
   static bool already_loaded = FALSE;
 
 {
   static bool already_loaded = FALSE;
 

-#if defined(__UNIX__) && wxUSE_UNICODE
+  if (already_loaded) return;
+
+  already_loaded = TRUE;
+#if defined(__UNIX__) && wxUSE_TEXTFILE

   // search through files in /usr/share/i18n/charmaps
   // search through files in /usr/share/i18n/charmaps

-  for (wxString fname = ::wxFindFirstFile(_T("/usr/share/i18n/charmaps/*"));
+  wxString fname;
+  for (fname = ::wxFindFirstFile(_T("/usr/share/i18n/charmaps/*"));

        !fname.IsEmpty();
        fname = ::wxFindNextFile()) {
     wxTextFile cmap(fname);
        !fname.IsEmpty();
        fname = ::wxFindNextFile()) {
     wxTextFile cmap(fname);


@@ -1946,139 +2155,196 @@ static void wxLoadCharacterSets(void)
       wxString comchar,escchar;
       bool in_charset = FALSE;
 
       wxString comchar,escchar;
       bool in_charset = FALSE;
 

-      wxPrintf(_T("yup, loaded %s\n"),fname.c_str());
-
-      for (wxString line = cmap.GetFirstLine();
-          !cmap.Eof();
-          line = cmap.GetNextLine()) {
-       wxPrintf(_T("line contents: %s\n"),line.c_str());
-       wxStringTokenizer token(line);
-       wxString cmd = token.GetNextToken();
-       if (cmd == comchar) {
-         if (token.GetNextToken() == _T("alias")) {
-           wxStringTokenizer names(token.GetNextToken(),_T("/"));
-           wxString name;
-           while (!(name = names.GetNextToken()).IsEmpty())
-             cset->names.Add(name);
-         }
-       }
-       else if (cmd == _T("<code_set_name>"))
-         cset->names.Add(token.GetNextToken());
-       else if (cmd == _T("<comment_char>"))
-         comchar = token.GetNextToken();
-       else if (cmd == _T("<escape_char>"))
-         escchar = token.GetNextToken();
-       else if (cmd == _T("<mb_cur_min")) {
-         delete cset;
-         goto forget_it; // we don't support multibyte charsets ourselves (yet)
-       }
-       else if (cmd == _T("CHARMAP")) {
-         cset->data = (wchar_t *)calloc(256, sizeof(wxChar));
-         in_charset = TRUE;
-       }
-       else if (cmd == _T("END")) {
-         if (token.GetNextToken() == _T("CHARMAP"))
-           in_charset = FALSE;
-       }
-       else if (in_charset) {
-         // format: <NUL> /x00 <U0000> NULL (NUL)
-         wxString hex = token.GetNextToken();
-         wxString uni = token.GetNextToken();
-         // just assume that we've got the right format
-         int pos = ::wxHexToDec(hex.Mid(2,2));
-         unsigned long uni1 = ::wxHexToDec(uni.Mid(2,2));
-         unsigned long uni2 = ::wxHexToDec(uni.Mid(4,2));
-         cset->data[pos] = (uni1 << 16) | uni2;
-       }
+      // wxFprintf(stderr,_T("Loaded: %s\n"),fname.c_str());
+
+      wxString line;
+      for (line = cmap.GetFirstLine();
+           !cmap.Eof();
+           line = cmap.GetNextLine()) {
+        // wxFprintf(stderr,_T("line contents: %s\n"),line.c_str());
+        wxStringTokenizer token(line);
+        wxString cmd = token.GetNextToken();
+        if (cmd == comchar) {
+          if (token.GetNextToken() == _T("alias"))
+            cset->names.Add(token.GetNextToken());
+        }
+        else if (cmd == _T("<code_set_name>"))
+          cset->names.Add(token.GetNextToken());
+        else if (cmd == _T("<comment_char>"))
+          comchar = token.GetNextToken();
+        else if (cmd == _T("<escape_char>"))
+          escchar = token.GetNextToken();
+        else if (cmd == _T("<mb_cur_min>")) {
+          delete cset;
+          cset = (wxCharacterSet *) NULL;
+          break; // we don't support multibyte charsets ourselves (yet)
+        }
+        else if (cmd == _T("CHARMAP")) {
+          cset->data = (wchar_t *)calloc(256, sizeof(wchar_t));
+          in_charset = TRUE;
+        }
+        else if (cmd == _T("END")) {
+          if (token.GetNextToken() == _T("CHARMAP"))
+            in_charset = FALSE;
+        }
+        else if (in_charset) {
+          // format: <NUL> /x00 <U0000> NULL (NUL)
+          //         <A>   /x41 <U0041> LATIN CAPITAL LETTER A
+          wxString hex = token.GetNextToken();
+          // skip whitespace (why doesn't wxStringTokenizer do this?)
+          while (wxIsEmpty(hex) && token.HasMoreTokens()) hex = token.GetNextToken();
+          wxString uni = token.GetNextToken();
+          // skip whitespace again
+          while (wxIsEmpty(uni) && token.HasMoreTokens()) uni = token.GetNextToken();
+          if ((hex.Len() > 2) && (wxString(hex.GetChar(0)) == escchar) && (hex.GetChar(1) == _T('x')) &&
+              (uni.Left(2) == _T("<U"))) {
+            hex.MakeUpper(); uni.MakeUpper();
+            int pos = ::wxHexToDec(hex.Mid(2,2));
+            if (pos>=0) {
+              unsigned long uni1 = ::wxHexToDec(uni.Mid(2,2));
+              unsigned long uni2 = ::wxHexToDec(uni.Mid(4,2));
+              cset->data[pos] = (uni1 << 16) | uni2;
+              // wxFprintf(stderr,_T("char %02x mapped to %04x (%c)\n"),pos,cset->data[pos],cset->data[pos]);
+            }
+          }
+        }
+      }
+      if (cset) {
+        cset->names.Shrink();
+        wxCharsets.Add(cset);

       }
       }

-      cset->names.Shrink();
-      wxCharsets.Add(cset);
-    forget_it:
-      continue;

     }
   }
 #endif
   wxCharsets.Shrink();
     }
   }
 #endif
   wxCharsets.Shrink();

-  already_loaded = TRUE;

 }
 
 }
 

-static wxCharacterSet *wxFindCharacterSet(const wxString& charset)
+static wxCharacterSet *wxFindCharacterSet(const wxChar *charset)

 {
 {

+  if (!charset) return (wxCharacterSet *)NULL;
+  wxLoadCharacterSets();

   for (size_t n=0; n<wxCharsets.GetCount(); n++)
     if (wxCharsets[n].names.Index(charset) != wxNOT_FOUND)
       return &(wxCharsets[n]);
   return (wxCharacterSet *)NULL;
 }
 
   for (size_t n=0; n<wxCharsets.GetCount(); n++)
     if (wxCharsets[n].names.Index(charset) != wxNOT_FOUND)
       return &(wxCharsets[n]);
   return (wxCharacterSet *)NULL;
 }
 

-WXDLLEXPORT_DATA(wxCSConv) wxConv_local((const wxChar *)NULL);
+WXDLLEXPORT_DATA(wxCSConv) wxConvLocal((const wxChar *)NULL);

 
 wxCSConv::wxCSConv(const wxChar *charset)
 {
 
 wxCSConv::wxCSConv(const wxChar *charset)
 {

-  wxLoadCharacterSets();
-  if (!charset) {
-#ifdef __UNIX__
-    wxChar *lang = wxGetenv(_T("LANG"));
-    wxChar *dot = wxStrchr(lang, _T('.'));
-    if (dot) charset = dot+1;
-#endif
-  }
-  cset = (wxCharacterSet *) NULL;
+  m_name = (wxChar *) NULL;
+  m_cset = (wxCharacterSet *) NULL;
+  m_deferred = TRUE;
+  SetName(charset);
+}

 
 

+wxCSConv::~wxCSConv()
+{
+  if (m_name) free(m_name);
+}
+
+void wxCSConv::SetName(const wxChar *charset)
+{
+  if (charset) {

 #ifdef __UNIX__
 #ifdef __UNIX__

-  // first, convert the character set name to standard form
-  wxString codeset;
-  if (wxString(charset,3) == _T("ISO")) {
-    // make sure it's represented in the standard form: ISO_8859-1
-    codeset = _T("ISO_");
-    charset += 3;
-    if ((*charset == _T('-')) || (*charset == _T('_'))) charset++;
-    if (wxStrlen(charset)>4) {
-      if (wxString(charset,4) == _T("8859")) {
-       codeset << _T("8859-");
-       if (*charset == _T('-')) charset++;
+    // first, convert the character set name to standard form
+    wxString codeset;
+    if (wxString(charset,3).CmpNoCase(_T("ISO")) == 0) {
+      // make sure it's represented in the standard form: ISO_8859-1
+      codeset = _T("ISO_");
+      charset += 3;
+      if ((*charset == _T('-')) || (*charset == _T('_'))) charset++;
+      if (wxStrlen(charset)>4) {
+        if (wxString(charset,4) == _T("8859")) {
+          codeset << _T("8859-");
+          if (*charset == _T('-')) charset++;
+        }

       }
     }
       }
     }

-  }
-  codeset << charset;
-  codeset.MakeUpper();
-  cset = wxFindCharacterSet(codeset);
+    codeset << charset;
+    codeset.MakeUpper();
+    m_name = wxStrdup(codeset.c_str());
+    m_deferred = TRUE;

 #endif
 #endif

+  }

 }
 
 }
 

-wxCSConv::~wxCSConv(void)
+void wxCSConv::LoadNow()

 {
 {

+//  wxPrintf(_T("Conversion request\n"));
+  if (m_deferred) {
+    if (!m_name) {
+#ifdef __UNIX__
+      wxChar *lang = wxGetenv(_T("LANG"));
+      wxChar *dot = lang ? wxStrchr(lang, _T('.')) : (wxChar *)NULL;
+      if (dot) SetName(dot+1);
+#endif
+    }
+    m_cset = wxFindCharacterSet(m_name);
+    m_deferred = FALSE;
+  }

 }
 
 size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {
 }
 
 size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
 {

+  ((wxCSConv *)this)->LoadNow(); // discard constness

   if (buf) {
   if (buf) {

-    if (cset) {
-      for (size_t c=0; c<=n; c++)
-       buf[c] = cset->data[psz[c]];
+    if (m_cset) {
+      for (size_t c=0; c<n; c++)
+        buf[c] = m_cset->data[(unsigned char)(psz[c])];

     } else {
       // latin-1 (direct)
     } else {
       // latin-1 (direct)

-      for (size_t c=0; c<=n; c++)
-       buf[c] = psz[c];
+      for (size_t c=0; c<n; c++)
+        buf[c] = (unsigned char)(psz[c]);

     }
     }

+    return n;

   }
   }

-  return n;
+  return strlen(psz);

 }
 
 size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 {
 }
 
 size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 {

+  ((wxCSConv *)this)->LoadNow(); // discard constness

   if (buf) {
   if (buf) {

-    if (cset) {
-      for (size_t c=0; c<=n; c++) {
-       size_t n;
-       for (n=0; (n<256) && (cset->data[n] != psz[c]); n++);
-       buf[c] = (n>0xff) ? '?' : n;
+    if (m_cset) {
+      for (size_t c=0; c<n; c++) {
+        size_t n;
+        for (n=0; (n<256) && (m_cset->data[n] != psz[c]); n++);
+        buf[c] = (n>0xff) ? '?' : n;

       }
     } else {
       // latin-1 (direct)
       }
     } else {
       // latin-1 (direct)

-      for (size_t c=0; c<=n; c++)
-       buf[c] = (psz[c]>0xff) ? '?' : psz[c];
+      for (size_t c=0; c<n; c++)
+        buf[c] = (psz[c]>0xff) ? '?' : psz[c];

     }
     }

+    return n;

   }
   }

-  return n;
+  return wcslen(psz);

 }
 
 }
 

+#endif//wxUSE_WCHAR_T
+
+#if wxUSE_WCHAR_T
+const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
+    {
+      if (psz) {
+        size_t nLen = MB2WC((wchar_t *) NULL, psz, 0);
+        wxWCharBuffer buf(nLen);
+        MB2WC(WCSTRINGCAST buf, psz, nLen);
+        return buf;
+      } else return wxWCharBuffer((wchar_t *) NULL);
+    }
+
+const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *psz) const
+    {
+      if (psz) {
+        size_t nLen = WC2MB((char *) NULL, psz, 0);
+        wxCharBuffer buf(nLen);
+        WC2MB(MBSTRINGCAST buf, psz, nLen);
+        return buf;
+      } else return wxCharBuffer((char *) NULL);
+    }
+
+#endif//wxUSE_WCHAR_T
+