]>
git.saurik.com Git - wxWidgets.git/blob - src/common/strconv.cpp
a7db44b730d07506228f03468ec257e8164289dc
1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Unicode conversion classes
4 // Author: Ove Kaaven, Robert Roebling, Vadim Zeitlin, Vaclav Slavik
8 // Copyright: (c) 1999 Ove Kaaven, Robert Roebling, Vadim Zeitlin, Vaclav Slavik
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 #pragma implementation "strconv.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
37 #include "wx/msw/private.h"
45 #include "wx/module.h"
46 #include "wx/strconv.h"
48 // ----------------------------------------------------------------------------
50 // ----------------------------------------------------------------------------
53 WXDLLEXPORT_DATA(wxMBConv
) wxConvLibc
;
54 WXDLLEXPORT_DATA(wxCSConv
) wxConvLocal((const wxChar
*)NULL
);
56 // stand-ins in absence of wchar_t
57 WXDLLEXPORT_DATA(wxMBConv
) wxConvLibc
, wxConvFile
;
58 #endif // wxUSE_WCHAR_T
60 WXDLLEXPORT_DATA(wxMBConv
*) wxConvCurrent
= &wxConvLibc
;
62 class wxStrConvModule
: public wxModule
65 wxStrConvModule() : wxModule() { }
66 virtual bool OnInit() { return TRUE
; }
74 DECLARE_DYNAMIC_CLASS(wxStrConvModule
)
77 IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule
, wxModule
)
80 // ----------------------------------------------------------------------------
82 // ----------------------------------------------------------------------------
94 #include "wx/encconv.h"
95 #include "wx/fontmap.h"
97 // ----------------------------------------------------------------------------
99 // ----------------------------------------------------------------------------
101 #define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); }
102 #define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); }
104 // under Unix SIZEOF_WCHAR_T is defined by configure, but under other platforms
105 // it might be not defined - assume the most common value
106 #ifndef SIZEOF_WCHAR_T
107 #define SIZEOF_WCHAR_T 2
108 #endif // !defined(SIZEOF_WCHAR_T)
110 #if SIZEOF_WCHAR_T == 4
111 #define WC_NAME "UCS4"
112 #define WC_BSWAP BSWAP_UCS4
113 #ifdef WORDS_BIGENDIAN
114 #define WC_NAME_BEST "UCS-4BE"
116 #define WC_NAME_BEST "UCS-4LE"
118 #elif SIZEOF_WCHAR_T == 2
119 #define WC_NAME "UTF16"
120 #define WC_BSWAP BSWAP_UTF16
122 #ifdef WORDS_BIGENDIAN
123 #define WC_NAME_BEST "UTF-16BE"
125 #define WC_NAME_BEST "UTF-16LE"
127 #else // sizeof(wchar_t) != 2 nor 4
128 // I don't know what to do about this
129 #error "Weird sizeof(wchar_t): please report your platform details to wx-users mailing list"
132 // ============================================================================
134 // ============================================================================
136 // ----------------------------------------------------------------------------
137 // UTF-16 en/decoding
138 // ----------------------------------------------------------------------------
142 static size_t encode_utf16(wxUint32 input
, wchar_t *output
)
146 if (output
) *output
++ = (wchar_t) input
;
149 else if (input
>=0x110000)
157 *output
++ = (wchar_t) ((input
>> 10)+0xd7c0);
158 *output
++ = (wchar_t) ((input
&0x3ff)+0xdc00);
164 static size_t decode_utf16(const wchar_t* input
, wxUint32
& output
)
166 if ((*input
<0xd800) || (*input
>0xdfff))
171 else if ((input
[1]<0xdc00) || (input
[1]>=0xdfff))
178 output
= ((input
[0] - 0xd7c0) << 10) + (input
[1] - 0xdc00);
185 // ----------------------------------------------------------------------------
187 // ----------------------------------------------------------------------------
189 #define IGNORE_LIBC 0
191 size_t wxMBConv::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
196 for (size_t i
= 0; i
< strlen( psz
)+1; i
++)
197 buf
[i
] = (wchar_t) psz
[i
];
198 // printf( "libc %s\n", buf );
199 return strlen( psz
);
203 return strlen( psz
);
206 return wxMB2WC(buf
, psz
, n
);
210 size_t wxMBConv::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
215 for (size_t i
= 0; i
< wxStrlen( psz
)+1; i
++)
216 buf
[i
] = (char) psz
[i
];
217 // printf( "libc %s\n", buf );
218 return wxStrlen( psz
);
222 return wxStrlen( psz
);
225 return wxWC2MB(buf
, psz
, n
);
229 const wxWCharBuffer
wxMBConv::cMB2WC(const char *psz
) const
233 size_t nLen
= MB2WC((wchar_t *) NULL
, psz
, 0); // return value excludes /0
234 if (nLen
== (size_t)-1)
235 return wxWCharBuffer((wchar_t *) NULL
);
236 wxWCharBuffer
buf(nLen
); // this allocates nLen1+
237 MB2WC((wchar_t *)(const wchar_t *) buf
, psz
, nLen
+1);
241 return wxWCharBuffer((wchar_t *) NULL
);
244 const wxCharBuffer
wxMBConv::cWC2MB(const wchar_t *psz
) const
248 size_t nLen
= WC2MB((char *) NULL
, psz
, 0); // return value excludes /0
249 if (nLen
== (size_t)-1)
250 return wxCharBuffer((char *) NULL
);
251 wxCharBuffer
buf(nLen
); // this allocates nLen+1
252 WC2MB((char *)(const char *) buf
, psz
, nLen
+1);
253 // printf( "str %s\n", (const char*) buf );
257 return wxCharBuffer((char *) NULL
);
260 // ----------------------------------------------------------------------------
261 // standard gdk conversion
262 // ----------------------------------------------------------------------------
266 WXDLLEXPORT_DATA(wxMBConvGdk
) wxConvGdk
;
270 size_t wxMBConvGdk::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
274 return gdk_mbstowcs((GdkWChar
*)buf
, psz
, n
);
278 GdkWChar
*nbuf
= new GdkWChar
[n
=strlen(psz
)];
279 size_t len
= gdk_mbstowcs(nbuf
, psz
, n
);
285 size_t wxMBConvGdk::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
287 char *mbstr
= gdk_wcstombs((GdkWChar
*)psz
);
288 size_t len
= mbstr
? strlen(mbstr
) : 0;
293 memcpy(buf
, psz
, len
);
302 // ----------------------------------------------------------------------------
304 // ----------------------------------------------------------------------------
306 WXDLLEXPORT_DATA(wxMBConvUTF7
) wxConvUTF7
;
309 static char utf7_setD
[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
310 "abcdefghijklmnopqrstuvwxyz"
311 "0123456789'(),-./:?";
312 static char utf7_setO
[]="!\"#$%&*;<=>@[]^_`{|}";
313 static char utf7_setB
[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
314 "abcdefghijklmnopqrstuvwxyz"
318 // TODO: write actual implementations of UTF-7 here
319 size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf
),
320 const char * WXUNUSED(psz
),
321 size_t WXUNUSED(n
)) const
326 size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf
),
327 const wchar_t * WXUNUSED(psz
),
328 size_t WXUNUSED(n
)) const
333 // ----------------------------------------------------------------------------
335 // ----------------------------------------------------------------------------
337 WXDLLEXPORT_DATA(wxMBConvUTF8
) wxConvUTF8
;
339 static wxUint32 utf8_max
[]=
340 { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
342 size_t wxMBConvUTF8::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
346 while (*psz
&& ((!buf
) || (len
< n
)))
348 unsigned char cc
= *psz
++, fc
= cc
;
350 for (cnt
= 0; fc
& 0x80; cnt
++)
364 // invalid UTF-8 sequence
369 unsigned ocnt
= cnt
- 1;
370 wxUint32 res
= cc
& (0x3f >> cnt
);
374 if ((cc
& 0xC0) != 0x80)
376 // invalid UTF-8 sequence
379 res
= (res
<< 6) | (cc
& 0x3f);
381 if (res
<= utf8_max
[ocnt
])
383 // illegal UTF-8 encoding
387 size_t pa
= encode_utf16(res
, buf
);
388 if (pa
== (size_t)-1)
397 #endif // WC_UTF16/!WC_UTF16
401 if (buf
&& (len
< n
))
406 size_t wxMBConvUTF8::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
410 while (*psz
&& ((!buf
) || (len
< n
)))
414 size_t pa
= decode_utf16(psz
, cc
);
415 psz
+= (pa
== (size_t)-1) ? 1 : pa
;
417 cc
=(*psz
++) & 0x7fffffff;
420 for (cnt
= 0; cc
> utf8_max
[cnt
]; cnt
++) {}
434 *buf
++ = (char) ((-128 >> cnt
) | ((cc
>> (cnt
* 6)) & (0x3f >> cnt
)));
436 *buf
++ = (char) (0x80 | ((cc
>> (cnt
* 6)) & 0x3f));
441 if (buf
&& (len
<n
)) *buf
= 0;
446 // ============================================================================
447 // wxCharacterSet and derived classes
448 // ============================================================================
450 // ----------------------------------------------------------------------------
451 // wxCharacterSet is the ABC for the classes below
452 // ----------------------------------------------------------------------------
457 wxCharacterSet(const wxChar
*name
) : cname(name
) {}
458 virtual ~wxCharacterSet() {}
459 virtual size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
) = 0;
460 virtual size_t WC2MB(char *buf
, const wchar_t *psz
, size_t n
) = 0;
461 virtual bool usable() const = 0;
466 // ----------------------------------------------------------------------------
467 // ID_CharSet: implementation of wxCharacterSet using an existing wxMBConv
468 // ----------------------------------------------------------------------------
470 class ID_CharSet
: public wxCharacterSet
473 ID_CharSet(const wxChar
*name
, wxMBConv
*cnv
)
474 : wxCharacterSet(name
), work(cnv
) {}
476 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
)
477 { return work
? work
->MB2WC(buf
,psz
,n
) : (size_t)-1; }
479 size_t WC2MB(char *buf
, const wchar_t *psz
, size_t n
)
480 { return work
? work
->WC2MB(buf
,psz
,n
) : (size_t)-1; }
483 { return work
!=NULL
; }
489 // ============================================================================
490 // The classes doing conversion using the iconv_xxx() functions
491 // ============================================================================
495 // VS: glibc 2.1.3 is broken in that iconv() conversion to/from UCS4 fails with E2BIG
496 // if output buffer is _exactly_ as big as needed. Such case is (unless there's
497 // yet another bug in glibc) the only case when iconv() returns with (size_t)-1
498 // (which means error) and says there are 0 bytes left in the input buffer --
499 // when _real_ error occurs, bytes-left-in-input buffer is non-zero. Hence,
500 // this alternative test for iconv() failure.
501 // [This bug does not appear in glibc 2.2.]
502 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ <= 1
503 #define ICONV_FAILED(cres, bufLeft) ((cres == (size_t)-1) && \
504 (errno != E2BIG || bufLeft != 0))
506 #define ICONV_FAILED(cres, bufLeft) (cres == (size_t)-1)
509 #define ICONV_CHAR_CAST(x) ((ICONV_CONST char **)(x))
511 // ----------------------------------------------------------------------------
512 // IC_CharSet: encapsulates an iconv character set
513 // ----------------------------------------------------------------------------
515 class IC_CharSet
: public wxCharacterSet
518 IC_CharSet(const wxChar
*name
);
519 virtual ~IC_CharSet();
521 virtual size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
);
522 virtual size_t WC2MB(char *buf
, const wchar_t *psz
, size_t n
);
525 { return (m2w
!= (iconv_t
)-1) && (w2m
!= (iconv_t
)-1); }
528 // the iconv handlers used to translate from multibyte to wide char and in
529 // the other direction
534 // the name (for iconv_open()) of a wide char charset - if none is
535 // available on this machine, it will remain NULL
536 static const char *ms_wcCharsetName
;
538 // true if the wide char encoding we use (i.e. ms_wcCharsetName) has
539 // different endian-ness than the native one
540 static bool ms_wcNeedsSwap
;
543 const char *IC_CharSet::ms_wcCharsetName
= NULL
;
544 bool IC_CharSet::ms_wcNeedsSwap
= FALSE
;
546 IC_CharSet::IC_CharSet(const wxChar
*name
)
547 : wxCharacterSet(name
)
549 // Do it the hard way
551 for (size_t i
= 0; i
< wxStrlen(name
)+1; i
++)
552 cname
[i
] = (char) name
[i
];
554 // check for charset that represents wchar_t:
555 if (ms_wcCharsetName
== NULL
)
557 ms_wcNeedsSwap
= FALSE
;
559 // try charset with explicit bytesex info (e.g. "UCS-4LE"):
560 ms_wcCharsetName
= WC_NAME_BEST
;
561 m2w
= iconv_open(ms_wcCharsetName
, cname
);
563 if (m2w
== (iconv_t
)-1)
565 // try charset w/o bytesex info (e.g. "UCS4")
566 // and check for bytesex ourselves:
567 ms_wcCharsetName
= WC_NAME
;
568 m2w
= iconv_open(ms_wcCharsetName
, cname
);
570 // last bet, try if it knows WCHAR_T pseudo-charset
571 if (m2w
== (iconv_t
)-1)
573 ms_wcCharsetName
= "WCHAR_T";
574 m2w
= iconv_open(ms_wcCharsetName
, cname
);
577 if (m2w
!= (iconv_t
)-1)
579 char buf
[2], *bufPtr
;
580 wchar_t wbuf
[2], *wbufPtr
;
588 outsz
= SIZEOF_WCHAR_T
* 2;
592 res
= iconv(m2w
, ICONV_CHAR_CAST(&bufPtr
), &insz
,
593 (char**)&wbufPtr
, &outsz
);
595 if (ICONV_FAILED(res
, insz
))
597 ms_wcCharsetName
= NULL
;
598 wxLogLastError(wxT("iconv"));
599 wxLogError(_("Convertion to charset '%s' doesn't work."), name
);
603 ms_wcNeedsSwap
= wbuf
[0] != (wchar_t)buf
[0];
608 ms_wcCharsetName
= NULL
;
610 // VS: we must not output an error here, since wxWindows will safely
611 // fall back to using wxEncodingConverter.
612 wxLogTrace(wxT("strconv"), wxT("Impossible to convert to/from charset '%s' with iconv, falling back to wxEncodingConverter."), name
);
616 wxLogTrace(wxT("strconv"), wxT("wchar_t charset is '%s', needs swap: %i"), ms_wcCharsetName
, ms_wcNeedsSwap
);
618 else // we already have ms_wcCharsetName
620 m2w
= iconv_open(ms_wcCharsetName
, cname
);
623 // NB: don't ever pass NULL to iconv_open(), it may crash!
624 if ( ms_wcCharsetName
)
626 w2m
= iconv_open( cname
, ms_wcCharsetName
);
634 IC_CharSet::~IC_CharSet()
636 if ( m2w
!= (iconv_t
)-1 )
638 if ( w2m
!= (iconv_t
)-1 )
642 size_t IC_CharSet::MB2WC(wchar_t *buf
, const char *psz
, size_t n
)
644 size_t inbuf
= strlen(psz
);
645 size_t outbuf
= n
* SIZEOF_WCHAR_T
;
647 // VS: Use these instead of psz, buf because iconv() modifies its arguments:
648 wchar_t *bufPtr
= buf
;
649 const char *pszPtr
= psz
;
653 // have destination buffer, convert there
655 ICONV_CHAR_CAST(&pszPtr
), &inbuf
,
656 (char**)&bufPtr
, &outbuf
);
657 res
= n
- (outbuf
/ SIZEOF_WCHAR_T
);
661 // convert to native endianness
662 WC_BSWAP(buf
/* _not_ bufPtr */, res
)
665 // iconv doesn't seem to set the trailing 0
670 // no destination buffer... convert using temp buffer
671 // to calculate destination buffer requirement
676 outbuf
= 8*SIZEOF_WCHAR_T
;
679 ICONV_CHAR_CAST(&pszPtr
), &inbuf
,
680 (char**)&bufPtr
, &outbuf
);
682 res
+= 8-(outbuf
/SIZEOF_WCHAR_T
);
683 } while ((cres
==(size_t)-1) && (errno
==E2BIG
));
686 if (ICONV_FAILED(cres
, inbuf
))
688 //VS: it is ok if iconv fails, hence trace only
689 wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
696 size_t IC_CharSet::WC2MB(char *buf
, const wchar_t *psz
, size_t n
)
698 #if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
699 size_t inbuf
= std::wcslen(psz
) * SIZEOF_WCHAR_T
;
701 size_t inbuf
= ::wcslen(psz
) * SIZEOF_WCHAR_T
;
710 // need to copy to temp buffer to switch endianness
711 // this absolutely doesn't rock!
712 // (no, doing WC_BSWAP twice on the original buffer won't help, as it
713 // could be in read-only memory, or be accessed in some other thread)
714 tmpbuf
=(wchar_t*)malloc((inbuf
+1)*SIZEOF_WCHAR_T
);
715 memcpy(tmpbuf
,psz
,(inbuf
+1)*SIZEOF_WCHAR_T
);
716 WC_BSWAP(tmpbuf
, inbuf
)
722 // have destination buffer, convert there
723 cres
= iconv( w2m
, ICONV_CHAR_CAST(&psz
), &inbuf
, &buf
, &outbuf
);
727 // iconv() doesn't set the trailing zero, but moves buf to
733 // no destination buffer... convert using temp buffer
734 // to calculate destination buffer requirement
738 buf
= tbuf
; outbuf
= 16;
740 cres
= iconv( w2m
, ICONV_CHAR_CAST(&psz
), &inbuf
, &buf
, &outbuf
);
743 } while ((cres
==(size_t)-1) && (errno
==E2BIG
));
751 if (ICONV_FAILED(cres
, inbuf
))
753 //VS: it is ok if iconv fails, hence trace only
754 wxLogTrace(wxT("strconv"), wxT("iconv failed: %s"), wxSysErrorMsg(wxSysErrorCode()));
763 // ============================================================================
764 // Win32 conversion classes
765 // ============================================================================
767 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
769 extern long wxCharsetToCodepage(const wxChar
*charset
); // from utils.cpp
771 class CP_CharSet
: public wxCharacterSet
774 CP_CharSet(const wxChar
* name
)
775 : wxCharacterSet(name
)
777 m_CodePage
= wxCharsetToCodepage(name
);
780 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t n
)
783 MultiByteToWideChar(m_CodePage
, 0, psz
, -1, buf
, buf
? n
: 0);
784 //VS: returns # of written chars for buf!=NULL and *size*
785 // needed buffer for buf==NULL
786 return len
? (buf
? len
: len
-1) : (size_t)-1;
789 size_t WC2MB(char *buf
, const wchar_t *psz
, size_t n
)
791 size_t len
= WideCharToMultiByte(m_CodePage
, 0, psz
, -1, buf
,
792 buf
? n
: 0, NULL
, NULL
);
793 //VS: returns # of written chars for buf!=NULL and *size*
794 // needed buffer for buf==NULL
795 return len
? (buf
? len
: len
-1) : (size_t)-1;
799 { return m_CodePage
!= -1; }
806 // ============================================================================
807 // wxEncodingConverter based conversion classes
808 // ============================================================================
812 class EC_CharSet
: public wxCharacterSet
815 // temporarily just use wxEncodingConverter stuff,
816 // so that it works while a better implementation is built
817 EC_CharSet(const wxChar
* name
) : wxCharacterSet(name
),
818 enc(wxFONTENCODING_SYSTEM
)
821 enc
= wxFontMapper::Get()->CharsetToEncoding(name
, FALSE
);
823 m_ok
= m2w
.Init(enc
, wxFONTENCODING_UNICODE
) &&
824 w2m
.Init(wxFONTENCODING_UNICODE
, enc
);
827 size_t MB2WC(wchar_t *buf
, const char *psz
, size_t WXUNUSED(n
))
829 size_t inbuf
= strlen(psz
);
831 m2w
.Convert(psz
,buf
);
835 size_t WC2MB(char *buf
, const wchar_t *psz
, size_t WXUNUSED(n
))
837 #if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
838 || ( defined(__MWERKS__) && defined(__WXMSW__) )
839 size_t inbuf
= std::wcslen(psz
);
841 size_t inbuf
= ::wcslen(psz
);
844 w2m
.Convert(psz
,buf
);
849 bool usable() const { return m_ok
; }
853 wxEncodingConverter m2w
, w2m
;
855 // were we initialized successfully?
859 #endif // wxUSE_FONTMAP
861 // ----------------------------------------------------------------------------
862 // the function creating the wxCharacterSet for the specified charset on the
863 // current system, trying all possibilities
864 // ----------------------------------------------------------------------------
866 static wxCharacterSet
*wxGetCharacterSet(const wxChar
*name
)
868 // check for the special case of ASCII charset
870 if ( wxFontMapper::Get()->CharsetToEncoding(name
) == wxFONTENCODING_DEFAULT
)
871 #else // wxUSE_FONTMAP
873 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
875 // don't convert at all
879 // the test above must have taken care of this case
880 wxCHECK_MSG( name
, NULL
, _T("NULL name must be wxFONTENCODING_DEFAULT") );
882 wxCharacterSet
*cset
;
884 if ( wxStricmp(name
, wxT("UTF8")) == 0 || wxStricmp(name
, wxT("UTF-8")) == 0)
886 cset
= new ID_CharSet(name
, &wxConvUTF8
);
891 cset
= new IC_CharSet(name
);
894 #endif // HAVE_ICONV/!HAVE_ICONV
897 // it can only be NULL in this case
900 #endif // !HAVE_ICONV
902 if ( cset
->usable() )
909 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
910 cset
= new CP_CharSet(name
);
911 if ( cset
->usable() )
919 cset
= new EC_CharSet(name
);
920 if ( cset
->usable() )
925 #endif // wxUSE_FONTMAP
927 wxLogError(_("Cannot convert from encoding '%s'!"), name
);
932 // ============================================================================
933 // wxCSConv implementation
934 // ============================================================================
936 wxCSConv::wxCSConv(const wxChar
*charset
)
938 m_name
= (wxChar
*)NULL
;
939 m_cset
= (wxCharacterSet
*) NULL
;
945 wxCSConv::~wxCSConv()
950 wxCSConv::wxCSConv(const wxCSConv
& conv
)
954 SetName(conv
.m_name
);
957 wxCSConv
& wxCSConv::operator=(const wxCSConv
& conv
)
960 SetName(conv
.m_name
);
964 void wxCSConv::Clear()
974 void wxCSConv::SetName(const wxChar
*charset
)
978 m_name
= wxStrdup(charset
);
983 void wxCSConv::LoadNow()
989 wxString name
= wxLocale::GetSystemEncodingName();
996 // wxGetCharacterSet() complains about NULL name
997 m_cset
= m_name
? wxGetCharacterSet(m_name
) : NULL
;
1002 size_t wxCSConv::MB2WC(wchar_t *buf
, const char *psz
, size_t n
) const
1004 ((wxCSConv
*)this)->LoadNow(); // discard constness
1007 return m_cset
->MB2WC(buf
, psz
, n
);
1010 size_t len
= strlen(psz
);
1014 for (size_t c
= 0; c
<= len
; c
++)
1015 buf
[c
] = (unsigned char)(psz
[c
]);
1021 size_t wxCSConv::WC2MB(char *buf
, const wchar_t *psz
, size_t n
) const
1023 ((wxCSConv
*)this)->LoadNow(); // discard constness
1026 return m_cset
->WC2MB(buf
, psz
, n
);
1029 #if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
1030 || ( defined(__MWERKS__) && defined(__WXMSW__) )
1031 size_t len
=std::wcslen(psz
);
1033 size_t len
=::wcslen(psz
);
1037 for (size_t c
= 0; c
<= len
; c
++)
1038 buf
[c
] = (psz
[c
] > 0xff) ? '?' : psz
[c
];
1044 #endif // wxUSE_WCHAR_T