#include "wx/strconv.h"
-#if wxUSE_WCHAR_T
-
#ifndef __WXWINCE__
#include <errno.h>
#endif
const size_t lenNul = GetMBNulLen();
for ( const wchar_t * const srcEnd = src + srcLen;
src < srcEnd;
- src += wxWcslen(src) + 1 /* skip L'\0' too */ )
+ src++ /* skip L'\0' too */ )
{
// try to convert the current chunk
size_t lenChunk = WC2MB(NULL, src, 0);
-
if ( lenChunk == wxCONV_FAILED )
return wxCONV_FAILED;
dstWritten += lenChunk;
- if ( src + lenChunk < srcEnd || isNulTerminated )
+
+ const wchar_t * const
+ chunkEnd = isNulTerminated ? srcEnd - 1 : src + wxWcslen(src);
+
+ // our return value accounts for the trailing NUL(s), unlike that of
+ // WC2MB(), however don't do it for the last NUL we artificially added
+ // ourselves above
+ if ( chunkEnd < srcEnd )
dstWritten += lenNul;
if ( dst )
if ( dstWritten > dstLen )
return wxCONV_FAILED;
- if ( WC2MB(dst, src, lenChunk + lenNul) == wxCONV_FAILED )
+ // if we know that there is enough space in the destination buffer
+ // (because we accounted for lenNul in dstWritten above), we can
+ // convert directly in place -- but otherwise we need another
+ // temporary buffer to ensure that we don't overwrite the output
+ wxCharBuffer dstBuf;
+ char *dstTmp;
+ if ( chunkEnd == srcEnd )
+ {
+ dstBuf = wxCharBuffer(lenChunk + lenNul - 1);
+ dstTmp = dstBuf.data();
+ }
+ else
+ {
+ dstTmp = dst;
+ }
+
+ if ( WC2MB(dstTmp, src, lenChunk + lenNul) == wxCONV_FAILED )
return wxCONV_FAILED;
+ if ( dstTmp != dst )
+ {
+ // copy everything up to but excluding the terminating NUL(s)
+ // into the real output buffer
+ memcpy(dst, dstTmp, lenChunk);
+
+ // micro-optimization: if dstTmp != dst it means that chunkEnd
+ // == srcEnd and so we're done, no need to update anything below
+ break;
+ }
+
dst += lenChunk;
- if ( src + lenChunk < srcEnd || isNulTerminated )
+ if ( chunkEnd < srcEnd )
dst += lenNul;
}
+
+ src = chunkEnd;
}
return dstWritten;
}
}
- return wxWCharBuffer();
+ return wxScopedWCharBuffer::CreateNonOwned(L"", 0);
}
const wxCharBuffer wxMBConv::cWC2MB(const wxScopedWCharBuffer& wbuf) const
}
}
- return wxCharBuffer();
+ return wxScopedCharBuffer::CreateNonOwned("", 0);
}
// ----------------------------------------------------------------------------
virtual wxMBConv *Clone() const
{
- wxMBConv_iconv *p = new wxMBConv_iconv(m_name.ToAscii());
+ wxMBConv_iconv *p = new wxMBConv_iconv(m_name);
p->m_minMBCharWidth = m_minMBCharWidth;
return p;
}
// name of the encoding handled by this conversion
- wxString m_name;
+ const char *m_name;
// cached result of GetMBNulLen(); set to 0 meaning "unknown"
// initially
bool wxMBConv_iconv::ms_wcNeedsSwap = false;
wxMBConv_iconv::wxMBConv_iconv(const char *name)
- : m_name(name)
+ : m_name(wxStrdup(name))
{
m_minMBCharWidth = 0;
wxMBConv_iconv::~wxMBConv_iconv()
{
+ free(const_cast<char *>(m_name));
+
if ( m2w != ICONV_T_INVALID )
iconv_close(m2w);
if ( w2m != ICONV_T_INVALID )
{
m_name = NULL;
m_convReal = NULL;
- m_deferred = true;
+}
+
+void wxCSConv::SetEncoding(wxFontEncoding encoding)
+{
+ switch ( encoding )
+ {
+ case wxFONTENCODING_MAX:
+ case wxFONTENCODING_SYSTEM:
+ if ( m_name )
+ {
+ // It's ok to not have encoding value if we have a name for it.
+ m_encoding = wxFONTENCODING_SYSTEM;
+ }
+ else // No name neither.
+ {
+ // Fall back to the system default encoding in this case (not
+ // sure how much sense does this make but this is how the old
+ // code used to behave).
+#if wxUSE_INTL
+ m_encoding = wxLocale::GetSystemEncoding();
+ if ( m_encoding == wxFONTENCODING_SYSTEM )
+#endif // wxUSE_INTL
+ m_encoding = wxFONTENCODING_ISO8859_1;
+ }
+ break;
+
+ case wxFONTENCODING_DEFAULT:
+ // wxFONTENCODING_DEFAULT is same as US-ASCII in this context
+ m_encoding = wxFONTENCODING_ISO8859_1;
+ break;
+
+ default:
+ // Just use the provided encoding.
+ m_encoding = encoding;
+ }
}
wxCSConv::wxCSConv(const wxString& charset)
}
#if wxUSE_FONTMAP
- m_encoding = wxFontMapperBase::GetEncodingFromName(charset);
- if ( m_encoding == wxFONTENCODING_MAX )
- {
- // set to unknown/invalid value
- m_encoding = wxFONTENCODING_SYSTEM;
- }
- else if ( m_encoding == wxFONTENCODING_DEFAULT )
- {
- // wxFONTENCODING_DEFAULT is same as US-ASCII in this context
- m_encoding = wxFONTENCODING_ISO8859_1;
- }
+ SetEncoding(wxFontMapperBase::GetEncodingFromName(charset));
#else
- m_encoding = wxFONTENCODING_SYSTEM;
+ SetEncoding(wxFONTENCODING_SYSTEM);
#endif
+
+ m_convReal = DoCreate();
}
wxCSConv::wxCSConv(wxFontEncoding encoding)
Init();
- m_encoding = encoding;
+ SetEncoding(encoding);
+
+ m_convReal = DoCreate();
}
wxCSConv::~wxCSConv()
Init();
SetName(conv.m_name);
- m_encoding = conv.m_encoding;
+ SetEncoding(conv.m_encoding);
+
+ m_convReal = DoCreate();
}
wxCSConv& wxCSConv::operator=(const wxCSConv& conv)
Clear();
SetName(conv.m_name);
- m_encoding = conv.m_encoding;
+ SetEncoding(conv.m_encoding);
+
+ m_convReal = DoCreate();
return *this;
}
void wxCSConv::Clear()
{
free(m_name);
- delete m_convReal;
-
m_name = NULL;
- m_convReal = NULL;
+
+ wxDELETE(m_convReal);
}
void wxCSConv::SetName(const char *charset)
{
- if (charset)
- {
+ if ( charset )
m_name = wxStrdup(charset);
- m_deferred = true;
- }
}
#if wxUSE_FONTMAP
// check for the special case of ASCII or ISO8859-1 charset: as we have
// special knowledge of it anyhow, we don't need to create a special
// conversion object
- if ( m_encoding == wxFONTENCODING_ISO8859_1 ||
- m_encoding == wxFONTENCODING_DEFAULT )
+ if ( m_encoding == wxFONTENCODING_ISO8859_1 )
{
// don't convert at all
return NULL;
return NULL;
}
-void wxCSConv::CreateConvIfNeeded() const
-{
- if ( m_deferred )
- {
- wxCSConv *self = (wxCSConv *)this; // const_cast
-
- // if we don't have neither the name nor the encoding, use the default
- // encoding for this system
- if ( !m_name && m_encoding == wxFONTENCODING_SYSTEM )
- {
-#if wxUSE_INTL
- self->m_encoding = wxLocale::GetSystemEncoding();
-#else
- // fallback to some reasonable default:
- self->m_encoding = wxFONTENCODING_ISO8859_1;
-#endif // wxUSE_INTL
- }
-
- self->m_convReal = DoCreate();
- self->m_deferred = false;
- }
-}
-
bool wxCSConv::IsOk() const
{
- CreateConvIfNeeded();
-
// special case: no convReal created for wxFONTENCODING_ISO8859_1
if ( m_encoding == wxFONTENCODING_ISO8859_1 )
return true; // always ok as we do it ourselves
size_t wxCSConv::ToWChar(wchar_t *dst, size_t dstLen,
const char *src, size_t srcLen) const
{
- CreateConvIfNeeded();
-
if (m_convReal)
return m_convReal->ToWChar(dst, dstLen, src, srcLen);
size_t wxCSConv::FromWChar(char *dst, size_t dstLen,
const wchar_t *src, size_t srcLen) const
{
- CreateConvIfNeeded();
-
if (m_convReal)
return m_convReal->FromWChar(dst, dstLen, src, srcLen);
size_t wxCSConv::GetMBNulLen() const
{
- CreateConvIfNeeded();
-
if ( m_convReal )
- {
return m_convReal->GetMBNulLen();
- }
// otherwise, we are ISO-8859-1
return 1;
#if wxUSE_UNICODE_UTF8
bool wxCSConv::IsUTF8() const
{
- CreateConvIfNeeded();
-
if ( m_convReal )
- {
return m_convReal->IsUTF8();
- }
// otherwise, we are ISO-8859-1
return false;
WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvUI = wxGet_wxConvLocalPtr();
#ifdef __DARWIN__
-// The xnu kernel always communicates file paths in decomposed UTF-8.
-// WARNING: Are we sure that CFString's conversion will cause decomposition?
+// It is important to use this conversion object under Darwin as it ensures
+// that Unicode strings are (re)composed correctly even though xnu kernel uses
+// decomposed form internally (at least for the file names).
static wxMBConv_cf wxConvMacUTF8DObj(wxFONTENCODING_UTF8);
#endif
#else // !__DARWIN__
wxGet_wxConvLibcPtr();
#endif // __DARWIN__/!__DARWIN__
-
-#else // !wxUSE_WCHAR_T
-
-// FIXME-UTF8: remove this, wxUSE_WCHAR_T is required now
-// stand-ins in absence of wchar_t
-WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
- wxConvISO8859_1,
- wxConvLocal,
- wxConvUTF8;
-
-#endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
projects / wxWidgets.git / blobdiff