Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

My iconv (GLIBC 2.2) uses char** as the second

Browse Source 
parameter. altough it is the in-buffer for the
    character conversion. I added some very ugly
    conversion to strconv to make it compile. While
    being at it, I also reformated the whole file,
    it looks less like Assembler or Perl now.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@9840 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robert Roebling
2001-04-22 14:06:55 +00:00
parent 3f2bcf3437
commit f1339c5685
1 changed files with 316 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

540
src/common/strconv.cpp
View File

@@ -360,131 +360,179 @@ WXDLLEXPORT_DATA(wxCSConv) wxConvLocal((const wxChar *)NULL);
// this should work if M$ Internet Exploiter is installed // this should work if M$ Internet Exploiter is installed
static long CharsetToCodepage(const wxChar *name) static long CharsetToCodepage(const wxChar *name)
{ {
if (!name) return GetACP(); if (!name)
long CP=-1; return GetACP();
wxString cn(name);
do { long CP=-1;
wxString path(wxT("MIME\\Database\\Charset\\"));
path += cn; wxString cn(name);
wxRegKey key(wxRegKey::HKCR,path); do {
wxString path( wxT("MIME\\Database\\Charset\\") );
path += cn;
wxRegKey key( wxRegKey::HKCR, path );
/* two cases: either there's an AliasForCharset string, /* two cases: either there's an AliasForCharset string,
* or there are Codepage and InternetEncoding dwords. * or there are Codepage and InternetEncoding dwords.
* The InternetEncoding gives us the actual encoding, * The InternetEncoding gives us the actual encoding,
* the Codepage just says which Windows character set to * the Codepage just says which Windows character set to
* use when displaying the data. * use when displaying the data.
*/ */
if (key.QueryValue(wxT("InternetEncoding"),&CP)) break; if (key.QueryValue( wxT("InternetEncoding"), &CP )) break;
// no encoding, see if it's an alias
if (!key.QueryValue(wxT("AliasForCharset"),cn)) break; // no encoding, see if it's an alias
} while (1); if (!key.QueryValue( wxT("AliasForCharset"), cn )) break;
return CP; } while (1);
return CP;
} }
#endif #endif
class wxCharacterSet class wxCharacterSet
{ {
public: public:
const wxChar*cname; wxCharacterSet(const wxChar*name)
wxCharacterSet(const wxChar*name) : cname(name) {} : cname(name) {}
virtual ~wxCharacterSet() {} 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 size_t MB2WC(wchar_t*buf, const char*psz, size_t n)
virtual bool usable() { return FALSE; } { 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; }
public:
const wxChar*cname;
}; };
class ID_CharSet : public wxCharacterSet class ID_CharSet : public wxCharacterSet
{ {
public: public:
wxMBConv*work; ID_CharSet(const wxChar*name,wxMBConv*cnv)
ID_CharSet(const wxChar*name,wxMBConv*cnv) : wxCharacterSet(name), work(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 MB2WC(wchar_t*buf, const char*psz, size_t n)
size_t WC2MB(char*buf, const wchar_t*psz, size_t n) { return work ? work->MB2WC(buf,psz,n) : (size_t)-1; }
{ return work ? work->WC2MB(buf,psz,n) : (size_t)-1; }
bool usable() { return work!=NULL; } 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; }
public:
wxMBConv*work;
}; };
#ifdef HAVE_ICONV_H #ifdef HAVE_ICONV_H
class IC_CharSet : public wxCharacterSet class IC_CharSet : public wxCharacterSet
{ {
public: public:
iconv_t m2w, w2m; IC_CharSet(const wxChar*name)
IC_CharSet(const wxChar*name) : wxCharacterSet(name), m2w((iconv_t)-1), w2m((iconv_t)-1) {} : wxCharacterSet(name), m2w((iconv_t)-1), w2m((iconv_t)-1) {}
~IC_CharSet() { ~IC_CharSet()
if (m2w!=(iconv_t)-1) iconv_close(m2w); {
if (w2m!=(iconv_t)-1) iconv_close(w2m); 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; void LoadM2W()
} {
size_t WC2MB(char*buf, const wchar_t*psz, size_t n) { if (m2w==(iconv_t)-1)
LoadW2M(); 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, (char**)&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, (char**)&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) #if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
size_t inbuf = std::wcslen(psz); size_t inbuf = std::wcslen(psz);
#else #else
size_t inbuf = ::wcslen(psz); size_t inbuf = ::wcslen(psz);
#endif #endif
size_t outbuf = n; size_t outbuf = n;
size_t res, cres; size_t res, cres;
fprintf(stderr,"IC Convert from WC using %s\n",(const char*)wxConvLibc.cWX2MB(cname)); fprintf(stderr,"IC Convert from WC using %s\n",(const char*)wxConvLibc.cWX2MB(cname));
#ifdef WC_NEED_BSWAP #ifdef WC_NEED_BSWAP
// need to copy to temp buffer to switch endianness // need to copy to temp buffer to switch endianness
// this absolutely doesn't rock! // this absolutely doesn't rock!
// (no, doing WC_BSWAP twice on the original buffer won't help, as it // (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) // could be in read-only memory, or be accessed in some other thread)
wchar_t*tmpbuf=(wchar_t*)malloc((inbuf+1)*SIZEOF_WCHAR_T); wchar_t*tmpbuf=(wchar_t*)malloc((inbuf+1)*SIZEOF_WCHAR_T);
memcpy(tmpbuf,psz,(inbuf+1)*SIZEOF_WCHAR_T); memcpy(tmpbuf,psz,(inbuf+1)*SIZEOF_WCHAR_T);
WC_BSWAP(tmpbuf, inbuf) WC_BSWAP(tmpbuf, inbuf)
psz=tmpbuf; psz=tmpbuf;
#endif #endif
if (buf) { if (buf)
// have destination buffer, convert there {
cres = iconv(w2m,(const char**)&psz,&inbuf,&buf,&outbuf); // have destination buffer, convert there
res = n-outbuf; cres = iconv( w2m, (char**)&psz, &inbuf, &buf, &outbuf );
} else { res = n-outbuf;
// no destination buffer... convert using temp buffer }
// to calculate destination buffer requirement else
char tbuf[16]; {
res = 0; // no destination buffer... convert using temp buffer
do { // to calculate destination buffer requirement
buf = tbuf; outbuf = 16; char tbuf[16];
cres = iconv(w2m,(const char**)&psz,&inbuf,&buf,&outbuf); res = 0;
res += 16 - outbuf; do {
} while ((cres==(size_t)-1) && (errno==E2BIG)); buf = tbuf; outbuf = 16;
cres = iconv( w2m, (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;
} }
#ifdef WC_NEED_BSWAP
free(tmpbuf); bool usable()
#endif { return TRUE; }
if (cres==(size_t)-1) return (size_t)-1;
return res; public:
} iconv_t m2w, w2m;
bool usable() { return TRUE; }
}; };
#endif #endif
@@ -492,195 +540,239 @@ public:
class CP_CharSet : public wxCharacterSet class CP_CharSet : public wxCharacterSet
{ {
public: public:
long CodePage; CP_CharSet(const wxChar*name)
CP_CharSet(const wxChar*name) : wxCharacterSet(name), CodePage(CharsetToCodepage(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); size_t MB2WC(wchar_t*buf, const char*psz, size_t n)
return len?len:(size_t)-1; {
} size_t len = MultiByteToWideChar(CodePage,0,psz,-1,buf,buf?n:0);
size_t WC2MB(char*buf, const wchar_t*psz, size_t n) { return len ? len : (size_t)-1;
size_t len = WideCharToMultiByte(CodePage,0,psz,-1,buf,buf?n:0,NULL,NULL); }
return len?len:(size_t)-1;
} size_t WC2MB(char*buf, const wchar_t*psz, size_t n)
bool usable() { return CodePage!=-1; } {
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; }
public:
long CodePage;
}; };
#endif #endif
class EC_CharSet : public wxCharacterSet class EC_CharSet : public wxCharacterSet
{ {
public: public:
// temporarily just use wxEncodingConverter stuff, // temporarily just use wxEncodingConverter stuff,
// so that it works while a better implementation is built // so that it works while a better implementation is built
wxFontEncoding enc; EC_CharSet(const wxChar*name) : wxCharacterSet(name), enc(wxFONTENCODING_SYSTEM)
wxEncodingConverter m2w, w2m; {
EC_CharSet(const wxChar*name) : wxCharacterSet(name), enc(wxFONTENCODING_SYSTEM) if (name)
{ enc = wxTheFontMapper->CharsetToEncoding(name, FALSE);
if (name) enc = wxTheFontMapper->CharsetToEncoding(name, FALSE); m2w.Init(enc, wxFONTENCODING_UNICODE);
m2w.Init(enc, wxFONTENCODING_UNICODE); w2m.Init(wxFONTENCODING_UNICODE, enc);
w2m.Init(wxFONTENCODING_UNICODE, enc); }
}
size_t MB2WC(wchar_t*buf, const char*psz, size_t n) { 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); size_t inbuf = strlen(psz);
if (buf) m2w.Convert(psz,buf); fprintf(stderr,"EC Convert to WC using %d\n",enc);
return inbuf; if (buf) m2w.Convert(psz,buf);
} return inbuf;
size_t WC2MB(char*buf, const wchar_t*psz, size_t n) { }
size_t WC2MB(char*buf, const wchar_t*psz, size_t n)
{
#if defined(__BORLANDC__) && (__BORLANDC__ > 0x530) #if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
size_t inbuf = std::wcslen(psz); size_t inbuf = std::wcslen(psz);
#else #else
size_t inbuf = ::wcslen(psz); size_t inbuf = ::wcslen(psz);
#endif #endif
fprintf(stderr,"EC Convert from WC using %d\n",enc); fprintf(stderr,"EC Convert from WC using %d\n",enc);
if (buf) w2m.Convert(psz,buf); if (buf)
return inbuf; w2m.Convert(psz,buf);
}
bool usable() { return (enc!=wxFONTENCODING_SYSTEM) && (enc!=wxFONTENCODING_DEFAULT); } return inbuf;
}
bool usable()
{ return (enc!=wxFONTENCODING_SYSTEM) && (enc!=wxFONTENCODING_DEFAULT); }
public:
wxFontEncoding enc;
wxEncodingConverter m2w, w2m;
}; };
static wxCharacterSet *wxGetCharacterSet(const wxChar *name) static wxCharacterSet *wxGetCharacterSet(const wxChar *name)
{ {
wxCharacterSet *cset = NULL; wxCharacterSet *cset = NULL;
if (name) { if (name)
if (!wxStricmp(name, wxT("UTF8")) || !wxStricmp(name, wxT("UTF-8"))) { {
cset = new ID_CharSet(name, &wxConvUTF8); if (!wxStricmp(name, wxT("UTF8")) || !wxStricmp(name, wxT("UTF-8")))
} else { {
cset = new ID_CharSet(name, &wxConvUTF8);
}
else
{
#ifdef HAVE_ICONV_H #ifdef HAVE_ICONV_H
cset = new IC_CharSet(name); // may not take NULL cset = new IC_CharSet(name); // may not take NULL
#endif #endif
}
} }
}
if (cset && cset->usable()) return cset; if (cset && cset->usable()) return cset;
if (cset) delete cset; if (cset) delete cset;
#ifdef __WIN32__ #ifdef __WIN32__
cset = new CP_CharSet(name); // may take NULL cset = new CP_CharSet(name); // may take NULL
if (cset->usable()) return cset; if (cset->usable()) return cset;
#endif #endif
if (cset) delete cset; if (cset) delete cset;
cset = new EC_CharSet(name); cset = new EC_CharSet(name);
if (cset->usable()) return cset; if (cset->usable()) return cset;
delete cset; delete cset;
return NULL; return NULL;
} }
wxCSConv::wxCSConv(const wxChar *charset) wxCSConv::wxCSConv(const wxChar *charset)
{ {
m_name = (wxChar *) NULL; m_name = (wxChar *) NULL;
m_cset = (wxCharacterSet *) NULL; m_cset = (wxCharacterSet *) NULL;
m_deferred = TRUE; m_deferred = TRUE;
SetName(charset); SetName(charset);
} }
wxCSConv::~wxCSConv() wxCSConv::~wxCSConv()
{ {
if (m_name) free(m_name); if (m_name) free(m_name);
if (m_cset) delete m_cset; if (m_cset) delete m_cset;
} }
void wxCSConv::SetName(const wxChar *charset) void wxCSConv::SetName(const wxChar *charset)
{ {
if (charset) { if (charset)
m_name = wxStrdup(charset); {
m_deferred = TRUE; m_name = wxStrdup(charset);
} m_deferred = TRUE;
}
} }
void wxCSConv::LoadNow() void wxCSConv::LoadNow()
{ {
// wxPrintf(wxT("Conversion request\n")); // wxPrintf(wxT("Conversion request\n"));
if (m_deferred) { if (m_deferred)
if (!m_name) { {
if (!m_name)
{
#ifdef __UNIX__ #ifdef __UNIX__
#if defined(HAVE_LANGINFO_H) && defined(CODESET) #if defined(HAVE_LANGINFO_H) && defined(CODESET)
// GNU libc provides current character set this way // GNU libc provides current character set this way
char*alang = nl_langinfo(CODESET); char*alang = nl_langinfo(CODESET);
if (alang) SetName(wxConvLibc.cMB2WX(alang)); if (alang)
else {
SetName(wxConvLibc.cMB2WX(alang));
}
else
#endif #endif
// if we can't get at the character set directly, {
// try to see if it's in the environment variables // if we can't get at the character set directly,
// (in most cases this won't work, but I was out of ideas) // 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")); wxChar *lang = wxGetenv(wxT("LC_ALL"));
if (!lang) lang = wxGetenv(wxT("LC_CTYPE")); if (!lang) lang = wxGetenv(wxT("LC_CTYPE"));
if (!lang) lang = wxGetenv(wxT("LANG")); if (!lang) lang = wxGetenv(wxT("LANG"));
wxChar *dot = lang ? wxStrchr(lang, wxT('.')) : (wxChar *)NULL; wxChar *dot = lang ? wxStrchr(lang, wxT('.')) : (wxChar *)NULL;
if (dot) SetName(dot+1); if (dot) SetName(dot+1);
} }
#endif #endif
}
m_cset = wxGetCharacterSet(m_name);
m_deferred = FALSE;
} }
m_cset = wxGetCharacterSet(m_name);
m_deferred = FALSE;
}
} }
size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const size_t wxCSConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
{ {
((wxCSConv *)this)->LoadNow(); // discard constness ((wxCSConv *)this)->LoadNow(); // discard constness
if (m_cset)
return m_cset->MB2WC(buf, psz, n); if (m_cset)
return m_cset->MB2WC(buf, psz, n);
// latin-1 (direct) // latin-1 (direct)
size_t len=strlen(psz); size_t len=strlen(psz);
if (buf) {
for (size_t c=0; c<=len; c++) if (buf)
buf[c] = (unsigned char)(psz[c]); {
} for (size_t c=0; c<=len; c++)
return len; buf[c] = (unsigned char)(psz[c]);
}
return len;
} }
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
{ {
((wxCSConv *)this)->LoadNow(); // discard constness ((wxCSConv *)this)->LoadNow(); // discard constness
if (m_cset)
return m_cset->WC2MB(buf, psz, n); if (m_cset)
return m_cset->WC2MB(buf, psz, n);
// latin-1 (direct) // latin-1 (direct)
#if defined(__BORLANDC__) && (__BORLANDC__ > 0x530) #if defined(__BORLANDC__) && (__BORLANDC__ > 0x530)
size_t len=std::wcslen(psz); size_t len=std::wcslen(psz);
#else #else
size_t len=::wcslen(psz); size_t len=::wcslen(psz);
#endif #endif
if (buf) { if (buf)
for (size_t c=0; c<=len; c++) {
buf[c] = (psz[c]>0xff) ? '?' : psz[c]; for (size_t c=0; c<=len; c++)
} buf[c] = (psz[c]>0xff) ? '?' : psz[c];
return len; }
return len;
} }
#ifdef HAVE_ICONV_H #ifdef HAVE_ICONV_H
class IC_CharSetConverter class IC_CharSetConverter
{ {
public: public:
iconv_t cnv; IC_CharSetConverter(IC_CharSet*from,IC_CharSet*to)
IC_CharSetConverter(IC_CharSet*from,IC_CharSet*to) { { cnv = iconv_open(wxConvLibc.cWX2MB(to->cname),wxConvLibc.cWX2MB(from->cname)); }
cnv=iconv_open(wxConvLibc.cWX2MB(to->cname),wxConvLibc.cWX2MB(from->cname));
} ~IC_CharSetConverter()
~IC_CharSetConverter() { { if (cnv!=(iconv_t)-1) iconv_close(cnv); }
if (cnv!=(iconv_t)-1) iconv_close(cnv);
} size_t Convert(char*buf, const char*psz, size_t n)
size_t Convert(char*buf, const char*psz, size_t n) { {
size_t inbuf = strlen(psz); size_t inbuf = strlen(psz);
size_t outbuf = n; size_t outbuf = n;
size_t res = iconv(cnv,&psz,&inbuf,&buf,&outbuf); size_t res = iconv( cnv, (char**)&psz, &inbuf, &buf, &outbuf );
if (res==(size_t)-1) return (size_t)-1; if (res==(size_t)-1) return (size_t)-1;
return n-outbuf; return n-outbuf;
} }
public:
iconv_t cnv;
}; };
#endif #endif
class EC_CharSetConverter class EC_CharSetConverter
{ {
public: public:
wxEncodingConverter cnv; EC_CharSetConverter(EC_CharSet*from,EC_CharSet*to)
EC_CharSetConverter(EC_CharSet*from,EC_CharSet*to) { { cnv.Init(from->enc,to->enc); }
cnv.Init(from->enc,to->enc);
} size_t Convert(char*buf, const char*psz, size_t n)
size_t Convert(char*buf, const char*psz, size_t n) { {
size_t inbuf = strlen(psz); size_t inbuf = strlen(psz);
if (buf) cnv.Convert(psz,buf); if (buf) cnv.Convert(psz,buf);
return inbuf; return inbuf;
} }
public:
wxEncodingConverter cnv;
}; };
#else // !wxUSE_WCHAR_T #else // !wxUSE_WCHAR_T