src/common/strconv.cpp

/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
  #pragma implementation "strconv.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
  #pragma hdrstop
#endif

#include <ctype.h>
#include <string.h>
#include <stdlib.h>

#ifdef __SALFORDC__
  #include <clib.h>
#endif

#include "wx/debug.h"
#include "wx/strconv.h"

//----------------------------------------------------------------------------
// wxConvCurrent
//----------------------------------------------------------------------------

WXDLLEXPORT_DATA(wxMBConv *) wxConvCurrent = &wxConvLibc;

#if !wxUSE_WCHAR_T
//----------------------------------------------------------------------------
// stand-ins in absence of wchar_t
//----------------------------------------------------------------------------

WXDLLEXPORT_DATA(wxMBConv) wxConvLibc, wxConvFile;

#else

//----------------------------------------------------------------------------
// 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);
        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);
        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);
}

#ifdef __WXGTK12__

//----------------------------------------------------------------------------
// standard gdk conversion
//----------------------------------------------------------------------------

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 unsigned long 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;
        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 wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
{
  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;
}

// ----------------------------------------------------------------------------
// specified character set
// ----------------------------------------------------------------------------

#ifndef WX_PRECOMP
  #include "wx/dynarray.h"
  #include "wx/filefn.h"
  #include "wx/textfile.h"
  #include "wx/tokenzr.h"
  #include "wx/utils.h"
#endif

class wxCharacterSet
{
public:
  wxArrayString names;
  wchar_t *data;
};

WX_DECLARE_OBJARRAY(wxCharacterSet, wxCSArray);
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(wxCSArray);

static wxCSArray wxCharsets;

static void wxLoadCharacterSets(void)
{
  static bool already_loaded = FALSE;

  if (already_loaded) return;

  already_loaded = TRUE;
#if defined(__UNIX__) && wxUSE_TEXTFILE
  // search through files in /usr/share/i18n/charmaps
  wxString fname;
  for (fname = ::wxFindFirstFile(wxT("/usr/share/i18n/charmaps/*"));
       !fname.IsEmpty();
       fname = ::wxFindNextFile()) {
    wxTextFile cmap(fname);
    if (cmap.Open()) {
      wxCharacterSet *cset = new wxCharacterSet;
      wxString comchar,escchar;
      bool in_charset = FALSE;

      // wxFprintf(stderr,wxT("Loaded: %s\n"),fname.c_str());

      wxString line;
      for (line = cmap.GetFirstLine();
           !cmap.Eof();
           line = cmap.GetNextLine()) {
        // wxFprintf(stderr,wxT("line contents: %s\n"),line.c_str());
        wxStringTokenizer token(line);
        wxString cmd = token.GetNextToken();
        if (cmd == comchar) {
          if (token.GetNextToken() == wxT("alias"))
            cset->names.Add(token.GetNextToken());
        }
        else if (cmd == wxT("<code_set_name>"))
          cset->names.Add(token.GetNextToken());
        else if (cmd == wxT("<comment_char>"))
          comchar = token.GetNextToken();
        else if (cmd == wxT("<escape_char>"))
          escchar = token.GetNextToken();
        else if (cmd == wxT("<mb_cur_min>")) {
          delete cset;
          cset = (wxCharacterSet *) NULL;
          break; // we don't support multibyte charsets ourselves (yet)
        }
        else if (cmd == wxT("CHARMAP")) {
          cset->data = (wchar_t *)calloc(256, sizeof(wchar_t));
          in_charset = TRUE;
        }
        else if (cmd == wxT("END")) {
          if (token.GetNextToken() == wxT("CHARMAP"))
            in_charset = FALSE;
        }
        else if (in_charset) {
          // format: <NUL> /x00 <U0000> NULL (NUL)
          //         <A>   /x41 <U0041> LATIN CAPITAL LETTER A
          wxString hex = token.GetNextToken();
          // skip whitespace (why doesn't wxStringTokenizer do this?)
          while (wxIsEmpty(hex) && token.HasMoreTokens()) hex = token.GetNextToken();
          wxString uni = token.GetNextToken();
          // skip whitespace again
          while (wxIsEmpty(uni) && token.HasMoreTokens()) uni = token.GetNextToken();
          if ((hex.Len() > 2) && (wxString(hex.GetChar(0)) == escchar) && (hex.GetChar(1) == wxT('x')) &&
              (uni.Left(2) == wxT("<U"))) {
            hex.MakeUpper(); uni.MakeUpper();
            int pos = ::wxHexToDec(hex.Mid(2,2));
            if (pos>=0) {
              unsigned long uni1 = ::wxHexToDec(uni.Mid(2,2));
              unsigned long uni2 = ::wxHexToDec(uni.Mid(4,2));
              cset->data[pos] = (uni1 << 16) | uni2;
              // wxFprintf(stderr,wxT("char %02x mapped to %04x (%c)\n"),pos,cset->data[pos],cset->data[pos]);
            }
          }
        }
      }
      if (cset) {
        cset->names.Shrink();
        wxCharsets.Add(cset);
      }
    }
  }
#endif
  wxCharsets.Shrink();
}

static wxCharacterSet *wxFindCharacterSet(const wxChar *charset)
{
  if (!charset) return (wxCharacterSet *)NULL;
  wxLoadCharacterSets();
  for (size_t n=0; n<wxCharsets.GetCount(); n++)
    if (wxCharsets[n].names.Index(charset) != wxNOT_FOUND)
      return &(wxCharsets[n]);
  return (wxCharacterSet *)NULL;
}

WXDLLEXPORT_DATA(wxCSConv) wxConvLocal((const wxChar *)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);
}

void wxCSConv::SetName(const wxChar *charset)
{
  if (charset) {
#ifdef __UNIX__
    // first, convert the character set name to standard form
    wxString codeset;
    if (wxString(charset,3).CmpNoCase(wxT("ISO")) == 0) {
      // make sure it's represented in the standard form: ISO_8859-1
      codeset = wxT("ISO_");
      charset += 3;
      if ((*charset == wxT('-')) || (*charset == wxT('_'))) charset++;
      if (wxStrlen(charset)>4) {
        if (wxString(charset,4) == wxT("8859")) {
          codeset << wxT("8859-");
          if (*charset == wxT('-')) charset++;
        }
      }
    }
    codeset << charset;
    codeset.MakeUpper();
    m_name = wxStrdup(codeset.c_str());
    m_deferred = TRUE;
#endif
  }
}

void wxCSConv::LoadNow()
{
//  wxPrintf(wxT("Conversion request\n"));
  if (m_deferred) {
    if (!m_name) {
#ifdef __UNIX__
      wxChar *lang = wxGetenv(wxT("LANG"));
      wxChar *dot = lang ? wxStrchr(lang, wxT('.')) : (wxChar *)NULL;
      if (dot) SetName(dot+1);
#endif
    }
    m_cset = wxFindCharacterSet(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 (buf) {
    if (m_cset) {
      for (size_t c=0; c<n; c++)
        buf[c] = m_cset->data[(unsigned char)(psz[c])];
    } else {
      // latin-1 (direct)
      for (size_t c=0; c<n; c++)
        buf[c] = (unsigned char)(psz[c]);
    }
    return n;
  }
  return strlen(psz);
}

size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
{
  ((wxCSConv *)this)->LoadNow(); // discard constness
  if (buf) {
    if (m_cset) {
      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)
      for (size_t c=0; c<n; c++)
        buf[c] = (psz[c]>0xff) ? '?' : psz[c];
    }
    return n;
  }
  return wcslen(psz);
}

#endif
  //wxUSE_WCHAR_T
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: strconv.cpp
	3	// Purpose: Unicode conversion classes
	4	// Author: Ove Kaaven, Robert Roebling, Vadim Zeitlin
	5	// Modified by:
	6	// Created: 29/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1999 Ove Kaaven, Robert Roebling, Vadim Zeitlin
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "strconv.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#include <ctype.h>
	24	#include <string.h>
	25	#include <stdlib.h>
	26
	27	#ifdef __SALFORDC__
	28	#include <clib.h>
	29	#endif
	30
	31	#include "wx/debug.h"
	32	#include "wx/strconv.h"
	33
	34	//----------------------------------------------------------------------------
	35	// wxConvCurrent
	36	//----------------------------------------------------------------------------
	37
	38	WXDLLEXPORT_DATA(wxMBConv *) wxConvCurrent = &wxConvLibc;
	39
	40	#if !wxUSE_WCHAR_T
	41	//----------------------------------------------------------------------------
	42	// stand-ins in absence of wchar_t
	43	//----------------------------------------------------------------------------
	44
	45	WXDLLEXPORT_DATA(wxMBConv) wxConvLibc, wxConvFile;
	46
	47	#else
	48
	49	//----------------------------------------------------------------------------
	50	// wxMBConv
	51	//----------------------------------------------------------------------------
	52
	53	WXDLLEXPORT_DATA(wxMBConv) wxConvLibc;
	54
	55	size_t wxMBConv::MB2WC(wchar_t buf, const char psz, size_t n) const
	56	{
	57	return wxMB2WC(buf, psz, n);
	58	}
	59
	60	size_t wxMBConv::WC2MB(char buf, const wchar_t psz, size_t n) const
	61	{
	62	return wxWC2MB(buf, psz, n);
	63	}
	64
	65	const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
	66	{
	67	if (psz)
	68	{
	69	size_t nLen = MB2WC((wchar_t *) NULL, psz, 0);
	70	wxWCharBuffer buf(nLen);
	71	MB2WC((wchar_t )(const wchar_t ) buf, psz, nLen);
	72	return buf;
	73	}
	74	else
	75	return wxWCharBuffer((wchar_t *) NULL);
	76	}
	77
	78	const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *psz) const
	79	{
	80	if (psz)
	81	{
	82	size_t nLen = WC2MB((char *) NULL, psz, 0);
	83	wxCharBuffer buf(nLen);
	84	WC2MB((char )(const char ) buf, psz, nLen);
	85	return buf;
	86	}
	87	else
	88	return wxCharBuffer((char *) NULL);
	89	}
	90
	91	//----------------------------------------------------------------------------
	92	// standard file conversion
	93	//----------------------------------------------------------------------------
	94
	95	WXDLLEXPORT_DATA(wxMBConvFile) wxConvFile;
	96
	97	// just use the libc conversion for now
	98	size_t wxMBConvFile::MB2WC(wchar_t buf, const char psz, size_t n) const
	99	{
	100	return wxMB2WC(buf, psz, n);
	101	}
	102
	103	size_t wxMBConvFile::WC2MB(char buf, const wchar_t psz, size_t n) const
	104	{
	105	return wxWC2MB(buf, psz, n);
	106	}
	107
	108	#ifdef __WXGTK12__
	109
	110	//----------------------------------------------------------------------------
	111	// standard gdk conversion
	112	//----------------------------------------------------------------------------
	113
	114	WXDLLEXPORT_DATA(wxMBConvGdk) wxConvGdk;
	115
	116	#include <gdk/gdk.h>
	117
	118	size_t wxMBConvGdk::MB2WC(wchar_t buf, const char psz, size_t n) const
	119	{
	120	if (buf) {
	121	return gdk_mbstowcs((GdkWChar *)buf, psz, n);
	122	} else {
	123	GdkWChar *nbuf = new GdkWChar[n=strlen(psz)];
	124	size_t len = gdk_mbstowcs(nbuf, psz, n);
	125	delete [] nbuf;
	126	return len;
	127	}
	128	}
	129
	130	size_t wxMBConvGdk::WC2MB(char buf, const wchar_t psz, size_t n) const
	131	{
	132	char mbstr = gdk_wcstombs((GdkWChar )psz);
	133	size_t len = mbstr ? strlen(mbstr) : 0;
	134	if (buf) {
	135	if (len > n) len = n;
	136	memcpy(buf, psz, len);
	137	if (len < n) buf[len] = 0;
	138	}
	139	return len;
	140	}
	141	#endif // GTK > 1.0
	142
	143	// ----------------------------------------------------------------------------
	144	// UTF-7
	145	// ----------------------------------------------------------------------------
	146
	147	WXDLLEXPORT_DATA(wxMBConvUTF7) wxConvUTF7;
	148
	149	#if 0
	150	static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	151	"abcdefghijklmnopqrstuvwxyz"
	152	"0123456789'(),-./:?";
	153	static char utf7_setO[]="!\"#$%&*;<=>@[]^_`{\|}";
	154	static char utf7_setB[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	155	"abcdefghijklmnopqrstuvwxyz"
	156	"0123456789+/";
	157	#endif
	158
	159	// TODO: write actual implementations of UTF-7 here
	160	size_t wxMBConvUTF7::MB2WC(wchar_t * WXUNUSED(buf),
	161	const char * WXUNUSED(psz),
	162	size_t WXUNUSED(n)) const
	163	{
	164	return 0;
	165	}
	166
	167	size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
	168	const wchar_t * WXUNUSED(psz),
	169	size_t WXUNUSED(n)) const
	170	{
	171	return 0;
	172	}
	173
	174	//----------------------------------------------------------------------------
	175	// UTF-8
	176	//----------------------------------------------------------------------------
	177
	178	WXDLLEXPORT_DATA(wxMBConvUTF8) wxConvUTF8;
	179
	180	static unsigned long utf8_max[]={0x7f,0x7ff,0xffff,0x1fffff,0x3ffffff,0x7fffffff,0xffffffff};
	181
	182	size_t wxMBConvUTF8::MB2WC(wchar_t buf, const char psz, size_t n) const
	183	{
	184	size_t len = 0;
	185
	186	while (*psz && ((!buf) \|\| (len<n))) {
	187	unsigned char cc=*psz++, fc=cc;
	188	unsigned cnt;
	189	for (cnt=0; fc&0x80; cnt++) fc<<=1;
	190	if (!cnt) {
	191	// plain ASCII char
	192	if (buf) *buf++=cc;
	193	len++;
	194	} else {
	195	cnt--;
	196	if (!cnt) {
	197	// invalid UTF-8 sequence
	198	return (size_t)-1;
	199	} else {
	200	unsigned ocnt=cnt-1;
	201	unsigned long res=cc&(0x3f>>cnt);
	202	while (cnt--) {
	203	cc = *psz++;
	204	if ((cc&0xC0)!=0x80) {
	205	// invalid UTF-8 sequence
	206	return (size_t)-1;
	207	}
	208	res=(res<<6)\|(cc&0x3f);
	209	}
	210	if (res<=utf8_max[ocnt]) {
	211	// illegal UTF-8 encoding
	212	return (size_t)-1;
	213	}
	214	if (buf) *buf++=res;
	215	len++;
	216	}
	217	}
	218	}
	219	if (buf && (len<n)) *buf = 0;
	220	return len;
	221	}
	222
	223	size_t wxMBConvUTF8::WC2MB(char buf, const wchar_t psz, size_t n) const
	224	{
	225	size_t len = 0;
	226
	227	while (*psz && ((!buf) \|\| (len<n))) {
	228	unsigned long cc=(*psz++)&0x7fffffff;
	229	unsigned cnt;
	230	for (cnt=0; cc>utf8_max[cnt]; cnt++);
	231	if (!cnt) {
	232	// plain ASCII char
	233	if (buf) *buf++=cc;
	234	len++;
	235	} else {
	236	len+=cnt+1;
	237	if (buf) {
	238	buf++=(-128>>cnt)\|((cc>>(cnt6))&(0x3f>>cnt));
	239	while (cnt--)
	240	buf++=0x80\|((cc>>(cnt6))&0x3f);
	241	}
	242	}
	243	}
	244	if (buf && (len<n)) *buf = 0;
	245	return len;
	246	}
	247
	248	// ----------------------------------------------------------------------------
	249	// specified character set
	250	// ----------------------------------------------------------------------------
	251
	252	#ifndef WX_PRECOMP
	253	#include "wx/dynarray.h"
	254	#include "wx/filefn.h"
	255	#include "wx/textfile.h"
	256	#include "wx/tokenzr.h"
	257	#include "wx/utils.h"
	258	#endif
	259
	260	class wxCharacterSet
	261	{
	262	public:
	263	wxArrayString names;
	264	wchar_t *data;
	265	};
	266
	267	WX_DECLARE_OBJARRAY(wxCharacterSet, wxCSArray);
	268	#include "wx/arrimpl.cpp"
	269	WX_DEFINE_OBJARRAY(wxCSArray);
	270
	271	static wxCSArray wxCharsets;
	272
	273	static void wxLoadCharacterSets(void)
	274	{
	275	static bool already_loaded = FALSE;
	276
	277	if (already_loaded) return;
	278
	279	already_loaded = TRUE;
	280	#if defined(__UNIX__) && wxUSE_TEXTFILE
	281	// search through files in /usr/share/i18n/charmaps
	282	wxString fname;
	283	for (fname = ::wxFindFirstFile(wxT("/usr/share/i18n/charmaps/*"));
	284	!fname.IsEmpty();
	285	fname = ::wxFindNextFile()) {
	286	wxTextFile cmap(fname);
	287	if (cmap.Open()) {
	288	wxCharacterSet *cset = new wxCharacterSet;
	289	wxString comchar,escchar;
	290	bool in_charset = FALSE;
	291
	292	// wxFprintf(stderr,wxT("Loaded: %s\n"),fname.c_str());
	293
	294	wxString line;
	295	for (line = cmap.GetFirstLine();
	296	!cmap.Eof();
	297	line = cmap.GetNextLine()) {
	298	// wxFprintf(stderr,wxT("line contents: %s\n"),line.c_str());
	299	wxStringTokenizer token(line);
	300	wxString cmd = token.GetNextToken();
	301	if (cmd == comchar) {
	302	if (token.GetNextToken() == wxT("alias"))
	303	cset->names.Add(token.GetNextToken());
	304	}
	305	else if (cmd == wxT("<code_set_name>"))
	306	cset->names.Add(token.GetNextToken());
	307	else if (cmd == wxT("<comment_char>"))
	308	comchar = token.GetNextToken();
	309	else if (cmd == wxT("<escape_char>"))
	310	escchar = token.GetNextToken();
	311	else if (cmd == wxT("<mb_cur_min>")) {
	312	delete cset;
	313	cset = (wxCharacterSet *) NULL;
	314	break; // we don't support multibyte charsets ourselves (yet)
	315	}
	316	else if (cmd == wxT("CHARMAP")) {
	317	cset->data = (wchar_t *)calloc(256, sizeof(wchar_t));
	318	in_charset = TRUE;
	319	}
	320	else if (cmd == wxT("END")) {
	321	if (token.GetNextToken() == wxT("CHARMAP"))
	322	in_charset = FALSE;
	323	}
	324	else if (in_charset) {
	325	// format: <NUL> /x00 <U0000> NULL (NUL)
	326	// <A> /x41 <U0041> LATIN CAPITAL LETTER A
	327	wxString hex = token.GetNextToken();
	328	// skip whitespace (why doesn't wxStringTokenizer do this?)
	329	while (wxIsEmpty(hex) && token.HasMoreTokens()) hex = token.GetNextToken();
	330	wxString uni = token.GetNextToken();
	331	// skip whitespace again
	332	while (wxIsEmpty(uni) && token.HasMoreTokens()) uni = token.GetNextToken();
	333	if ((hex.Len() > 2) && (wxString(hex.GetChar(0)) == escchar) && (hex.GetChar(1) == wxT('x')) &&
	334	(uni.Left(2) == wxT("<U"))) {
	335	hex.MakeUpper(); uni.MakeUpper();
	336	int pos = ::wxHexToDec(hex.Mid(2,2));
	337	if (pos>=0) {
	338	unsigned long uni1 = ::wxHexToDec(uni.Mid(2,2));
	339	unsigned long uni2 = ::wxHexToDec(uni.Mid(4,2));
	340	cset->data[pos] = (uni1 << 16) \| uni2;
	341	// wxFprintf(stderr,wxT("char %02x mapped to %04x (%c)\n"),pos,cset->data[pos],cset->data[pos]);
	342	}
	343	}
	344	}
	345	}
	346	if (cset) {
	347	cset->names.Shrink();
	348	wxCharsets.Add(cset);
	349	}
	350	}
	351	}
	352	#endif
	353	wxCharsets.Shrink();
	354	}
	355
	356	static wxCharacterSet wxFindCharacterSet(const wxChar charset)
	357	{
	358	if (!charset) return (wxCharacterSet *)NULL;
	359	wxLoadCharacterSets();
	360	for (size_t n=0; n<wxCharsets.GetCount(); n++)
	361	if (wxCharsets[n].names.Index(charset) != wxNOT_FOUND)
	362	return &(wxCharsets[n]);
	363	return (wxCharacterSet *)NULL;
	364	}
	365
	366	WXDLLEXPORT_DATA(wxCSConv) wxConvLocal((const wxChar *)NULL);
	367
	368	wxCSConv::wxCSConv(const wxChar *charset)
	369	{
	370	m_name = (wxChar *) NULL;
	371	m_cset = (wxCharacterSet *) NULL;
	372	m_deferred = TRUE;
	373	SetName(charset);
	374	}
	375
	376	wxCSConv::~wxCSConv()
	377	{
	378	if (m_name) free(m_name);
	379	}
	380
	381	void wxCSConv::SetName(const wxChar *charset)
	382	{
	383	if (charset) {
	384	#ifdef __UNIX__
	385	// first, convert the character set name to standard form
	386	wxString codeset;
	387	if (wxString(charset,3).CmpNoCase(wxT("ISO")) == 0) {
	388	// make sure it's represented in the standard form: ISO_8859-1
	389	codeset = wxT("ISO_");
	390	charset += 3;
	391	if ((charset == wxT('-')) \|\| (charset == wxT('_'))) charset++;
	392	if (wxStrlen(charset)>4) {
	393	if (wxString(charset,4) == wxT("8859")) {
	394	codeset << wxT("8859-");
	395	if (*charset == wxT('-')) charset++;
	396	}
	397	}
	398	}
	399	codeset << charset;
	400	codeset.MakeUpper();
	401	m_name = wxStrdup(codeset.c_str());
	402	m_deferred = TRUE;
	403	#endif
	404	}
	405	}
	406
	407	void wxCSConv::LoadNow()
	408	{
	409	// wxPrintf(wxT("Conversion request\n"));
	410	if (m_deferred) {
	411	if (!m_name) {
	412	#ifdef __UNIX__
	413	wxChar *lang = wxGetenv(wxT("LANG"));
	414	wxChar dot = lang ? wxStrchr(lang, wxT('.')) : (wxChar )NULL;
	415	if (dot) SetName(dot+1);
	416	#endif
	417	}
	418	m_cset = wxFindCharacterSet(m_name);
	419	m_deferred = FALSE;
	420	}
	421	}
	422
	423	size_t wxCSConv::MB2WC(wchar_t buf, const char psz, size_t n) const
	424	{
	425	((wxCSConv *)this)->LoadNow(); // discard constness
	426	if (buf) {
	427	if (m_cset) {
	428	for (size_t c=0; c<n; c++)
	429	buf[c] = m_cset->data[(unsigned char)(psz[c])];
	430	} else {
	431	// latin-1 (direct)
	432	for (size_t c=0; c<n; c++)
	433	buf[c] = (unsigned char)(psz[c]);
	434	}
	435	return n;
	436	}
	437	return strlen(psz);
	438	}
	439
	440	size_t wxCSConv::WC2MB(char buf, const wchar_t psz, size_t n) const
	441	{
	442	((wxCSConv *)this)->LoadNow(); // discard constness
	443	if (buf) {
	444	if (m_cset) {
	445	for (size_t c=0; c<n; c++) {
	446	size_t n;
	447	for (n=0; (n<256) && (m_cset->data[n] != psz[c]); n++);
	448	buf[c] = (n>0xff) ? '?' : n;
	449	}
	450	} else {
	451	// latin-1 (direct)
	452	for (size_t c=0; c<n; c++)
	453	buf[c] = (psz[c]>0xff) ? '?' : psz[c];
	454	}
	455	return n;
	456	}
	457	return wcslen(psz);
	458	}
	459
	460	#endif
	461	//wxUSE_WCHAR_T
	462
	463