more 2.0b9 updates

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

diff --git a/src/common/string.cpp b/src/common/string.cpp
index 9b9cc89f0f6bc4d570282b819726dd6536cb5ee3..7ebd31772944227db30811f093417f5c22d934b0 100644 (file)
--- a/src/common/string.cpp
+++ b/src/common/string.cpp
@@ -259,11 +259,11 @@ wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
   size_t nLen = psz ? conv.MB2WC((wchar_t *) NULL, psz, 0) : 0;
 
   // nLength is number of *Unicode* characters here!
   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?
     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);
   }


@@ -281,7 +281,7 @@ wxString::wxString(const wchar_t *pwz)
   size_t nLen = pwz ? wxWC2MB((char *) NULL, pwz, 0) : 0;
 
   // empty?
   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);
   }
     AllocBuffer(nLen);
     wxWC2MB(m_pchData, pwz, nLen);
   }


@@ -1164,7 +1164,7 @@ int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
            char *val = va_arg(argptr, char *);
 #if wxUSE_UNICODE
            // ASCII->Unicode constructor handles max_width right
            char *val = va_arg(argptr, char *);
 #if wxUSE_UNICODE
            // ASCII->Unicode constructor handles max_width right

-           wxString s(val, wxConv_libc, max_width);
+           wxString s(val, wxConvLibc, max_width);

 #else
            size_t len = wxSTRING_MAXLEN;
            if (val) {
 #else
            size_t len = wxSTRING_MAXLEN;
            if (val) {


@@ -1801,13 +1801,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
 {


@@ -1823,15 +1828,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);
 }


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

-#if defined(__WXGTK__) && (GTK_MINOR_VERSION > 0)
-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);


@@ -1857,7 +1862,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;


@@ -1874,15 +1879,25 @@ size_t wxMBConv_gdk::WC2MB(char *buf, const wchar_t *psz, size_t n) const
 // 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 *buf, const char *psz, size_t 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 *buf, const wchar_t *psz, size_t n) const

 {
   return 0;
 }
 {
   return 0;
 }


@@ -1891,17 +1906,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,6 +2007,7 @@ static void wxLoadCharacterSets(void)
 
   if (already_loaded) return;
 
 
   if (already_loaded) return;
 

+  already_loaded = TRUE;

 #if defined(__UNIX__)
   // search through files in /usr/share/i18n/charmaps
   wxString fname;
 #if defined(__UNIX__)
   // search through files in /usr/share/i18n/charmaps
   wxString fname;


@@ -1957,12 +2030,8 @@ static void wxLoadCharacterSets(void)
        wxStringTokenizer token(line);
        wxString cmd = token.GetNextToken();
        if (cmd == comchar) {
        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);
-         }
+         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("<code_set_name>"))
          cset->names.Add(token.GetNextToken());


@@ -1993,7 +2062,7 @@ static void wxLoadCharacterSets(void)
          // skip whitespace again
          while (wxIsEmpty(uni) && token.HasMoreTokens()) uni = token.GetNextToken();
 
          // skip whitespace again
          while (wxIsEmpty(uni) && token.HasMoreTokens()) uni = token.GetNextToken();
 

-         if ((hex.GetChar(0) == escchar) && (hex.GetChar(1) == _T('x')) &&
+         if ((hex.Len() > 2) && (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));
              (uni.Left(2) == _T("<U"))) {
            hex.MakeUpper(); uni.MakeUpper();
            int pos = ::wxHexToDec(hex.Mid(2,2));


@@ -2014,7 +2083,6 @@ static void wxLoadCharacterSets(void)
   }
 #endif
   wxCharsets.Shrink();
   }
 #endif
   wxCharsets.Shrink();

-  already_loaded = TRUE;

 }
 
 static wxCharacterSet *wxFindCharacterSet(const wxChar *charset)
 }
 
 static wxCharacterSet *wxFindCharacterSet(const wxChar *charset)


@@ -2027,7 +2095,7 @@ static wxCharacterSet *wxFindCharacterSet(const wxChar *charset)
   return (wxCharacterSet *)NULL;
 }
 
   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)
 {


@@ -2089,15 +2157,16 @@ size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
   ((wxCSConv *)this)->LoadNow(); // discard constness
   if (buf) {
     if (m_cset) {
   ((wxCSConv *)this)->LoadNow(); // discard constness
   if (buf) {
     if (m_cset) {

-      for (size_t c=0; c<=n; c++)
-       buf[c] = m_cset->data[psz[c]];
+      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


@@ -2105,17 +2174,19 @@ size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
   ((wxCSConv *)this)->LoadNow(); // discard constness
   if (buf) {
     if (m_cset) {
   ((wxCSConv *)this)->LoadNow(); // discard constness
   if (buf) {
     if (m_cset) {

-      for (size_t c=0; c<=n; c++) {
+      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)
        size_t n;
        for (n=0; (n<256) && (m_cset->data[n] != psz[c]); n++);
        buf[c] = (n>0xff) ? '?' : n;
       }
     } else {
       // latin-1 (direct)

-      for (size_t c=0; c<=n; c++)
+      for (size_t c=0; c<n; c++)

        buf[c] = (psz[c]>0xff) ? '?' : psz[c];
     }
        buf[c] = (psz[c]>0xff) ? '?' : psz[c];
     }

+    return n;

   }
   }

-  return n;
+  return wcslen(psz);

 }
 
 }
 

+#endif//wxUSE_WCHAR_T