X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ba555d51b00e2acf5d148b6445206556853ef5f3..ae8f57691329af997e274a3fce5b25c5e5f00f2f:/src/common/string.cpp

diff --git a/src/common/string.cpp b/src/common/string.cpp
index d0676caa7f..b7221a429a 100644
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -56,6 +56,11 @@
   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!
@@ -89,6 +94,13 @@ extern const wxChar WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
 // 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.
@@ -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__)
- 	    #warning "Using sprintf() because no snprintf()-like function defined"
+             #warning "Using sprintf() because no snprintf()-like function defined"
     #endif //compiler
 #endif // no vsnprintf
 
@@ -126,7 +138,7 @@ extern const wxChar WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
 // 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.
@@ -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
-
-  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!
-  if (nLen > nLength)
+  if ((nLen != (size_t)-1) && (nLen > nLength))
     nLen = nLength;
 
   // empty?
-  if ( nLen != 0 ) {
+  if ( (nLen != 0) && (nLen != (size_t)-1) ) {
     AllocBuffer(nLen);
     conv.MB2WC(m_pchData, psz, nLen);
   }
@@ -275,15 +286,15 @@ wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
 
 #else
 
+#if wxUSE_WCHAR_T
 // 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?
-  if ( nLen != 0 ) {
+  if ( (nLen != 0) && (nLen != (size_t)-1) ) {
     AllocBuffer(nLen);
     wxWC2MB(m_pchData, pwz, nLen);
   }
@@ -291,6 +302,7 @@ wxString::wxString(const wchar_t *pwz)
     Init();
   }
 }
+#endif
 
 #endif
 
@@ -497,12 +509,14 @@ wxString& wxString::operator=(const unsigned char* psz)
   return *this;
 }
 
+#if wxUSE_WCHAR_T
 wxString& wxString::operator=(const wchar_t *pwz)
 {
   wxString str(pwz);
   *this = str;
   return *this;
 }
+#endif
 
 #endif
 
@@ -850,8 +864,8 @@ wxString& wxString::MakeLower()
 wxString& wxString::Trim(bool bFromRight)
 {
   // first check if we're going to modify the string at all
-  if ( !IsEmpty() && 
-       ( 
+  if ( !IsEmpty() &&
+       (
         (bFromRight && wxIsspace(GetChar(Len() - 1))) ||
         (!bFromRight && wxIsspace(GetChar(0u)))
        )
@@ -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
-  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
+#endif
 
-#if 1 // the new implementation
+#if wxUSE_EXPERIMENTAL_PRINTF
+// the new implementation
 
   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,
-	   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; }
-	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
-	    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
-	    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
-	  }
-	  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
-	    // 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
-	    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
-	    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];
@@ -1408,7 +1425,7 @@ size_t wxString::rfind(const wxString& str, size_t nStart) const
   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 )
@@ -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
 {
-  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
 {
-  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
 
+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'
@@ -1556,7 +1685,12 @@ void wxArrayString::Grow()
     else {
       // otherwise when it's called for the first time, nIncrement would be 0
       // and the array would never be expanded
+#if defined(__VISAGECPP__)
+      int                           array_size = ARRAY_DEFAULT_INITIAL_SIZE;
+      wxASSERT( array_size != 0 );
+#else
       wxASSERT( ARRAY_DEFAULT_INITIAL_SIZE != 0 );
+#endif
 
       // add 50% but not too much
       size_t nIncrement = m_nSize < ARRAY_DEFAULT_INITIAL_SIZE
@@ -1627,6 +1761,21 @@ void wxArrayString::Alloc(size_t nSize)
   m_nCount = 0;
 }
 
+// minimizes the memory usage by freeing unused memory
+void wxArrayString::Shrink()
+{
+  // only do it if we have some memory to free
+  if( m_nCount < m_nSize ) {
+    // allocates exactly as much memory as we need
+    wxChar **pNew = new wxChar *[m_nCount];
+
+    // copy data to new location
+    memcpy(pNew, m_pItems, m_nCount*sizeof(wxChar *));
+    delete [] m_pItems;
+    m_pItems = pNew;
+  }
+}
+
 // searches the array for an item (forward or backwards)
 int wxArrayString::Index(const wxChar *sz, bool bCase, bool bFromEnd) const
 {
@@ -1736,7 +1885,7 @@ static wxArrayString::CompareFunction gs_compareFunction = NULL;
 static bool gs_sortAscending = TRUE;
 
 // function which is called by quick sort
-static int wxStringCompareFunction(const void *first, const void *second)
+static int LINKAGEMODE wxStringCompareFunction(const void *first, const void *second)
 {
   wxString *strFirst = (wxString *)first;
   wxString *strSecond = (wxString *)second;
@@ -1784,142 +1933,3 @@ void wxArrayString::DoSort()
   qsort(m_pItems, m_nCount, sizeof(wxChar *), wxStringCompareFunction);
 }
 
-// ============================================================================
-// MBConv
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// standard libc conversion
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv) wxConv_libc;
-
-size_t wxMBConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
-  return wxMB2WC(buf, psz, n);
-}
-
-size_t wxMBConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
-  return wxWC2MB(buf, psz, n);
-}
-
-// ----------------------------------------------------------------------------
-// standard file conversion
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv_file) wxConv_file;
-
-// just use the libc conversion for now
-size_t wxMBConv_file::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
-  return wxMB2WC(buf, psz, n);
-}
-
-size_t wxMBConv_file::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
-  return wxWC2MB(buf, psz, n);
-}
-
-// ----------------------------------------------------------------------------
-// standard gdk conversion
-// ----------------------------------------------------------------------------
-
-#ifdef __WXGTK__
-WXDLLEXPORT_DATA(wxMBConv_gdk) wxConv_gdk;
-
-#include <gdk/gdk.h>
-
-size_t wxMBConv_gdk::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
-  if (buf) {
-    return gdk_mbstowcs((GdkWChar *)buf, psz, n);
-  } else {
-    GdkWChar *nbuf = new GdkWChar[n=strlen(psz)];
-    size_t len = gdk_mbstowcs(nbuf, psz, n);
-    delete [] nbuf;
-    return len;
-  }
-}
-
-size_t wxMBConv_gdk::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
-  char *mbstr = gdk_wcstombs((GdkWChar *)psz);
-  size_t len = mbstr ? strlen(mbstr) : 0;
-  if (buf) {
-    if (len > n) len = n;
-    memcpy(buf, psz, len);
-    if (len < n) buf[len] = 0;
-  }
-  return len;
-}
-#endif
-
-// ----------------------------------------------------------------------------
-// UTF-7
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv_UTF7) wxConv_UTF7;
-
-// TODO: write actual implementations of UTF-7 here
-size_t wxMBConv_UTF7::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
-  return 0;
-}
-
-size_t wxMBConv_UTF7::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
-  return 0;
-}
-
-// ----------------------------------------------------------------------------
-// UTF-8
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(wxMBConv_UTF8) wxConv_UTF8;
-
-// TODO: write actual implementations of UTF-8 here
-size_t wxMBConv_UTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
-  return wxMB2WC(buf, psz, n);
-}
-
-size_t wxMBConv_UTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
-  return wxWC2MB(buf, psz, n);
-}
-
-// ----------------------------------------------------------------------------
-// specified character set
-// ----------------------------------------------------------------------------
-
-// TODO: write actual implementation of character set conversion here
-wxCSConv::wxCSConv(const wxChar *charset)
-{
-  data = (wxChar *) NULL;
-}
-
-wxCSConv::~wxCSConv(void)
-{
-}
-
-size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
-{
-  if (buf && !data) {
-    // latin-1 (direct)
-    for (size_t c=0; c<=n; c++)
-      buf[c] = psz[c];
-  }
-  return n;
-}
-
-size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
-{
-  if (buf && !data) {
-    // latin-1 (direct)
-    for (size_t c=0; c<=n; c++)
-      buf[c] = (psz[c]>0xff) ? '?' : psz[c];
-  }
-  return n;
-}
-