d43088ee78
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@9607 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
697 lines
19 KiB
C++
697 lines
19 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: strconv.cpp
|
|
// Purpose: Unicode conversion classes
|
|
// Author: Ove Kaaven, Robert Roebling, Vadim Zeitlin
|
|
// Modified by:
|
|
// Created: 29/01/98
|
|
// RCS-ID: $Id$
|
|
// Copyright: (c) 1999 Ove Kaaven, Robert Roebling, Vadim Zeitlin
|
|
// Licence: wxWindows license
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// ============================================================================
|
|
// declarations
|
|
// ============================================================================
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// headers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#ifdef __GNUG__
|
|
#pragma implementation "strconv.h"
|
|
#endif
|
|
|
|
// For compilers that support precompilation, includes "wx.h".
|
|
#include "wx/wxprec.h"
|
|
|
|
#ifdef __BORLANDC__
|
|
#pragma hdrstop
|
|
#endif
|
|
|
|
#ifdef __WXMSW__
|
|
#include "wx/msw/private.h"
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifdef __SALFORDC__
|
|
#include <clib.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_ICONV_H
|
|
#include <iconv.h>
|
|
#endif
|
|
#ifdef HAVE_LANGINFO_H
|
|
#include <langinfo.h>
|
|
#endif
|
|
|
|
#ifdef __WXMSW__
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
#include "wx/debug.h"
|
|
#include "wx/strconv.h"
|
|
|
|
#if defined(WORDS_BIGENDIAN) || defined(__STDC_ISO_10646__)
|
|
#define BSWAP_UCS4(str, len)
|
|
#define BSWAP_UCS2(str, len)
|
|
#else
|
|
#define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); }
|
|
#define BSWAP_UCS2(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); }
|
|
#define WC_NEED_BSWAP
|
|
#endif
|
|
#define BSWAP_UTF32(str, len) BSWAP_UCS4(str, len)
|
|
#define BSWAP_UTF16(str, len) BSWAP_UCS2(str, len)
|
|
|
|
#if SIZEOF_WCHAR_T == 4
|
|
#define WC_NAME "UCS4"
|
|
#define WC_BSWAP BSWAP_UCS4
|
|
#elif SIZEOF_WCHAR_T == 2
|
|
#define WC_NAME "UTF16"
|
|
#define WC_BSWAP BSWAP_UTF16
|
|
#define WC_UTF16
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// globals
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WXDLLEXPORT_DATA(wxMBConv *) wxConvCurrent = &wxConvLibc;
|
|
|
|
// ============================================================================
|
|
// implementation
|
|
// ============================================================================
|
|
|
|
#if wxUSE_WCHAR_T
|
|
|
|
#ifdef WC_UTF16
|
|
|
|
static size_t encode_utf16(wxUint32 input,wxUint16*output)
|
|
{
|
|
if (input<=0xffff) {
|
|
if (output) *output++ = input;
|
|
return 1;
|
|
} else
|
|
if (input>=0x110000) {
|
|
return (size_t)-1;
|
|
} else {
|
|
if (output) {
|
|
*output++ = (input >> 10)+0xd7c0;
|
|
*output++ = (input&0x3ff)+0xdc00;
|
|
}
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
static size_t decode_utf16(wxUint16*input,wxUint32&output)
|
|
{
|
|
if ((*input<0xd800) || (*input>0xdfff)) {
|
|
output = *input;
|
|
return 1;
|
|
} else
|
|
if ((input[1]<0xdc00) || (input[1]>=0xdfff)) {
|
|
output = *input;
|
|
return (size_t)-1;
|
|
} else {
|
|
output = ((input[0] - 0xd7c0) << 10) + (input[1] - 0xdc00);
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
#endif // WC_UTF16
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxMBConv
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WXDLLEXPORT_DATA(wxMBConv) wxConvLibc;
|
|
|
|
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);
|
|
}
|
|
|
|
const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
|
|
{
|
|
if (psz)
|
|
{
|
|
size_t nLen = MB2WC((wchar_t *) NULL, psz, 0);
|
|
if (nLen == (size_t)-1)
|
|
return wxWCharBuffer((wchar_t *) NULL);
|
|
wxWCharBuffer buf(nLen);
|
|
MB2WC((wchar_t *)(const wchar_t *) 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);
|
|
if (nLen == (size_t)-1)
|
|
return wxCharBuffer((char *) NULL);
|
|
wxCharBuffer buf(nLen);
|
|
WC2MB((char *)(const char *) buf, psz, nLen);
|
|
return buf;
|
|
}
|
|
else
|
|
return wxCharBuffer((char *) NULL);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// standard file conversion
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WXDLLEXPORT_DATA(wxMBConvFile) wxConvFile;
|
|
|
|
// just use the libc conversion for now
|
|
size_t wxMBConvFile::MB2WC(wchar_t *buf, const char *psz, size_t n) const
|
|
{
|
|
return wxMB2WC(buf, psz, n);
|
|
}
|
|
|
|
size_t wxMBConvFile::WC2MB(char *buf, const wchar_t *psz, size_t n) const
|
|
{
|
|
return wxWC2MB(buf, psz, n);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// standard gdk conversion
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#ifdef __WXGTK12__
|
|
|
|
WXDLLEXPORT_DATA(wxMBConvGdk) wxConvGdk;
|
|
|
|
#include <gdk/gdk.h>
|
|
|
|
size_t wxMBConvGdk::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 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;
|
|
if (buf) {
|
|
if (len > n) len = n;
|
|
memcpy(buf, psz, len);
|
|
if (len < n) buf[len] = 0;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
#endif // GTK > 1.0
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// UTF-7
|
|
// ----------------------------------------------------------------------------
|
|
|
|
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
|
|
size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf),
|
|
const char * WXUNUSED(psz),
|
|
size_t WXUNUSED(n)) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
|
|
const wchar_t * WXUNUSED(psz),
|
|
size_t WXUNUSED(n)) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// UTF-8
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WXDLLEXPORT_DATA(wxMBConvUTF8) wxConvUTF8;
|
|
|
|
static wxUint32 utf8_max[]={0x7f,0x7ff,0xffff,0x1fffff,0x3ffffff,0x7fffffff,0xffffffff};
|
|
|
|
size_t wxMBConvUTF8::MB2WC(wchar_t *buf, const char *psz, size_t n) const
|
|
{
|
|
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;
|
|
wxUint32 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;
|
|
}
|
|
#ifdef WC_UTF16
|
|
size_t pa = encode_utf16(res, buf);
|
|
if (pa == (size_t)-1)
|
|
return (size_t)-1;
|
|
if (buf) buf+=pa;
|
|
len+=pa;
|
|
#else
|
|
if (buf) *buf++=res;
|
|
len++;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
if (buf && (len<n)) *buf = 0;
|
|
return len;
|
|
}
|
|
|
|
size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
|
|
{
|
|
size_t len = 0;
|
|
|
|
while (*psz && ((!buf) || (len<n))) {
|
|
wxUint32 cc;
|
|
#ifdef WC_UTF16
|
|
size_t pa = decode_utf16(psz,cc);
|
|
psz += (pa == (size_t)-1) ? 1 : pa;
|
|
#else
|
|
cc=(*psz++)&0x7fffffff;
|
|
#endif
|
|
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;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// specified character set
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WXDLLEXPORT_DATA(wxCSConv) wxConvLocal((const wxChar *)NULL);
|
|
|
|
#include "wx/encconv.h"
|
|
#include "wx/fontmap.h"
|
|
|
|
// TODO: add some tables here
|
|
// - perhaps common encodings to common codepages (for Win32)
|
|
// - perhaps common encodings to objects ("UTF8" -> wxConvUTF8)
|
|
// - move wxEncodingConverter meat in here
|
|
|
|
#ifdef __WIN32__
|
|
#include "wx/msw/registry.h"
|
|
// this should work if M$ Internet Exploiter is installed
|
|
static long CharsetToCodepage(const wxChar *name)
|
|
{
|
|
if (!name) return GetACP();
|
|
long CP=-1;
|
|
wxString cn(name);
|
|
do {
|
|
wxString path(wxT("MIME\\Database\\Charset\\"));
|
|
path += cn;
|
|
wxRegKey key(wxRegKey::HKCR,path);
|
|
|
|
/* two cases: either there's an AliasForCharset string,
|
|
* or there are Codepage and InternetEncoding dwords.
|
|
* The InternetEncoding gives us the actual encoding,
|
|
* the Codepage just says which Windows character set to
|
|
* use when displaying the data.
|
|
*/
|
|
if (key.QueryValue(wxT("InternetEncoding"),&CP)) break;
|
|
// no encoding, see if it's an alias
|
|
if (!key.QueryValue(wxT("AliasForCharset"),cn)) break;
|
|
} while (1);
|
|
return CP;
|
|
}
|
|
#endif
|
|
|
|
class wxCharacterSet
|
|
{
|
|
public:
|
|
const wxChar*cname;
|
|
wxCharacterSet(const wxChar*name) : cname(name) {}
|
|
virtual ~wxCharacterSet() {}
|
|
virtual size_t MB2WC(wchar_t*buf, const char*psz, size_t n) { return (size_t)-1; }
|
|
virtual size_t WC2MB(char*buf, const wchar_t*psz, size_t n) { return (size_t)-1; }
|
|
virtual bool usable() { return FALSE; }
|
|
};
|
|
|
|
class ID_CharSet : public wxCharacterSet
|
|
{
|
|
public:
|
|
wxMBConv*work;
|
|
ID_CharSet(const wxChar*name,wxMBConv*cnv) : wxCharacterSet(name), work(cnv) {}
|
|
size_t MB2WC(wchar_t*buf, const char*psz, size_t n)
|
|
{ return work ? work->MB2WC(buf,psz,n) : (size_t)-1; }
|
|
size_t WC2MB(char*buf, const wchar_t*psz, size_t n)
|
|
{ return work ? work->WC2MB(buf,psz,n) : (size_t)-1; }
|
|
bool usable() { return work!=NULL; }
|
|
};
|
|
|
|
#ifdef HAVE_ICONV_H
|
|
class IC_CharSet : public wxCharacterSet
|
|
{
|
|
public:
|
|
iconv_t m2w, w2m;
|
|
IC_CharSet(const wxChar*name) : wxCharacterSet(name), m2w((iconv_t)-1), w2m((iconv_t)-1) {}
|
|
~IC_CharSet() {
|
|
if (m2w!=(iconv_t)-1) iconv_close(m2w);
|
|
if (w2m!=(iconv_t)-1) iconv_close(w2m);
|
|
}
|
|
void LoadM2W() { if (m2w==(iconv_t)-1) m2w=iconv_open(WC_NAME,wxConvLibc.cWX2MB(cname)); }
|
|
void LoadW2M() { if (w2m==(iconv_t)-1) w2m=iconv_open(wxConvLibc.cWX2MB(cname),WC_NAME); }
|
|
size_t MB2WC(wchar_t*buf, const char*psz, size_t n) {
|
|
LoadM2W();
|
|
size_t inbuf = strlen(psz);
|
|
size_t outbuf = n*SIZEOF_WCHAR_T;
|
|
size_t res, cres;
|
|
fprintf(stderr,"IC Convert to WC using %s\n",(const char*)wxConvLibc.cWX2MB(cname));
|
|
if (buf) {
|
|
// have destination buffer, convert there
|
|
cres = iconv(m2w,&psz,&inbuf,(char**)&buf,&outbuf);
|
|
res = n-(outbuf/SIZEOF_WCHAR_T);
|
|
// convert to native endianness
|
|
WC_BSWAP(buf, res)
|
|
} else {
|
|
// no destination buffer... convert using temp buffer
|
|
// to calculate destination buffer requirement
|
|
wchar_t tbuf[8];
|
|
res = 0;
|
|
do {
|
|
buf = tbuf; outbuf = 8*SIZEOF_WCHAR_T;
|
|
cres = iconv(m2w,&psz,&inbuf,(char**)&buf,&outbuf);
|
|
res += 8-(outbuf/SIZEOF_WCHAR_T);
|
|
} while ((cres==(size_t)-1) && (errno==E2BIG));
|
|
}
|
|
if (cres==(size_t)-1) return (size_t)-1;
|
|
return res;
|
|
}
|
|
size_t WC2MB(char*buf, const wchar_t*psz, size_t n) {
|
|
LoadW2M();
|
|
#if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
|
|
size_t inbuf = std::wcslen(psz);
|
|
#else
|
|
size_t inbuf = ::wcslen(psz);
|
|
#endif
|
|
size_t outbuf = n;
|
|
size_t res, cres;
|
|
fprintf(stderr,"IC Convert from WC using %s\n",(const char*)wxConvLibc.cWX2MB(cname));
|
|
#ifdef WC_NEED_BSWAP
|
|
// need to copy to temp buffer to switch endianness
|
|
// this absolutely doesn't rock!
|
|
// (no, doing WC_BSWAP twice on the original buffer won't help, as it
|
|
// could be in read-only memory, or be accessed in some other thread)
|
|
wchar_t*tmpbuf=(wchar_t*)malloc((inbuf+1)*SIZEOF_WCHAR_T);
|
|
memcpy(tmpbuf,psz,(inbuf+1)*SIZEOF_WCHAR_T);
|
|
WC_BSWAP(tmpbuf, inbuf)
|
|
psz=tmpbuf;
|
|
#endif
|
|
if (buf) {
|
|
// have destination buffer, convert there
|
|
cres = iconv(w2m,(const char**)&psz,&inbuf,&buf,&outbuf);
|
|
res = n-outbuf;
|
|
} else {
|
|
// no destination buffer... convert using temp buffer
|
|
// to calculate destination buffer requirement
|
|
char tbuf[16];
|
|
res = 0;
|
|
do {
|
|
buf = tbuf; outbuf = 16;
|
|
cres = iconv(w2m,(const char**)&psz,&inbuf,&buf,&outbuf);
|
|
res += 16 - outbuf;
|
|
} while ((cres==(size_t)-1) && (errno==E2BIG));
|
|
}
|
|
#ifdef WC_NEED_BSWAP
|
|
free(tmpbuf);
|
|
#endif
|
|
if (cres==(size_t)-1) return (size_t)-1;
|
|
return res;
|
|
}
|
|
bool usable() { return TRUE; }
|
|
};
|
|
#endif
|
|
|
|
#ifdef __WIN32__
|
|
class CP_CharSet : public wxCharacterSet
|
|
{
|
|
public:
|
|
long CodePage;
|
|
CP_CharSet(const wxChar*name) : wxCharacterSet(name), CodePage(CharsetToCodepage(name)) {}
|
|
size_t MB2WC(wchar_t*buf, const char*psz, size_t n) {
|
|
size_t len = MultiByteToWideChar(CodePage,0,psz,-1,buf,buf?n:0);
|
|
return len?len:(size_t)-1;
|
|
}
|
|
size_t WC2MB(char*buf, const wchar_t*psz, size_t n) {
|
|
size_t len = WideCharToMultiByte(CodePage,0,psz,-1,buf,buf?n:0,NULL,NULL);
|
|
return len?len:(size_t)-1;
|
|
}
|
|
bool usable() { return CodePage!=-1; }
|
|
};
|
|
#endif
|
|
|
|
class EC_CharSet : public wxCharacterSet
|
|
{
|
|
public:
|
|
// temporarily just use wxEncodingConverter stuff,
|
|
// so that it works while a better implementation is built
|
|
wxFontEncoding enc;
|
|
wxEncodingConverter m2w, w2m;
|
|
EC_CharSet(const wxChar*name) : wxCharacterSet(name), enc(wxFONTENCODING_SYSTEM)
|
|
{
|
|
if (name) enc = wxTheFontMapper->CharsetToEncoding(name, FALSE);
|
|
m2w.Init(enc, wxFONTENCODING_UNICODE);
|
|
w2m.Init(wxFONTENCODING_UNICODE, enc);
|
|
}
|
|
size_t MB2WC(wchar_t*buf, const char*psz, size_t n) {
|
|
size_t inbuf = strlen(psz);
|
|
fprintf(stderr,"EC Convert to WC using %d\n",enc);
|
|
if (buf) m2w.Convert(psz,buf);
|
|
return inbuf;
|
|
}
|
|
size_t WC2MB(char*buf, const wchar_t*psz, size_t n) {
|
|
#if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
|
|
size_t inbuf = std::wcslen(psz);
|
|
#else
|
|
size_t inbuf = ::wcslen(psz);
|
|
#endif
|
|
fprintf(stderr,"EC Convert from WC using %d\n",enc);
|
|
if (buf) w2m.Convert(psz,buf);
|
|
return inbuf;
|
|
}
|
|
bool usable() { return (enc!=wxFONTENCODING_SYSTEM) && (enc!=wxFONTENCODING_DEFAULT); }
|
|
};
|
|
|
|
static wxCharacterSet *wxGetCharacterSet(const wxChar *name)
|
|
{
|
|
wxCharacterSet *cset = NULL;
|
|
if (name) {
|
|
if (!wxStricmp(name, wxT("UTF8")) || !wxStricmp(name, wxT("UTF-8"))) {
|
|
cset = new ID_CharSet(name, &wxConvUTF8);
|
|
} else {
|
|
#ifdef HAVE_ICONV_H
|
|
cset = new IC_CharSet(name); // may not take NULL
|
|
#endif
|
|
}
|
|
}
|
|
if (cset && cset->usable()) return cset;
|
|
if (cset) delete cset;
|
|
#ifdef __WIN32__
|
|
cset = new CP_CharSet(name); // may take NULL
|
|
if (cset->usable()) return cset;
|
|
#endif
|
|
if (cset) delete cset;
|
|
cset = new EC_CharSet(name);
|
|
if (cset->usable()) return cset;
|
|
delete cset;
|
|
return NULL;
|
|
}
|
|
|
|
wxCSConv::wxCSConv(const wxChar *charset)
|
|
{
|
|
m_name = (wxChar *) NULL;
|
|
m_cset = (wxCharacterSet *) NULL;
|
|
m_deferred = TRUE;
|
|
SetName(charset);
|
|
}
|
|
|
|
wxCSConv::~wxCSConv()
|
|
{
|
|
if (m_name) free(m_name);
|
|
if (m_cset) delete m_cset;
|
|
}
|
|
|
|
void wxCSConv::SetName(const wxChar *charset)
|
|
{
|
|
if (charset) {
|
|
m_name = wxStrdup(charset);
|
|
m_deferred = TRUE;
|
|
}
|
|
}
|
|
|
|
void wxCSConv::LoadNow()
|
|
{
|
|
// wxPrintf(wxT("Conversion request\n"));
|
|
if (m_deferred) {
|
|
if (!m_name) {
|
|
#ifdef __UNIX__
|
|
#if defined(HAVE_LANGINFO_H) && defined(CODESET)
|
|
// GNU libc provides current character set this way
|
|
char*alang = nl_langinfo(CODESET);
|
|
if (alang) SetName(wxConvLibc.cMB2WX(alang));
|
|
else
|
|
#endif
|
|
// if we can't get at the character set directly,
|
|
// try to see if it's in the environment variables
|
|
// (in most cases this won't work, but I was out of ideas)
|
|
{
|
|
wxChar *lang = wxGetenv(wxT("LC_ALL"));
|
|
if (!lang) lang = wxGetenv(wxT("LC_CTYPE"));
|
|
if (!lang) lang = wxGetenv(wxT("LANG"));
|
|
wxChar *dot = lang ? wxStrchr(lang, wxT('.')) : (wxChar *)NULL;
|
|
if (dot) SetName(dot+1);
|
|
}
|
|
#endif
|
|
}
|
|
m_cset = wxGetCharacterSet(m_name);
|
|
m_deferred = FALSE;
|
|
}
|
|
}
|
|
|
|
size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
|
|
{
|
|
((wxCSConv *)this)->LoadNow(); // discard constness
|
|
if (m_cset)
|
|
return m_cset->MB2WC(buf, psz, n);
|
|
|
|
// latin-1 (direct)
|
|
size_t len=strlen(psz);
|
|
if (buf) {
|
|
for (size_t c=0; c<=len; c++)
|
|
buf[c] = (unsigned char)(psz[c]);
|
|
}
|
|
return len;
|
|
}
|
|
|
|
size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
|
|
{
|
|
((wxCSConv *)this)->LoadNow(); // discard constness
|
|
if (m_cset)
|
|
return m_cset->WC2MB(buf, psz, n);
|
|
|
|
// latin-1 (direct)
|
|
#if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
|
|
size_t len=std::wcslen(psz);
|
|
#else
|
|
size_t len=::wcslen(psz);
|
|
#endif
|
|
if (buf) {
|
|
for (size_t c=0; c<=len; c++)
|
|
buf[c] = (psz[c]>0xff) ? '?' : psz[c];
|
|
}
|
|
return len;
|
|
}
|
|
|
|
#ifdef HAVE_ICONV_H
|
|
class IC_CharSetConverter
|
|
{
|
|
public:
|
|
iconv_t cnv;
|
|
IC_CharSetConverter(IC_CharSet*from,IC_CharSet*to) {
|
|
cnv=iconv_open(wxConvLibc.cWX2MB(to->cname),wxConvLibc.cWX2MB(from->cname));
|
|
}
|
|
~IC_CharSetConverter() {
|
|
if (cnv!=(iconv_t)-1) iconv_close(cnv);
|
|
}
|
|
size_t Convert(char*buf, const char*psz, size_t n) {
|
|
size_t inbuf = strlen(psz);
|
|
size_t outbuf = n;
|
|
size_t res = iconv(cnv,&psz,&inbuf,&buf,&outbuf);
|
|
if (res==(size_t)-1) return (size_t)-1;
|
|
return n-outbuf;
|
|
}
|
|
};
|
|
#endif
|
|
|
|
class EC_CharSetConverter
|
|
{
|
|
public:
|
|
wxEncodingConverter cnv;
|
|
EC_CharSetConverter(EC_CharSet*from,EC_CharSet*to) {
|
|
cnv.Init(from->enc,to->enc);
|
|
}
|
|
size_t Convert(char*buf, const char*psz, size_t n) {
|
|
size_t inbuf = strlen(psz);
|
|
if (buf) cnv.Convert(psz,buf);
|
|
return inbuf;
|
|
}
|
|
};
|
|
|
|
#else // !wxUSE_WCHAR_T
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// stand-ins in absence of wchar_t
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WXDLLEXPORT_DATA(wxMBConv) wxConvLibc, wxConvFile;
|
|
|
|
#endif // wxUSE_WCHAR_T
|
|
|
|
|