You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3122 lines
102 KiB
3122 lines
102 KiB
/****************************************************************************
|
|
**
|
|
** Implementation of QTextCodec class
|
|
**
|
|
** Created : 981015
|
|
**
|
|
** Copyright (C) 1998-2008 Trolltech ASA. All rights reserved.
|
|
**
|
|
** This file is part of the tools module of the Qt GUI Toolkit.
|
|
**
|
|
** This file may be used under the terms of the GNU General
|
|
** Public License versions 2.0 or 3.0 as published by the Free
|
|
** Software Foundation and appearing in the files LICENSE.GPL2
|
|
** and LICENSE.GPL3 included in the packaging of this file.
|
|
** Alternatively you may (at your option) use any later version
|
|
** of the GNU General Public License if such license has been
|
|
** publicly approved by Trolltech ASA (or its successors, if any)
|
|
** and the KDE Free Qt Foundation.
|
|
**
|
|
** Please review the following information to ensure GNU General
|
|
** Public Licensing requirements will be met:
|
|
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
|
|
** If you are unsure which license is appropriate for your use, please
|
|
** review the following information:
|
|
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
|
|
** or contact the sales department at sales@trolltech.com.
|
|
**
|
|
** This file may be used under the terms of the Q Public License as
|
|
** defined by Trolltech ASA and appearing in the file LICENSE.QPL
|
|
** included in the packaging of this file. Licensees holding valid Qt
|
|
** Commercial licenses may use this file in accordance with the Qt
|
|
** Commercial License Agreement provided with the Software.
|
|
**
|
|
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
|
|
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
|
|
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
|
|
** herein.
|
|
**
|
|
**********************************************************************/
|
|
|
|
#include "qplatformdefs.h"
|
|
|
|
// UNIX Large File Support redefines open -> open64
|
|
#if defined(open)
|
|
# undef open
|
|
#endif
|
|
|
|
#include "qtextcodec.h"
|
|
#ifndef QT_NO_TEXTCODEC
|
|
|
|
#include "qvaluelist.h"
|
|
#include "qtextcodecfactory.h"
|
|
#include "qutfcodec.h"
|
|
#include "qnamespace.h"
|
|
#ifndef QT_NO_CODECS
|
|
#include "qrtlcodec.h"
|
|
#include "qtsciicodec.h"
|
|
#include "qisciicodec_p.h"
|
|
#endif // QT_NO_CODECS
|
|
#ifndef QT_NO_BIG_CODECS
|
|
#include "qbig5codec.h"
|
|
#include "qeucjpcodec.h"
|
|
#include "qeuckrcodec.h"
|
|
#include "qgb18030codec.h"
|
|
#include "qjiscodec.h"
|
|
#include "qjpunicode.h"
|
|
#include "qsjiscodec.h"
|
|
#endif // QT_NO_BIG_CODECS
|
|
#include "qfile.h"
|
|
#include "qstrlist.h"
|
|
#include "qstring.h"
|
|
#include "../tools/qlocale_p.h"
|
|
|
|
#if !defined(QT_NO_CODECS) && !defined(QT_NO_BIG_CODECS) && defined(Q_WS_X11)
|
|
# include "qfontcodecs_p.h"
|
|
#endif
|
|
|
|
#ifdef QT_THREAD_SUPPORT
|
|
# include <private/qmutexpool_p.h>
|
|
#endif // QT_THREAD_SUPPORT
|
|
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#ifndef Q_OS_TEMP
|
|
#include <locale.h>
|
|
#endif
|
|
#if defined(_XOPEN_UNIX) && !defined(Q_OS_QNX6)
|
|
#include <langinfo.h>
|
|
#endif
|
|
|
|
static QValueList<QTextCodec*> *all = 0;
|
|
static bool destroying_is_ok; // starts out as 0
|
|
static QTextCodec * localeMapper = 0;
|
|
|
|
class QTextCodecCleanup {
|
|
public:
|
|
~QTextCodecCleanup() {
|
|
QTextCodec::deleteAllCodecs();
|
|
}
|
|
};
|
|
static QTextCodecCleanup qtextcodec_cleanup;
|
|
|
|
/*!
|
|
Deletes all the created codecs.
|
|
|
|
\warning Do not call this function.
|
|
|
|
QApplication calls this function just before exiting to delete
|
|
any QTextCodec objects that may be lying around. Since various
|
|
other classes hold pointers to QTextCodec objects, it is not safe
|
|
to call this function earlier.
|
|
|
|
If you are using the utility classes (like QString) but not using
|
|
QApplication, calling this function at the very end of your
|
|
application may be helpful for chasing down memory leaks by
|
|
eliminating any QTextCodec objects.
|
|
*/
|
|
|
|
void QTextCodec::deleteAllCodecs()
|
|
{
|
|
if ( !all )
|
|
return;
|
|
|
|
#ifdef QT_THREAD_SUPPORT
|
|
QMutexLocker locker( qt_global_mutexpool ?
|
|
qt_global_mutexpool->get( &all ) : 0 );
|
|
if ( !all )
|
|
return;
|
|
#endif // QT_THREAD_SUPPORT
|
|
|
|
destroying_is_ok = TRUE;
|
|
|
|
QValueList<QTextCodec*> *ball = all;
|
|
all = 0;
|
|
QValueList<QTextCodec*>::Iterator it;
|
|
for ( it = ball->begin(); it != ball->end(); ++it ) {
|
|
delete *it;
|
|
*it = 0;
|
|
}
|
|
ball->clear();
|
|
delete ball;
|
|
|
|
destroying_is_ok = FALSE;
|
|
}
|
|
|
|
|
|
static void realSetup();
|
|
|
|
|
|
static inline void setup()
|
|
{
|
|
if ( all ) return;
|
|
|
|
#ifdef QT_THREAD_SUPPORT
|
|
QMutexLocker locker( qt_global_mutexpool ?
|
|
qt_global_mutexpool->get( &all ) : 0 );
|
|
if ( all ) return;
|
|
#endif // QT_THREAD_SUPPORT
|
|
|
|
realSetup();
|
|
}
|
|
|
|
|
|
class QTextStatelessEncoder: public QTextEncoder {
|
|
const QTextCodec* codec;
|
|
public:
|
|
QTextStatelessEncoder(const QTextCodec*);
|
|
QCString fromUnicode(const QString& uc, int& lenInOut);
|
|
};
|
|
|
|
|
|
class QTextStatelessDecoder : public QTextDecoder {
|
|
const QTextCodec* codec;
|
|
public:
|
|
QTextStatelessDecoder(const QTextCodec*);
|
|
QString toUnicode(const char* chars, int len);
|
|
};
|
|
|
|
QTextStatelessEncoder::QTextStatelessEncoder(const QTextCodec* c) :
|
|
codec(c)
|
|
{
|
|
}
|
|
|
|
|
|
QCString QTextStatelessEncoder::fromUnicode(const QString& uc, int& lenInOut)
|
|
{
|
|
return codec->fromUnicode(uc,lenInOut);
|
|
}
|
|
|
|
|
|
QTextStatelessDecoder::QTextStatelessDecoder(const QTextCodec* c) :
|
|
codec(c)
|
|
{
|
|
}
|
|
|
|
|
|
QString QTextStatelessDecoder::toUnicode(const char* chars, int len)
|
|
{
|
|
return codec->toUnicode(chars,len);
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
\class QTextCodec qtextcodec.h
|
|
\brief The QTextCodec class provides conversion between text encodings.
|
|
\reentrant
|
|
\ingroup i18n
|
|
|
|
Qt uses Unicode to store, draw and manipulate strings. In many
|
|
situations you may wish to deal with data that uses a different
|
|
encoding. For example, most Japanese documents are still stored in
|
|
Shift-JIS or ISO2022, while Russian users often have their
|
|
documents in KOI8-R or CP1251.
|
|
|
|
Qt provides a set of QTextCodec classes to help with converting
|
|
non-Unicode formats to and from Unicode. You can also create your
|
|
own codec classes (\link #subclassing see later\endlink).
|
|
|
|
The supported encodings are:
|
|
\list
|
|
\i Latin1
|
|
\i Big5 -- Chinese
|
|
\i Big5-HKSCS -- Chinese
|
|
\i eucJP -- Japanese
|
|
\i eucKR -- Korean
|
|
\i GB2312 -- Chinese
|
|
\i GBK -- Chinese
|
|
\i GB18030 -- Chinese
|
|
\i JIS7 -- Japanese
|
|
\i Shift-JIS -- Japanese
|
|
\i TSCII -- Tamil
|
|
\i utf8 -- Unicode, 8-bit
|
|
\i utf16 -- Unicode
|
|
\i KOI8-R -- Russian
|
|
\i KOI8-U -- Ukrainian
|
|
\i ISO8859-1 -- Western
|
|
\i ISO8859-2 -- Central European
|
|
\i ISO8859-3 -- Central European
|
|
\i ISO8859-4 -- Baltic
|
|
\i ISO8859-5 -- Cyrillic
|
|
\i ISO8859-6 -- Arabic
|
|
\i ISO8859-7 -- Greek
|
|
\i ISO8859-8 -- Hebrew, visually ordered
|
|
\i ISO8859-8-i -- Hebrew, logically ordered
|
|
\i ISO8859-9 -- Turkish
|
|
\i ISO8859-10
|
|
\i ISO8859-13
|
|
\i ISO8859-14
|
|
\i ISO8859-15 -- Western
|
|
\i IBM 850
|
|
\i IBM 866
|
|
\i CP874
|
|
\i CP1250 -- Central European
|
|
\i CP1251 -- Cyrillic
|
|
\i CP1252 -- Western
|
|
\i CP1253 -- Greek
|
|
\i CP1254 -- Turkish
|
|
\i CP1255 -- Hebrew
|
|
\i CP1256 -- Arabic
|
|
\i CP1257 -- Baltic
|
|
\i CP1258
|
|
\i Apple Roman
|
|
\i TIS-620 -- Thai
|
|
\endlist
|
|
|
|
QTextCodecs can be used as follows to convert some locally encoded
|
|
string to Unicode. Suppose you have some string encoded in Russian
|
|
KOI8-R encoding, and want to convert it to Unicode. The simple way
|
|
to do this is:
|
|
|
|
\code
|
|
QCString locallyEncoded = "..."; // text to convert
|
|
QTextCodec *codec = QTextCodec::codecForName("KOI8-R"); // get the codec for KOI8-R
|
|
QString unicodeString = codec->toUnicode( locallyEncoded );
|
|
\endcode
|
|
|
|
After this, \c{unicodeString} holds the text converted to Unicode.
|
|
Converting a string from Unicode to the local encoding is just as
|
|
easy:
|
|
|
|
\code
|
|
QString unicodeString = "..."; // any Unicode text
|
|
QTextCodec *codec = QTextCodec::codecForName("KOI8-R"); // get the codec for KOI8-R
|
|
QCString locallyEncoded = codec->fromUnicode( unicodeString );
|
|
\endcode
|
|
|
|
Some care must be taken when trying to convert the data in chunks,
|
|
for example, when receiving it over a network. In such cases it is
|
|
possible that a multi-byte character will be split over two
|
|
chunks. At best this might result in the loss of a character and
|
|
at worst cause the entire conversion to fail.
|
|
|
|
The approach to use in these situations is to create a QTextDecoder
|
|
object for the codec and use this QTextDecoder for the whole
|
|
decoding process, as shown below:
|
|
|
|
\code
|
|
QTextCodec *codec = QTextCodec::codecForName( "Shift-JIS" );
|
|
QTextDecoder *decoder = codec->makeDecoder();
|
|
|
|
QString unicodeString;
|
|
while( receiving_data ) {
|
|
QByteArray chunk = new_data;
|
|
unicodeString += decoder->toUnicode( chunk.data(), chunk.length() );
|
|
}
|
|
\endcode
|
|
|
|
The QTextDecoder object maintains state between chunks and therefore
|
|
works correctly even if a multi-byte character is split between
|
|
chunks.
|
|
|
|
\target subclassing
|
|
\section1 Creating your own Codec class
|
|
|
|
Support for new text encodings can be added to Qt by creating
|
|
QTextCodec subclasses.
|
|
|
|
Built-in codecs can be overridden by custom codecs since more
|
|
recently created QTextCodec objects take precedence over earlier
|
|
ones.
|
|
|
|
You may find it more convenient to make your codec class available
|
|
as a plugin; see the \link plugins-howto.html plugin
|
|
documentation\endlink for more details.
|
|
|
|
The abstract virtual functions describe the encoder to the
|
|
system and the coder is used as required in the different
|
|
text file formats supported by QTextStream, and under X11, for the
|
|
locale-specific character input and output.
|
|
|
|
To add support for another 8-bit encoding to Qt, make a subclass
|
|
of QTextCodec and implement at least the following methods:
|
|
|
|
\code
|
|
const char* name() const
|
|
\endcode
|
|
Return the official name for the encoding.
|
|
|
|
\code
|
|
int mibEnum() const
|
|
\endcode
|
|
Return the MIB enum for the encoding if it is listed in the
|
|
\link http://www.iana.org/assignments/character-sets
|
|
IANA character-sets encoding file\endlink.
|
|
|
|
If the encoding is multi-byte then it will have "state"; that is,
|
|
the interpretation of some bytes will be dependent on some preceding
|
|
bytes. For such encodings, you must implement:
|
|
|
|
\code
|
|
QTextDecoder* makeDecoder() const
|
|
\endcode
|
|
Return a QTextDecoder that remembers incomplete multi-byte sequence
|
|
prefixes or other required state.
|
|
|
|
If the encoding does \e not require state, you should implement:
|
|
|
|
\code
|
|
QString toUnicode(const char* chars, int len) const
|
|
\endcode
|
|
Converts \e len characters from \e chars to Unicode.
|
|
|
|
The base QTextCodec class has default implementations of the above
|
|
two functions, \e{but they are mutually recursive}, so you must
|
|
re-implement at least one of them, or both for improved efficiency.
|
|
|
|
For conversion from Unicode to 8-bit encodings, it is rarely necessary
|
|
to maintain state. However, two functions similar to the two above
|
|
are used for encoding:
|
|
|
|
\code
|
|
QTextEncoder* makeEncoder() const
|
|
\endcode
|
|
Return a QTextEncoder.
|
|
|
|
\code
|
|
QCString fromUnicode(const QString& uc, int& lenInOut ) const
|
|
\endcode
|
|
Converts \e lenInOut characters (of type QChar) from the start of
|
|
the string \e uc, returning a QCString result, and also returning
|
|
the \link QCString::length() length\endlink of the result in
|
|
\e lenInOut.
|
|
|
|
Again, these are mutually recursive so only one needs to be implemented,
|
|
or both if greater efficiency is possible.
|
|
|
|
Finally, you must implement:
|
|
|
|
\code
|
|
int heuristicContentMatch(const char* chars, int len) const
|
|
\endcode
|
|
Gives a value indicating how likely it is that \e len characters
|
|
from \e chars are in the encoding.
|
|
|
|
A good model for this function is the
|
|
QWindowsLocalCodec::heuristicContentMatch function found in the Qt
|
|
sources.
|
|
|
|
A QTextCodec subclass might have improved performance if you also
|
|
re-implement:
|
|
|
|
\code
|
|
bool canEncode( QChar ) const
|
|
\endcode
|
|
Test if a Unicode character can be encoded.
|
|
|
|
\code
|
|
bool canEncode( const QString& ) const
|
|
\endcode
|
|
Test if a string of Unicode characters can be encoded.
|
|
|
|
\code
|
|
int heuristicNameMatch(const char* hint) const
|
|
\endcode
|
|
Test if a possibly non-standard name is referring to the codec.
|
|
|
|
Codecs can also be created as \link plugins-howto.html plugins\endlink.
|
|
*/
|
|
|
|
|
|
/*!
|
|
\nonreentrant
|
|
|
|
Constructs a QTextCodec, and gives it the highest precedence. The
|
|
QTextCodec should always be constructed on the heap (i.e. with \c
|
|
new). Qt takes ownership and will delete it when the application
|
|
terminates.
|
|
*/
|
|
QTextCodec::QTextCodec()
|
|
{
|
|
setup();
|
|
all->insert( all->begin(), this );
|
|
}
|
|
|
|
|
|
/*!
|
|
\nonreentrant
|
|
|
|
Destroys the QTextCodec. Note that you should not delete codecs
|
|
yourself: once created they become Qt's responsibility.
|
|
*/
|
|
QTextCodec::~QTextCodec()
|
|
{
|
|
if ( !destroying_is_ok )
|
|
qWarning("QTextCodec::~QTextCodec() called by application");
|
|
if ( all )
|
|
all->remove( this );
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns a value indicating how likely it is that this decoder is
|
|
appropriate for decoding some format that has the given name. The
|
|
name is compared with the \a hint.
|
|
|
|
A good match returns a positive number around the length of the
|
|
string. A bad match is negative.
|
|
|
|
The default implementation calls simpleHeuristicNameMatch() with
|
|
the name of the codec.
|
|
*/
|
|
int QTextCodec::heuristicNameMatch(const char* hint) const
|
|
{
|
|
return simpleHeuristicNameMatch(name(),hint);
|
|
}
|
|
|
|
|
|
// returns a string containing the letters and numbers from input,
|
|
// with a space separating run of a character class. e.g. "iso8859-1"
|
|
// becomes "iso 8859 1"
|
|
static QString lettersAndNumbers( const char * input )
|
|
{
|
|
QString result;
|
|
QChar c;
|
|
|
|
while( input && *input ) {
|
|
c = *input;
|
|
if ( c.isLetter() || c.isNumber() )
|
|
result += c.lower();
|
|
if ( input[1] ) {
|
|
// add space at character class transition, except
|
|
// transition from upper-case to lower-case letter
|
|
QChar n( input[1] );
|
|
if ( c.isLetter() && n.isLetter() ) {
|
|
if ( c == c.lower() && n == n.upper() )
|
|
result += ' ';
|
|
} else if ( c.category() != n.category() ) {
|
|
result += ' ';
|
|
}
|
|
}
|
|
input++;
|
|
}
|
|
return result.simplifyWhiteSpace();
|
|
}
|
|
|
|
/*!
|
|
A simple utility function for heuristicNameMatch(): it does some
|
|
very minor character-skipping so that almost-exact matches score
|
|
high. \a name is the text we're matching and \a hint is used for
|
|
the comparison.
|
|
*/
|
|
int QTextCodec::simpleHeuristicNameMatch(const char* name, const char* hint)
|
|
{
|
|
// if they're the same, return a perfect score.
|
|
if ( name && hint && *name && *hint && qstricmp( name, hint ) == 0 )
|
|
return qstrlen( hint );
|
|
|
|
// if the letters and numbers are the same, we have an "almost"
|
|
// perfect match.
|
|
QString h( lettersAndNumbers( hint ) );
|
|
QString n( lettersAndNumbers( name ) );
|
|
if ( h == n )
|
|
return qstrlen( hint )-1;
|
|
|
|
if ( h.stripWhiteSpace() == n.stripWhiteSpace() )
|
|
return qstrlen( hint )-2;
|
|
|
|
// could do some more here, but I don't think it's worth it
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns the QTextCodec \a i positions from the most recently
|
|
inserted codec, or 0 if there is no such QTextCodec. Thus,
|
|
codecForIndex(0) returns the most recently created QTextCodec.
|
|
*/
|
|
QTextCodec* QTextCodec::codecForIndex(int i)
|
|
{
|
|
setup();
|
|
return (uint)i >= all->count() ? 0 : *all->at(i);
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns the QTextCodec which matches the \link
|
|
QTextCodec::mibEnum() MIBenum\endlink \a mib.
|
|
*/
|
|
QTextCodec* QTextCodec::codecForMib(int mib)
|
|
{
|
|
setup();
|
|
QValueList<QTextCodec*>::ConstIterator i;
|
|
QTextCodec* result=0;
|
|
for ( i = all->begin(); i != all->end(); ++i ) {
|
|
result = *i;
|
|
if ( result->mibEnum()==mib )
|
|
return result;
|
|
}
|
|
|
|
#if !defined(QT_NO_COMPONENT) && !defined(QT_LITE_COMPONENT)
|
|
if ( !result || (result && result->mibEnum() != mib) ) {
|
|
QTextCodec *codec = QTextCodecFactory::createForMib(mib);
|
|
if (codec)
|
|
result = codec;
|
|
}
|
|
#endif // !QT_NO_COMPONENT !QT_LITE_COMPONENT
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef Q_OS_WIN32
|
|
class QWindowsLocalCodec: public QTextCodec
|
|
{
|
|
public:
|
|
QWindowsLocalCodec();
|
|
~QWindowsLocalCodec();
|
|
|
|
QString toUnicode(const char* chars, int len) const;
|
|
QCString fromUnicode(const QString& uc, int& lenInOut ) const;
|
|
|
|
const char* name() const;
|
|
int mibEnum() const;
|
|
|
|
int heuristicContentMatch(const char* chars, int len) const;
|
|
|
|
QTextDecoder* makeDecoder() const;
|
|
};
|
|
|
|
QWindowsLocalCodec::QWindowsLocalCodec()
|
|
{
|
|
}
|
|
|
|
QWindowsLocalCodec::~QWindowsLocalCodec()
|
|
{
|
|
}
|
|
|
|
|
|
QString QWindowsLocalCodec::toUnicode(const char* chars, int len) const
|
|
{
|
|
if ( len == 1 && chars ) { // Optimization; avoids allocation
|
|
char c[2];
|
|
c[0] = *chars;
|
|
c[1] = 0;
|
|
return qt_winMB2QString( c, 2 );
|
|
}
|
|
if ( len < 0 )
|
|
return qt_winMB2QString( chars );
|
|
QCString s(chars,len+1);
|
|
return qt_winMB2QString(s);
|
|
}
|
|
|
|
QCString QWindowsLocalCodec::fromUnicode(const QString& uc, int& lenInOut ) const
|
|
{
|
|
QCString r = qt_winQString2MB( uc, lenInOut );
|
|
lenInOut = r.length();
|
|
return r;
|
|
}
|
|
|
|
|
|
const char* QWindowsLocalCodec::name() const
|
|
{
|
|
return "System";
|
|
}
|
|
|
|
int QWindowsLocalCodec::mibEnum() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
int QWindowsLocalCodec::heuristicContentMatch(const char* chars, int len) const
|
|
{
|
|
// ### Not a bad default implementation?
|
|
QString t = toUnicode(chars,len);
|
|
int l = t.length();
|
|
QCString mb = fromUnicode(t,l);
|
|
int i=0;
|
|
while ( i < len ) {
|
|
if ( chars[i] == mb[i] )
|
|
i++;
|
|
else
|
|
break;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
class QWindowsLocalDecoder: public QTextDecoder
|
|
{
|
|
const QWindowsLocalCodec* codec;
|
|
int nbuf;
|
|
uchar buf[4]; // hopefully this will be enough
|
|
public:
|
|
QWindowsLocalDecoder(const QWindowsLocalCodec *c) : codec(c), nbuf(0)
|
|
{
|
|
}
|
|
|
|
QString toUnicode(const char* chars, int len)
|
|
{
|
|
if (len != 1 && nbuf == 0)
|
|
return codec->toUnicode(chars, len);
|
|
if (len == 1) {
|
|
char c[sizeof buf + 2];
|
|
memcpy(c, buf, nbuf);
|
|
c[nbuf] = *chars;
|
|
c[nbuf+1] = 0;
|
|
|
|
// try to decode this:
|
|
QString retval = codec->toUnicode(c, -1);
|
|
if ( retval.isEmpty() ) {
|
|
// it didn't return anything; we probably stopped mid-way in a multi-byte
|
|
// character
|
|
buf[nbuf++] = *chars;
|
|
if (nbuf + 1 == sizeof buf) {
|
|
qWarning("QWindowsLocalDecoder: exceeded max internal buffer size");
|
|
nbuf = 0;
|
|
}
|
|
}
|
|
else
|
|
nbuf = 0; // decoded successfully
|
|
|
|
return retval;
|
|
}
|
|
|
|
if (len == -1)
|
|
len = (int)strlen(chars);
|
|
|
|
// Ugh! We need to allocate memory
|
|
char *s = new char[nbuf + len + 1];
|
|
memcpy(s, buf, nbuf);
|
|
memcpy(s + nbuf, chars, len);
|
|
s[nbuf + len] = 0;
|
|
|
|
QString retval = codec->toUnicode(s, -1);
|
|
nbuf = 0;
|
|
delete[] s;
|
|
return retval;
|
|
}
|
|
};
|
|
|
|
QTextDecoder* QWindowsLocalCodec::makeDecoder() const
|
|
{
|
|
return new QWindowsLocalDecoder(this);
|
|
}
|
|
|
|
#else
|
|
|
|
/* locale names mostly copied from XFree86 */
|
|
static const char * const iso8859_2locales[] = {
|
|
"croatian", "cs", "cs_CS", "cs_CZ","cz", "cz_CZ", "czech", "hr",
|
|
"hr_HR", "hu", "hu_HU", "hungarian", "pl", "pl_PL", "polish", "ro",
|
|
"ro_RO", "rumanian", "serbocroatian", "sh", "sh_SP", "sh_YU", "sk",
|
|
"sk_SK", "sl", "sl_CS", "sl_SI", "slovak", "slovene", "sr_SP", 0 };
|
|
|
|
static const char * const iso8859_3locales[] = {
|
|
"eo", 0 };
|
|
|
|
static const char * const iso8859_4locales[] = {
|
|
"ee", "ee_EE", 0 };
|
|
|
|
static const char * const iso8859_5locales[] = {
|
|
"mk", "mk_MK", "sp", "sp_YU", 0 };
|
|
|
|
static const char * const cp_1251locales[] = {
|
|
"be", "be_BY", "bg", "bg_BG", "bulgarian", 0 };
|
|
|
|
static const char * const pt_154locales[] = {
|
|
"ba_RU", "ky", "ky_KG", "kk", "kk_KZ", 0 };
|
|
|
|
static const char * const iso8859_6locales[] = {
|
|
"ar_AA", "ar_SA", "arabic", 0 };
|
|
|
|
static const char * const iso8859_7locales[] = {
|
|
"el", "el_GR", "greek", 0 };
|
|
|
|
static const char * const iso8859_8locales[] = {
|
|
"hebrew", "he", "he_IL", "iw", "iw_IL", 0 };
|
|
|
|
static const char * const iso8859_9locales[] = {
|
|
"tr", "tr_TR", "turkish", 0 };
|
|
|
|
static const char * const iso8859_13locales[] = {
|
|
"lt", "lt_LT", "lv", "lv_LV", 0 };
|
|
|
|
static const char * const iso8859_15locales[] = {
|
|
"et", "et_EE",
|
|
// Euro countries
|
|
"br_FR", "ca_ES", "de", "de_AT", "de_BE", "de_DE", "de_LU", "en_IE",
|
|
"es", "es_ES", "eu_ES", "fi", "fi_FI", "finnish", "fr", "fr_FR",
|
|
"fr_BE", "fr_LU", "french", "ga_IE", "gl_ES", "it", "it_IT", "oc_FR",
|
|
"nl", "nl_BE", "nl_NL", "pt", "pt_PT", "sv_FI", "wa_BE",
|
|
0 };
|
|
|
|
static const char * const koi8_ulocales[] = {
|
|
"uk", "uk_UA", "ru_UA", "ukrainian", 0 };
|
|
|
|
static const char * const tis_620locales[] = {
|
|
"th", "th_TH", "thai", 0 };
|
|
|
|
static const char * const tcvnlocales[] = {
|
|
"vi", "vi_VN", 0 };
|
|
|
|
static bool try_locale_list( const char * const locale[], const char * lang )
|
|
{
|
|
int i;
|
|
for( i=0; locale[i] && *locale[i] && strcmp(locale[i], lang); i++ )
|
|
;
|
|
return locale[i] != 0;
|
|
}
|
|
|
|
// For the probably_koi8_locales we have to look. the standard says
|
|
// these are 8859-5, but almost all Russian users use KOI8-R and
|
|
// incorrectly set $LANG to ru_RU. We'll check tolower() to see what
|
|
// tolower() thinks ru_RU means.
|
|
|
|
// If you read the history, it seems that many Russians blame ISO and
|
|
// Perestroika for the confusion.
|
|
//
|
|
// The real bug is that some programs break if the user specifies
|
|
// ru_RU.KOI8-R.
|
|
|
|
static const char * const probably_koi8_rlocales[] = {
|
|
"ru", "ru_SU", "ru_RU", "russian", 0 };
|
|
|
|
static QTextCodec * ru_RU_hack( const char * i ) {
|
|
QTextCodec * ru_RU_codec = 0;
|
|
|
|
QCString origlocale = setlocale( LC_CTYPE, i );
|
|
// unicode koi8r latin5 name
|
|
// 0x044E 0xC0 0xEE CYRILLIC SMALL LETTER YU
|
|
// 0x042E 0xE0 0xCE CYRILLIC CAPITAL LETTER YU
|
|
int latin5 = tolower( 0xCE );
|
|
int koi8r = tolower( 0xE0 );
|
|
if ( koi8r == 0xC0 && latin5 != 0xEE ) {
|
|
ru_RU_codec = QTextCodec::codecForName( "KOI8-R" );
|
|
} else if ( koi8r != 0xC0 && latin5 == 0xEE ) {
|
|
ru_RU_codec = QTextCodec::codecForName( "ISO 8859-5" );
|
|
} else {
|
|
// something else again... let's assume... *throws dice*
|
|
ru_RU_codec = QTextCodec::codecForName( "KOI8-R" );
|
|
qWarning( "QTextCodec: using KOI8-R, probe failed (%02x %02x %s)",
|
|
koi8r, latin5, i );
|
|
}
|
|
setlocale( LC_CTYPE, origlocale.data() );
|
|
|
|
return ru_RU_codec;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*!
|
|
Set the codec to \a c; this will be returned by codecForLocale().
|
|
This might be needed for some applications that want to use their
|
|
own mechanism for setting the locale.
|
|
|
|
\sa codecForLocale()
|
|
*/
|
|
void QTextCodec::setCodecForLocale(QTextCodec *c) {
|
|
localeMapper = c;
|
|
}
|
|
|
|
/*! Returns a pointer to the codec most suitable for this locale. */
|
|
|
|
QTextCodec* QTextCodec::codecForLocale()
|
|
{
|
|
if ( localeMapper )
|
|
return localeMapper;
|
|
|
|
setup();
|
|
|
|
return localeMapper;
|
|
}
|
|
|
|
|
|
/*!
|
|
Searches all installed QTextCodec objects and returns the one
|
|
which best matches \a name; the match is case-insensitive. Returns
|
|
0 if no codec's heuristicNameMatch() reports a match better than
|
|
\a accuracy, or if \a name is a null string.
|
|
|
|
\sa heuristicNameMatch()
|
|
*/
|
|
|
|
QTextCodec* QTextCodec::codecForName( const char* name, int accuracy )
|
|
{
|
|
if ( !name || !*name )
|
|
return 0;
|
|
|
|
setup();
|
|
QValueList<QTextCodec*>::ConstIterator i;
|
|
QTextCodec* result = 0;
|
|
int best = accuracy;
|
|
QTextCodec* cursor;
|
|
for ( i = all->begin(); i != all->end(); ++i ) {
|
|
cursor = *i;
|
|
int s = cursor->heuristicNameMatch( name );
|
|
if ( s > best ) {
|
|
best = s;
|
|
result = cursor;
|
|
}
|
|
}
|
|
|
|
#if !defined(QT_NO_COMPONENT) && !defined(QT_LITE_COMPONENT)
|
|
if ( !result )
|
|
result = QTextCodecFactory::createForName(name);
|
|
#endif // !QT_NO_COMPONENT !QT_LITE_COMPONENT
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*!
|
|
Searches all installed QTextCodec objects, returning the one which
|
|
most recognizes the given content. May return 0.
|
|
|
|
Note that this is often a poor choice, since character encodings
|
|
often use most of the available character sequences, and so only
|
|
by linguistic analysis could a true match be made.
|
|
|
|
\a chars contains the string to check, and \a len contains the
|
|
number of characters in the string to use.
|
|
|
|
\sa heuristicContentMatch()
|
|
*/
|
|
QTextCodec* QTextCodec::codecForContent(const char* chars, int len)
|
|
{
|
|
setup();
|
|
QValueList<QTextCodec*>::ConstIterator i;
|
|
QTextCodec* result = 0;
|
|
int best=0;
|
|
QTextCodec* cursor;
|
|
for ( i = all->begin(); i != all->end(); ++i ) {
|
|
cursor = *i;
|
|
int s = cursor->heuristicContentMatch(chars,len);
|
|
if ( s > best ) {
|
|
best = s;
|
|
result = cursor;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/*!
|
|
\fn const char* QTextCodec::name() const
|
|
|
|
QTextCodec subclasses must reimplement this function. It returns
|
|
the name of the encoding supported by the subclass. When choosing
|
|
a name for an encoding, consider these points:
|
|
\list
|
|
\i On X11, heuristicNameMatch( const char * hint )
|
|
is used to test if a the QTextCodec
|
|
can convert between Unicode and the encoding of a font
|
|
with encoding \e hint, such as "iso8859-1" for Latin-1 fonts,
|
|
"koi8-r" for Russian KOI8 fonts.
|
|
The default algorithm of heuristicNameMatch() uses name().
|
|
\i Some applications may use this function to present
|
|
encodings to the end user.
|
|
\endlist
|
|
*/
|
|
|
|
/*!
|
|
\fn int QTextCodec::mibEnum() const
|
|
|
|
Subclasses of QTextCodec must reimplement this function. It
|
|
returns the MIBenum (see \link
|
|
http://www.iana.org/assignments/character-sets the
|
|
IANA character-sets encoding file\endlink for more information).
|
|
It is important that each QTextCodec subclass returns the correct
|
|
unique value for this function.
|
|
*/
|
|
|
|
|
|
/*!
|
|
Returns the preferred mime name of the encoding as defined in the
|
|
\link http://www.iana.org/assignments/character-sets
|
|
IANA character-sets encoding file\endlink.
|
|
*/
|
|
const char* QTextCodec::mimeName() const
|
|
{
|
|
return name();
|
|
}
|
|
|
|
|
|
/*!
|
|
\fn int QTextCodec::heuristicContentMatch(const char* chars, int len) const
|
|
|
|
QTextCodec subclasses must reimplement this function. It examines
|
|
the first \a len bytes of \a chars and returns a value indicating
|
|
how likely it is that the string is a prefix of text encoded in
|
|
the encoding of the subclass. A negative return value indicates
|
|
that the text is detectably not in the encoding (e.g. it contains
|
|
characters undefined in the encoding). A return value of 0
|
|
indicates that the text should be decoded with this codec rather
|
|
than as ASCII, but there is no particular evidence. The value
|
|
should range up to \a len. Thus, most decoders will return -1, 0,
|
|
or -\a len.
|
|
|
|
The characters are not null terminated.
|
|
|
|
\sa codecForContent().
|
|
*/
|
|
|
|
|
|
/*!
|
|
Creates a QTextDecoder which stores enough state to decode chunks
|
|
of char* data to create chunks of Unicode data. The default
|
|
implementation creates a stateless decoder, which is only
|
|
sufficient for the simplest encodings where each byte corresponds
|
|
to exactly one Unicode character.
|
|
|
|
The caller is responsible for deleting the returned object.
|
|
*/
|
|
QTextDecoder* QTextCodec::makeDecoder() const
|
|
{
|
|
return new QTextStatelessDecoder(this);
|
|
}
|
|
|
|
|
|
/*!
|
|
Creates a QTextEncoder which stores enough state to encode chunks
|
|
of Unicode data as char* data. The default implementation creates
|
|
a stateless encoder, which is only sufficient for the simplest
|
|
encodings where each Unicode character corresponds to exactly one
|
|
character.
|
|
|
|
The caller is responsible for deleting the returned object.
|
|
*/
|
|
QTextEncoder* QTextCodec::makeEncoder() const
|
|
{
|
|
return new QTextStatelessEncoder(this);
|
|
}
|
|
|
|
|
|
/*!
|
|
QTextCodec subclasses must reimplement this function or
|
|
makeDecoder(). It converts the first \a len characters of \a chars
|
|
to Unicode.
|
|
|
|
The default implementation makes a decoder with makeDecoder() and
|
|
converts the input with that. Note that the default makeDecoder()
|
|
implementation makes a decoder that simply calls
|
|
this function, hence subclasses \e must reimplement one function or
|
|
the other to avoid infinite recursion.
|
|
*/
|
|
QString QTextCodec::toUnicode(const char* chars, int len) const
|
|
{
|
|
if ( chars == 0 )
|
|
return QString::null;
|
|
QTextDecoder* i = makeDecoder();
|
|
QString result = i->toUnicode(chars,len);
|
|
delete i;
|
|
return result;
|
|
}
|
|
|
|
|
|
/*!
|
|
QTextCodec subclasses must reimplement either this function or
|
|
makeEncoder(). It converts the first \a lenInOut characters of \a
|
|
uc from Unicode to the encoding of the subclass. If \a lenInOut is
|
|
negative or too large, the length of \a uc is used instead.
|
|
|
|
Converts \a lenInOut characters (not bytes) from \a uc, producing
|
|
a QCString. \a lenInOut will be set to the \link
|
|
QCString::length() length\endlink of the result (in bytes).
|
|
|
|
The default implementation makes an encoder with makeEncoder() and
|
|
converts the input with that. Note that the default makeEncoder()
|
|
implementation makes an encoder that simply calls this function,
|
|
hence subclasses \e must reimplement one function or the other to
|
|
avoid infinite recursion.
|
|
*/
|
|
|
|
QCString QTextCodec::fromUnicode(const QString& uc, int& lenInOut) const
|
|
{
|
|
QTextEncoder* i = makeEncoder();
|
|
QCString result = i->fromUnicode(uc, lenInOut);
|
|
delete i;
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
\internal
|
|
*/
|
|
QByteArray QTextCodec::fromUnicode( const QString &str, int pos, int len ) const
|
|
{
|
|
QByteArray a;
|
|
if( len < 0 )
|
|
len = str.length() - pos;
|
|
a = fromUnicode( str.mid(pos, len) );
|
|
if( a.size() > 0 && a[(int)a.size() - 1] == '\0' )
|
|
a.resize( a.size() - 1 );
|
|
return a;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a uc is the unicode source string.
|
|
*/
|
|
QCString QTextCodec::fromUnicode(const QString& uc) const
|
|
{
|
|
int l = uc.length();
|
|
return fromUnicode(uc,l);
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a a contains the source characters; \a len contains the number of
|
|
characters in \a a to use.
|
|
*/
|
|
QString QTextCodec::toUnicode(const QByteArray& a, int len) const
|
|
{
|
|
int l = a.size();
|
|
l = QMIN( l, len );
|
|
return toUnicode( a.data(), l );
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a a contains the source characters.
|
|
*/
|
|
QString QTextCodec::toUnicode(const QByteArray& a) const
|
|
{
|
|
int l = a.size();
|
|
return toUnicode( a.data(), l );
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a a contains the source characters; \a len contains the number of
|
|
characters in \a a to use.
|
|
*/
|
|
QString QTextCodec::toUnicode(const QCString& a, int len) const
|
|
{
|
|
int l = a.length();
|
|
l = QMIN( l, len );
|
|
return toUnicode( a.data(), l );
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a a contains the source characters.
|
|
*/
|
|
QString QTextCodec::toUnicode(const QCString& a) const
|
|
{
|
|
int l = a.length();
|
|
return toUnicode( a.data(), l );
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a chars contains the source characters.
|
|
*/
|
|
QString QTextCodec::toUnicode(const char* chars) const
|
|
{
|
|
return toUnicode(chars,qstrlen(chars));
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
unsigned short QTextCodec::characterFromUnicode(const QString &str, int pos) const
|
|
{
|
|
QCString result = QTextCodec::fromUnicode(QString(str[pos]));
|
|
uchar *ch = (uchar *) result.data();
|
|
ushort retval = 0;
|
|
if (result.size() > 2) {
|
|
retval = (ushort) *ch << 8;
|
|
ch++;
|
|
}
|
|
return retval + *ch;
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if the Unicode character \a ch can be fully encoded
|
|
with this codec; otherwise returns FALSE. The default
|
|
implementation tests if the result of toUnicode(fromUnicode(ch))
|
|
is the original \a ch. Subclasses may be able to improve the
|
|
efficiency.
|
|
*/
|
|
bool QTextCodec::canEncode( QChar ch ) const
|
|
{
|
|
return toUnicode(fromUnicode(ch)) == ch;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a s contains the string being tested for encode-ability.
|
|
*/
|
|
bool QTextCodec::canEncode( const QString& s ) const
|
|
{
|
|
if ( s.isEmpty() )
|
|
return TRUE;
|
|
return toUnicode(fromUnicode(s)) == s;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
\class QTextEncoder qtextcodec.h
|
|
\brief The QTextEncoder class provides a state-based encoder.
|
|
\reentrant
|
|
\ingroup i18n
|
|
|
|
The encoder converts Unicode into another format, remembering any
|
|
state that is required between calls.
|
|
|
|
\sa QTextCodec::makeEncoder()
|
|
*/
|
|
|
|
/*!
|
|
Destroys the encoder.
|
|
*/
|
|
QTextEncoder::~QTextEncoder()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
\fn QCString QTextEncoder::fromUnicode(const QString& uc, int& lenInOut)
|
|
|
|
Converts \a lenInOut characters (not bytes) from \a uc, producing
|
|
a QCString. \a lenInOut will be set to the \link
|
|
QCString::length() length\endlink of the result (in bytes).
|
|
|
|
The encoder is free to record state to use when subsequent calls
|
|
are made to this function (for example, it might change modes with
|
|
escape sequences if needed during the encoding of one string, then
|
|
assume that mode applies when a subsequent call begins).
|
|
*/
|
|
|
|
/*!
|
|
\class QTextDecoder qtextcodec.h
|
|
\brief The QTextDecoder class provides a state-based decoder.
|
|
\reentrant
|
|
\ingroup i18n
|
|
|
|
The decoder converts a text format into Unicode, remembering any
|
|
state that is required between calls.
|
|
|
|
\sa QTextCodec::makeEncoder()
|
|
*/
|
|
|
|
|
|
/*!
|
|
Destroys the decoder.
|
|
*/
|
|
QTextDecoder::~QTextDecoder()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
\fn QString QTextDecoder::toUnicode(const char* chars, int len)
|
|
|
|
Converts the first \a len bytes in \a chars to Unicode, returning
|
|
the result.
|
|
|
|
If not all characters are used (e.g. if only part of a multi-byte
|
|
encoding is at the end of the characters), the decoder remembers
|
|
enough state to continue with the next call to this function.
|
|
*/
|
|
|
|
#define CHAINED 0xffff
|
|
|
|
struct QMultiByteUnicodeTable {
|
|
// If multiByte, ignore unicode and index into multiByte
|
|
// with the next character.
|
|
QMultiByteUnicodeTable() : unicode(0xfffd), multiByte(0) { }
|
|
|
|
~QMultiByteUnicodeTable()
|
|
{
|
|
if ( multiByte )
|
|
delete [] multiByte;
|
|
}
|
|
|
|
ushort unicode;
|
|
QMultiByteUnicodeTable* multiByte;
|
|
};
|
|
|
|
static int getByte(char* &cursor)
|
|
{
|
|
int byte = 0;
|
|
if ( *cursor ) {
|
|
if ( cursor[1] == 'x' )
|
|
byte = strtol(cursor+2,&cursor,16);
|
|
else if ( cursor[1] == 'd' )
|
|
byte = strtol(cursor+2,&cursor,10);
|
|
else
|
|
byte = strtol(cursor+2,&cursor,8);
|
|
}
|
|
return byte&0xff;
|
|
}
|
|
|
|
class QTextCodecFromIOD;
|
|
|
|
class QTextCodecFromIODDecoder : public QTextDecoder {
|
|
const QTextCodecFromIOD* codec;
|
|
QMultiByteUnicodeTable* mb;
|
|
public:
|
|
QTextCodecFromIODDecoder(const QTextCodecFromIOD* c);
|
|
QString toUnicode(const char* chars, int len);
|
|
};
|
|
|
|
class QTextCodecFromIOD : public QTextCodec {
|
|
friend class QTextCodecFromIODDecoder;
|
|
|
|
QCString n;
|
|
|
|
// If from_unicode_page[row()][cell()] is 0 and from_unicode_page_multiByte,
|
|
// use from_unicode_page_multiByte[row()][cell()] as string.
|
|
char** from_unicode_page;
|
|
char*** from_unicode_page_multiByte;
|
|
char unkn;
|
|
|
|
// Only one of these is used
|
|
ushort* to_unicode;
|
|
QMultiByteUnicodeTable* to_unicode_multiByte;
|
|
int max_bytes_per_char;
|
|
QStrList aliases;
|
|
|
|
bool stateless() const { return !to_unicode_multiByte; }
|
|
|
|
public:
|
|
QTextCodecFromIOD(QIODevice* iod)
|
|
{
|
|
from_unicode_page = 0;
|
|
to_unicode_multiByte = 0;
|
|
to_unicode = 0;
|
|
from_unicode_page_multiByte = 0;
|
|
max_bytes_per_char = 1;
|
|
|
|
const int maxlen=100;
|
|
char line[maxlen];
|
|
char esc='\\';
|
|
char comm='%';
|
|
bool incmap = FALSE;
|
|
while (iod->readLine(line,maxlen) > 0) {
|
|
if (0==qstrnicmp(line,"<code_set_name>",15))
|
|
n = line+15;
|
|
else if (0==qstrnicmp(line,"<escape_char> ",14))
|
|
esc = line[14];
|
|
else if (0==qstrnicmp(line,"<comment_char> ",15))
|
|
comm = line[15];
|
|
else if (line[0]==comm && 0==qstrnicmp(line+1," alias ",7)) {
|
|
aliases.append(line+8);
|
|
} else if (0==qstrnicmp(line,"CHARMAP",7)) {
|
|
if (!from_unicode_page) {
|
|
from_unicode_page = new char*[256];
|
|
for (int i=0; i<256; i++)
|
|
from_unicode_page[i]=0;
|
|
}
|
|
if (!to_unicode) {
|
|
to_unicode = new ushort[256];
|
|
}
|
|
incmap = TRUE;
|
|
} else if (0==qstrnicmp(line,"END CHARMAP",11))
|
|
break;
|
|
else if (incmap) {
|
|
char* cursor = line;
|
|
int byte=-1,unicode=-1;
|
|
ushort* mb_unicode=0;
|
|
const int maxmb=8; // more -> we'll need to improve datastructures
|
|
char mb[maxmb+1];
|
|
int nmb=0;
|
|
|
|
while (*cursor) {
|
|
if (cursor[0]=='<' && cursor[1]=='U' &&
|
|
cursor[2]>='0' && cursor[2]<='9' &&
|
|
cursor[3]>='0' && cursor[3]<='9') {
|
|
|
|
unicode = strtol(cursor+2,&cursor,16);
|
|
|
|
} else if (*cursor==esc) {
|
|
|
|
byte = getByte(cursor);
|
|
|
|
if ( *cursor == esc ) {
|
|
if ( !to_unicode_multiByte ) {
|
|
to_unicode_multiByte =
|
|
new QMultiByteUnicodeTable[256];
|
|
for (int i=0; i<256; i++) {
|
|
to_unicode_multiByte[i].unicode =
|
|
to_unicode[i];
|
|
to_unicode_multiByte[i].multiByte = 0;
|
|
}
|
|
delete [] to_unicode;
|
|
to_unicode = 0;
|
|
}
|
|
QMultiByteUnicodeTable* mbut =
|
|
to_unicode_multiByte+byte;
|
|
mb[nmb++] = byte;
|
|
while ( nmb < maxmb && *cursor == esc ) {
|
|
// Always at least once
|
|
|
|
mbut->unicode = CHAINED;
|
|
byte = getByte(cursor);
|
|
mb[nmb++] = byte;
|
|
if (!mbut->multiByte) {
|
|
mbut->multiByte =
|
|
new QMultiByteUnicodeTable[256];
|
|
}
|
|
mbut = mbut->multiByte+byte;
|
|
mb_unicode = & mbut->unicode;
|
|
}
|
|
|
|
if ( nmb > max_bytes_per_char )
|
|
max_bytes_per_char = nmb;
|
|
}
|
|
} else {
|
|
cursor++;
|
|
}
|
|
}
|
|
|
|
if (unicode >= 0 && unicode <= 0xffff)
|
|
{
|
|
QChar ch((ushort)unicode);
|
|
if (!from_unicode_page[ch.row()]) {
|
|
from_unicode_page[ch.row()] = new char[256];
|
|
for (int i=0; i<256; i++)
|
|
from_unicode_page[ch.row()][i]=0;
|
|
}
|
|
if ( mb_unicode ) {
|
|
from_unicode_page[ch.row()][ch.cell()] = 0;
|
|
if (!from_unicode_page_multiByte) {
|
|
from_unicode_page_multiByte = new char**[256];
|
|
for (int i=0; i<256; i++)
|
|
from_unicode_page_multiByte[i]=0;
|
|
}
|
|
if (!from_unicode_page_multiByte[ch.row()]) {
|
|
from_unicode_page_multiByte[ch.row()] = new char*[256];
|
|
for (int i=0; i<256; i++)
|
|
from_unicode_page_multiByte[ch.row()][i] = 0;
|
|
}
|
|
mb[nmb++] = 0;
|
|
from_unicode_page_multiByte[ch.row()][ch.cell()]
|
|
= qstrdup(mb);
|
|
*mb_unicode = unicode;
|
|
} else {
|
|
from_unicode_page[ch.row()][ch.cell()] = (char)byte;
|
|
if ( to_unicode )
|
|
to_unicode[byte] = unicode;
|
|
else
|
|
to_unicode_multiByte[byte].unicode = unicode;
|
|
}
|
|
} else {
|
|
}
|
|
}
|
|
}
|
|
n = n.stripWhiteSpace();
|
|
|
|
unkn = '?'; // ##### Might be a bad choice.
|
|
}
|
|
|
|
~QTextCodecFromIOD()
|
|
{
|
|
if ( from_unicode_page ) {
|
|
for (int i=0; i<256; i++)
|
|
if (from_unicode_page[i])
|
|
delete [] from_unicode_page[i];
|
|
}
|
|
if ( from_unicode_page_multiByte ) {
|
|
for (int i=0; i<256; i++)
|
|
if (from_unicode_page_multiByte[i])
|
|
for (int j=0; j<256; j++)
|
|
if (from_unicode_page_multiByte[i][j])
|
|
delete [] from_unicode_page_multiByte[i][j];
|
|
}
|
|
if ( to_unicode )
|
|
delete [] to_unicode;
|
|
if ( to_unicode_multiByte )
|
|
delete [] to_unicode_multiByte;
|
|
}
|
|
|
|
bool ok() const
|
|
{
|
|
return !!from_unicode_page;
|
|
}
|
|
|
|
QTextDecoder* makeDecoder() const
|
|
{
|
|
if ( stateless() )
|
|
return QTextCodec::makeDecoder();
|
|
else
|
|
return new QTextCodecFromIODDecoder(this);
|
|
}
|
|
|
|
const char* name() const
|
|
{
|
|
return n;
|
|
}
|
|
|
|
int mibEnum() const
|
|
{
|
|
return 0; // #### Unknown.
|
|
}
|
|
|
|
int heuristicContentMatch(const char*, int) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int heuristicNameMatch(const char* hint) const
|
|
{
|
|
int bestr = QTextCodec::heuristicNameMatch(hint);
|
|
QStrListIterator it(aliases);
|
|
char* a;
|
|
while ((a=it.current())) {
|
|
++it;
|
|
int r = simpleHeuristicNameMatch(a,hint);
|
|
if (r > bestr)
|
|
bestr = r;
|
|
}
|
|
return bestr;
|
|
}
|
|
|
|
QString toUnicode(const char* chars, int len) const
|
|
{
|
|
const uchar* uchars = (const uchar*)chars;
|
|
QString result;
|
|
QMultiByteUnicodeTable* multiByte=to_unicode_multiByte;
|
|
if ( multiByte ) {
|
|
while (len--) {
|
|
QMultiByteUnicodeTable& mb = multiByte[*uchars];
|
|
if ( mb.multiByte ) {
|
|
// Chained multi-byte
|
|
multiByte = mb.multiByte;
|
|
} else {
|
|
result += QChar(mb.unicode);
|
|
multiByte=to_unicode_multiByte;
|
|
}
|
|
uchars++;
|
|
}
|
|
} else {
|
|
while (len--)
|
|
result += QChar(to_unicode[*uchars++]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#if !defined(Q_NO_USING_KEYWORD)
|
|
using QTextCodec::fromUnicode;
|
|
#endif
|
|
QCString fromUnicode(const QString& uc, int& lenInOut) const
|
|
{
|
|
if (lenInOut > (int)uc.length())
|
|
lenInOut = uc.length();
|
|
int rlen = lenInOut*max_bytes_per_char;
|
|
QCString rstr(rlen+1);
|
|
char* cursor = rstr.data();
|
|
char* s=0;
|
|
int l = lenInOut;
|
|
int lout = 0;
|
|
for (int i=0; i<l; i++) {
|
|
QChar ch = uc[i];
|
|
if ( ch == QChar::null ) {
|
|
// special
|
|
*cursor++ = 0;
|
|
} else if ( from_unicode_page[ch.row()] &&
|
|
from_unicode_page[ch.row()][ch.cell()] )
|
|
{
|
|
*cursor++ = from_unicode_page[ch.row()][ch.cell()];
|
|
lout++;
|
|
} else if ( from_unicode_page_multiByte &&
|
|
from_unicode_page_multiByte[ch.row()] &&
|
|
(s=from_unicode_page_multiByte[ch.row()][ch.cell()]) )
|
|
{
|
|
while (*s) {
|
|
*cursor++ = *s++;
|
|
lout++;
|
|
}
|
|
} else {
|
|
*cursor++ = unkn;
|
|
lout++;
|
|
}
|
|
}
|
|
*cursor = 0;
|
|
lenInOut = lout;
|
|
return rstr;
|
|
}
|
|
};
|
|
|
|
QTextCodecFromIODDecoder::QTextCodecFromIODDecoder(const QTextCodecFromIOD* c) :
|
|
codec(c)
|
|
{
|
|
mb = codec->to_unicode_multiByte;
|
|
}
|
|
|
|
QString QTextCodecFromIODDecoder::toUnicode(const char* chars, int len)
|
|
{
|
|
const uchar* uchars = (const uchar*)chars;
|
|
QString result;
|
|
while (len--) {
|
|
QMultiByteUnicodeTable& t = mb[*uchars];
|
|
if ( t.multiByte ) {
|
|
// Chained multi-byte
|
|
mb = t.multiByte;
|
|
} else {
|
|
if ( t.unicode )
|
|
result += QChar(t.unicode);
|
|
mb=codec->to_unicode_multiByte;
|
|
}
|
|
uchars++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#ifndef QT_NO_CODECS
|
|
// Cannot use <pre> or \code
|
|
/*!
|
|
Reads a POSIX2 charmap definition from \a iod.
|
|
The parser recognizes the following lines:
|
|
|
|
<font name="sans">
|
|
<code_set_name> <i>name</i></br>
|
|
<escape_char> <i>character</i></br>
|
|
% alias <i>alias</i></br>
|
|
CHARMAP</br>
|
|
<<i>token</i>> /x<i>hexbyte</i> <U<i>unicode</i>> ...</br>
|
|
<<i>token</i>> /d<i>decbyte</i> <U<i>unicode</i>> ...</br>
|
|
<<i>token</i>> /<i>octbyte</i> <U<i>unicode</i>> ...</br>
|
|
<<i>token</i>> /<i>any</i>/<i>any</i>... <U<i>unicode</i>> ...</br>
|
|
END CHARMAP</br>
|
|
</font>
|
|
|
|
The resulting QTextCodec is returned (and also added to the global
|
|
list of codecs). The name() of the result is taken from the
|
|
code_set_name.
|
|
|
|
Note that a codec constructed in this way uses much more memory
|
|
and is slower than a hand-written QTextCodec subclass, since
|
|
tables in code are kept in memory shared by all Qt applications.
|
|
|
|
\sa loadCharmapFile()
|
|
*/
|
|
QTextCodec* QTextCodec::loadCharmap(QIODevice* iod)
|
|
{
|
|
QTextCodecFromIOD* r = new QTextCodecFromIOD(iod);
|
|
if ( !r->ok() ) {
|
|
delete r;
|
|
r = 0;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/*!
|
|
A convenience function for loadCharmap() that loads the charmap
|
|
definition from the file \a filename.
|
|
*/
|
|
QTextCodec* QTextCodec::loadCharmapFile(QString filename)
|
|
{
|
|
QFile f(filename);
|
|
if (f.open(IO_ReadOnly)) {
|
|
QTextCodecFromIOD* r = new QTextCodecFromIOD(&f);
|
|
if ( !r->ok() )
|
|
delete r;
|
|
else
|
|
return r;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endif //QT_NO_CODECS
|
|
|
|
/*!
|
|
Returns a string representing the current language and
|
|
sublanguage, e.g. "pt" for Portuguese, or "pt_br" for Portuguese/Brazil.
|
|
*/
|
|
|
|
const char* QTextCodec::locale()
|
|
{
|
|
return QLocalePrivate::systemLocaleName();
|
|
}
|
|
|
|
#ifndef QT_NO_CODECS
|
|
|
|
class QSimpleTextCodec: public QTextCodec
|
|
{
|
|
public:
|
|
QSimpleTextCodec( int );
|
|
~QSimpleTextCodec();
|
|
|
|
QString toUnicode(const char* chars, int len) const;
|
|
#if !defined(Q_NO_USING_KEYWORD)
|
|
using QTextCodec::fromUnicode;
|
|
#endif
|
|
QCString fromUnicode(const QString& uc, int& lenInOut ) const;
|
|
unsigned short characterFromUnicode(const QString &str, int pos) const;
|
|
|
|
const char* name() const;
|
|
const char* mimeName() const;
|
|
int mibEnum() const;
|
|
|
|
int heuristicContentMatch(const char* chars, int len) const;
|
|
|
|
int heuristicNameMatch(const char* hint) const;
|
|
#if !defined(Q_NO_USING_KEYWORD)
|
|
using QTextCodec::canEncode;
|
|
#endif
|
|
bool canEncode( QChar ch ) const;
|
|
|
|
void fromUnicode( const QChar *in, unsigned short *out, int length ) const;
|
|
|
|
private:
|
|
void buildReverseMap();
|
|
|
|
int forwardIndex;
|
|
#ifndef Q_WS_QWS
|
|
QMemArray<unsigned char> *reverseMap;
|
|
#endif
|
|
};
|
|
|
|
#ifdef Q_WS_QWS
|
|
static const QSimpleTextCodec * reverseOwner = 0;
|
|
static QMemArray<unsigned char> * reverseMap = 0;
|
|
#endif
|
|
|
|
#define LAST_MIB 2004
|
|
|
|
static const struct {
|
|
const char *mime;
|
|
const char * cs;
|
|
int mib;
|
|
Q_UINT16 values[128];
|
|
} unicodevalues[] = {
|
|
// from RFC 1489, ftp://ftp.isi.edu/in-notes/rfc1489.txt
|
|
{ "KOI8-R", "KOI8-R", 2084,
|
|
{ 0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
|
|
0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
|
|
0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2219/**/, 0x221A, 0x2248,
|
|
0x2264, 0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
|
|
0x2550, 0x2551, 0x2552, 0x0451, 0x2553, 0x2554, 0x2555, 0x2556,
|
|
0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x255C, 0x255D, 0x255E,
|
|
0x255F, 0x2560, 0x2561, 0x0401, 0x2562, 0x2563, 0x2564, 0x2565,
|
|
0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B, 0x256C, 0x00A9,
|
|
0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
|
|
0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
|
|
0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
|
|
0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
|
|
0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
|
|
0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
|
|
0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
|
|
0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A } },
|
|
// /**/ - The BULLET OPERATOR is confused. Some people think
|
|
// it should be 0x2022 (BULLET).
|
|
|
|
// from RFC 2319, ftp://ftp.isi.edu/in-notes/rfc2319.txt
|
|
{ "KOI8-U", "KOI8-U", 2088,
|
|
{ 0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
|
|
0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
|
|
0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2219, 0x221A, 0x2248,
|
|
0x2264, 0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
|
|
0x2550, 0x2551, 0x2552, 0x0451, 0x0454, 0x2554, 0x0456, 0x0457,
|
|
0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x0491, 0x255D, 0x255E,
|
|
0x255F, 0x2560, 0x2561, 0x0401, 0x0404, 0x2563, 0x0406, 0x0407,
|
|
0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x0490, 0x256C, 0x00A9,
|
|
0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
|
|
0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
|
|
0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
|
|
0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
|
|
0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
|
|
0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
|
|
0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
|
|
0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A } },
|
|
|
|
// next bits generated from tables on the Unicode 2.0 CD. we can
|
|
// use these tables since this is part of the transition to using
|
|
// unicode everywhere in qt.
|
|
|
|
// $ for A in 8 9 A B C D E F ; do for B in 0 1 2 3 4 5 6 7 8 9 A B C D E F ; do echo 0x${A}${B} 0xFFFD ; done ; done > /tmp/digits ; for a in 8859-* ; do ( awk '/^0x[89ABCDEF]/{ print $1, $2 }' < $a ; cat /tmp/digits ) | sort | uniq -w4 | cut -c6- | paste '-d ' - - - - - - - - | sed -e 's/ /, /g' -e 's/$/,/' -e '$ s/,$/} },/' -e '1 s/^/{ /' > ~/tmp/$a ; done
|
|
|
|
// then I inserted the files manually.
|
|
{ "ISO-8859-2", "ISO 8859-2", 5,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
|
|
0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
|
|
0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
|
|
0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
|
|
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
|
|
0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
|
|
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
|
|
0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
|
|
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
|
|
0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
|
|
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
|
|
0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9} },
|
|
{ "ISO-8859-3", "ISO 8859-3", 6,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x0126, 0x02D8, 0x00A3, 0x00A4, 0xFFFD, 0x0124, 0x00A7,
|
|
0x00A8, 0x0130, 0x015E, 0x011E, 0x0134, 0x00AD, 0xFFFD, 0x017B,
|
|
0x00B0, 0x0127, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x0125, 0x00B7,
|
|
0x00B8, 0x0131, 0x015F, 0x011F, 0x0135, 0x00BD, 0xFFFD, 0x017C,
|
|
0x00C0, 0x00C1, 0x00C2, 0xFFFD, 0x00C4, 0x010A, 0x0108, 0x00C7,
|
|
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
|
0xFFFD, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x0120, 0x00D6, 0x00D7,
|
|
0x011C, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x016C, 0x015C, 0x00DF,
|
|
0x00E0, 0x00E1, 0x00E2, 0xFFFD, 0x00E4, 0x010B, 0x0109, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
|
0xFFFD, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x0121, 0x00F6, 0x00F7,
|
|
0x011D, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x016D, 0x015D, 0x02D9} },
|
|
{ "ISO-8859-4", "ISO 8859-4", 7,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x0104, 0x0138, 0x0156, 0x00A4, 0x0128, 0x013B, 0x00A7,
|
|
0x00A8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00AD, 0x017D, 0x00AF,
|
|
0x00B0, 0x0105, 0x02DB, 0x0157, 0x00B4, 0x0129, 0x013C, 0x02C7,
|
|
0x00B8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014A, 0x017E, 0x014B,
|
|
0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
|
|
0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x012A,
|
|
0x0110, 0x0145, 0x014C, 0x0136, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
|
0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x0168, 0x016A, 0x00DF,
|
|
0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
|
|
0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x012B,
|
|
0x0111, 0x0146, 0x014D, 0x0137, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
|
0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x0169, 0x016B, 0x02D9} },
|
|
{ "ISO-8859-5", "ISO 8859-5", 8,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
|
|
0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00AD, 0x040E, 0x040F,
|
|
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
|
|
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
|
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
|
|
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
|
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
|
|
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
|
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
|
|
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
|
|
0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
|
|
0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00A7, 0x045E, 0x045F} },
|
|
{ "ISO-8859-6", "ISO 8859-6", 82,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0xFFFD, 0xFFFD, 0xFFFD, 0x00A4, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x060C, 0x00AD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0x061B, 0xFFFD, 0xFFFD, 0xFFFD, 0x061F,
|
|
0xFFFD, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
|
|
0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
|
|
0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637,
|
|
0x0638, 0x0639, 0x063A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
|
|
0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F,
|
|
0x0650, 0x0651, 0x0652, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD} },
|
|
{ "ISO-8859-7", "ISO 8859-7", 10,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x2018, 0x2019, 0x00A3, 0xFFFD, 0xFFFD, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0xFFFD, 0x00AB, 0x00AC, 0x00AD, 0xFFFD, 0x2015,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x0385, 0x0386, 0x00B7,
|
|
0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
|
|
0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
|
|
0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
|
|
0x03A0, 0x03A1, 0xFFFD, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
|
|
0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
|
|
0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
|
|
0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
|
|
0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
|
|
0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0xFFFD} },
|
|
{ "ISO-8859-8-I", "ISO 8859-8-I", 85,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0xFFFD, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x203E,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2017,
|
|
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
|
|
0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
|
|
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
|
|
0x05E8, 0x05E9, 0x05EA, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD} },
|
|
{ "ISO-8859-9", "ISO 8859-9", 12,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
|
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
|
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
|
0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
|
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
|
|
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
|
0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
|
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF} },
|
|
{ "ISO-8859-10", "ISO 8859-10", 13,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x0104, 0x0112, 0x0122, 0x012A, 0x0128, 0x0136, 0x00A7,
|
|
0x013B, 0x0110, 0x0160, 0x0166, 0x017D, 0x00AD, 0x016A, 0x014A,
|
|
0x00B0, 0x0105, 0x0113, 0x0123, 0x012B, 0x0129, 0x0137, 0x00B7,
|
|
0x013C, 0x0111, 0x0161, 0x0167, 0x017E, 0x2015, 0x016B, 0x014B,
|
|
0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
|
|
0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x00CF,
|
|
0x00D0, 0x0145, 0x014C, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0168,
|
|
0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
|
|
0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
|
|
0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x00EF,
|
|
0x00F0, 0x0146, 0x014D, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0169,
|
|
0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0138} },
|
|
{ "ISO-8859-13", "ISO 8859-13", 109,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x201D, 0x00A2, 0x00A3, 0x00A4, 0x201E, 0x00A6, 0x00A7,
|
|
0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00C6,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x201C, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00F8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
|
|
0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
|
|
0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
|
|
0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
|
|
0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
|
|
0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
|
|
0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
|
|
0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
|
|
0x0173, 0x0142, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x2019} },
|
|
{ "ISO-8859-14", "ISO 8859-14", 110,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x1E02, 0x1E03, 0x00A3, 0x010A, 0x010B, 0x1E0A, 0x00A7,
|
|
0x1E80, 0x00A9, 0x1E82, 0x1E0B, 0x1EF2, 0x00AD, 0x00AE, 0x0178,
|
|
0x1E1E, 0x1E1F, 0x0120, 0x0121, 0x1E40, 0x1E41, 0x00B6, 0x1E56,
|
|
0x1E81, 0x1E57, 0x1E83, 0x1E60, 0x1EF3, 0x1E84, 0x1E85, 0x1E61,
|
|
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
|
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
|
0x0174, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x1E6A,
|
|
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x0176, 0x00DF,
|
|
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
|
0x0175, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x1E6B,
|
|
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x0177, 0x00FF} },
|
|
{ "ISO-8859-16", "ISO 8859-16", 112,
|
|
{ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
|
|
0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
|
|
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
|
|
0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
|
|
0x00A0, 0x0104, 0x0105, 0x0141, 0x20AC, 0x201E, 0x0160, 0x00A7,
|
|
0x0161, 0x00A9, 0x0218, 0x00AB, 0x0179, 0x00AD, 0x017A, 0x017B,
|
|
0x00B0, 0x00B1, 0x010C, 0x0142, 0x017D, 0x201D, 0x00B6, 0x00B7,
|
|
0x017E, 0x010D, 0x0219, 0x00BB, 0x0152, 0x0153, 0x0178, 0x017C,
|
|
0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0106, 0x00C6, 0x00C7,
|
|
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
|
0x0110, 0x0143, 0x00D2, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x015A,
|
|
0x0170, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0118, 0x021A, 0x00DF,
|
|
0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x0107, 0x00E6, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
|
0x0111, 0x0144, 0x00F2, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x015B,
|
|
0x0171, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0119, 0x021B, 0x00FF} },
|
|
|
|
// next bits generated again from tables on the Unicode 3.0 CD.
|
|
|
|
// $ for a in CP* ; do ( awk '/^0x[89ABCDEF]/{ print $1, $2 }' < $a ) | sort | sed -e 's/#UNDEF.*$/0xFFFD/' | cut -c6- | paste '-d ' - - - - - - - - | sed -e 's/ /, /g' -e 's/$/,/' -e '$ s/,$/} },/' -e '1 s/^/{ /' > ~/tmp/$a ; done
|
|
|
|
{ "CP 850", "IBM 850", 2009,
|
|
{ 0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
|
|
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
|
|
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
|
|
0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
|
|
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
|
|
0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
|
|
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
|
|
0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
|
|
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
|
|
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
|
|
0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
|
|
0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
|
|
0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
|
|
0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
|
|
0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
|
|
0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0} },
|
|
{ "CP 874", "CP 874", 0, //### what is the mib?
|
|
{ 0x20AC, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2026, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
|
|
0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
|
|
0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
|
|
0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
|
|
0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
|
|
0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
|
|
0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
|
|
0x0E38, 0x0E39, 0x0E3A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0E3F,
|
|
0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
|
|
0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
|
|
0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
|
|
0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD} },
|
|
{ "IBM 866", "IBM 866", 2086,
|
|
{ 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
|
|
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
|
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
|
|
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
|
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
|
|
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
|
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
|
|
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
|
|
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
|
|
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
|
|
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
|
|
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
|
|
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
|
|
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
|
|
0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E,
|
|
0x00B0, 0x2219, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0} },
|
|
|
|
{ "windows-1250", "CP 1250", 2250,
|
|
{ 0x20AC, 0xFFFD, 0x201A, 0xFFFD, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0xFFFD, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0xFFFD, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A,
|
|
0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B,
|
|
0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C,
|
|
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
|
|
0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
|
|
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
|
|
0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
|
|
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
|
|
0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
|
|
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
|
|
0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9} },
|
|
{ "windows-1251", "CP 1251", 2251,
|
|
{ 0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
|
|
0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0xFFFD, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
|
|
0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
|
|
0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
|
|
0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
|
|
0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
|
|
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
|
|
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
|
|
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
|
|
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
|
|
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
|
|
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
|
|
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
|
|
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F} },
|
|
{ "windows-1252", "CP 1252", 2252,
|
|
{ 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFD, 0x017D, 0xFFFD,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFD, 0x017E, 0x0178,
|
|
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
|
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
|
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
|
0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
|
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
|
|
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
|
0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
|
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF} },
|
|
{ "windows-1253", "CP 1253", 2253,
|
|
{ 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0xFFFD, 0x2030, 0xFFFD, 0x2039, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0xFFFD, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0x00A0, 0x0385, 0x0386, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0xFFFD, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x2015,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x00B5, 0x00B6, 0x00B7,
|
|
0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
|
|
0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
|
|
0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
|
|
0x03A0, 0x03A1, 0xFFFD, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
|
|
0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
|
|
0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
|
|
0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
|
|
0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
|
|
0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0xFFFD} },
|
|
{ "windows-1254", "CP 1254", 2254,
|
|
{ 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFD, 0xFFFD, 0x0178,
|
|
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
|
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
|
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
|
0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
|
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
|
|
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
|
0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
|
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF} },
|
|
{ "windows-1255", "CP 1255", 2255,
|
|
{ 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0x02C6, 0x2030, 0xFFFD, 0x2039, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0x02DC, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AA, 0x00A5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
|
0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
|
|
0x05B8, 0x05B9, 0xFFFD, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
|
|
0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3,
|
|
0x05F4, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
|
|
0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
|
|
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
|
|
0x05E8, 0x05E9, 0x05EA, 0xFFFD, 0xFFFD, 0x200E, 0x200F, 0xFFFD} },
|
|
{ "windows-1256", "CP 1256", 2256,
|
|
{ 0x20AC, 0x067E, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0x02C6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
|
|
0x06AF, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0x06A9, 0x2122, 0x0691, 0x203A, 0x0153, 0x200C, 0x200D, 0x06BA,
|
|
0x00A0, 0x060C, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x06BE, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00B8, 0x00B9, 0x061B, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x061F,
|
|
0x06C1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
|
|
0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
|
|
0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00D7,
|
|
0x0637, 0x0638, 0x0639, 0x063A, 0x0640, 0x0641, 0x0642, 0x0643,
|
|
0x00E0, 0x0644, 0x00E2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0649, 0x064A, 0x00EE, 0x00EF,
|
|
0x064B, 0x064C, 0x064D, 0x064E, 0x00F4, 0x064F, 0x0650, 0x00F7,
|
|
0x0651, 0x00F9, 0x0652, 0x00FB, 0x00FC, 0x200E, 0x200F, 0x06D2} },
|
|
{ "windows-1257", "CP 1257", 2257,
|
|
{ 0x20AC, 0xFFFD, 0x201A, 0xFFFD, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0xFFFD, 0x2030, 0xFFFD, 0x2039, 0xFFFD, 0x00A8, 0x02C7, 0x00B8,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0xFFFD, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0x00AF, 0x02DB, 0xFFFD,
|
|
0x00A0, 0xFFFD, 0x00A2, 0x00A3, 0x00A4, 0xFFFD, 0x00A6, 0x00A7,
|
|
0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00C6,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00F8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
|
|
0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
|
|
0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
|
|
0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
|
|
0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
|
|
0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
|
|
0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
|
|
0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
|
|
0x0173, 0x0142, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x02D9} },
|
|
{ "windows-1258", "CP 1258", 2258,
|
|
{ 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
|
|
0x02C6, 0x2030, 0xFFFD, 0x2039, 0x0152, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0x02DC, 0x2122, 0xFFFD, 0x203A, 0x0153, 0xFFFD, 0xFFFD, 0x0178,
|
|
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
|
|
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
|
|
0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
|
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x0300, 0x00CD, 0x00CE, 0x00CF,
|
|
0x0110, 0x00D1, 0x0309, 0x00D3, 0x00D4, 0x01A0, 0x00D6, 0x00D7,
|
|
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x01AF, 0x0303, 0x00DF,
|
|
0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0301, 0x00ED, 0x00EE, 0x00EF,
|
|
0x0111, 0x00F1, 0x0323, 0x00F3, 0x00F4, 0x01A1, 0x00F6, 0x00F7,
|
|
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x01B0, 0x20AB, 0x00FF} },
|
|
|
|
{ "Apple Roman", "Apple Roman", 0,
|
|
{ 0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
|
|
0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
|
|
0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
|
|
0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
|
|
0x2020, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
|
|
0x00AE, 0x00A9, 0x2122, 0x00B4, 0x00A8, 0x2260, 0x00C6, 0x00D8,
|
|
0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5, 0x2202, 0x2211,
|
|
0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x00E6, 0x00F8,
|
|
0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
|
|
0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153,
|
|
0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
|
|
0x00FF, 0x0178, 0x2044, 0x20AC, 0x2039, 0x203A, 0xFB01, 0xFB02,
|
|
0x2021, 0x00B7, 0x201A, 0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1,
|
|
0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 0x00D3, 0x00D4,
|
|
0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0x0131, 0x02C6, 0x02DC,
|
|
0x00AF, 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD, 0x02DB, 0x02C7} },
|
|
|
|
|
|
|
|
// This one is based on the charmap file
|
|
// /usr/share/i18n/charmaps/SAMI-WS2.gz, which is manually adapted
|
|
// to this format by Børre Gaup <boerre@subdimension.com>
|
|
{ "WINSAMI2", "WS2", 0,
|
|
{ 0x20AC, 0xFFFD, 0x010C, 0x0192, 0x010D, 0x01B7, 0x0292, 0x01EE,
|
|
0x01EF, 0x0110, 0x0160, 0x2039, 0x0152, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0x0111, 0x01E6, 0x0161, 0x203A, 0x0153, 0xFFFD, 0xFFFD, 0x0178,
|
|
0x00A0, 0x01E7, 0x01E4, 0x00A3, 0x00A4, 0x01E5, 0x00A6, 0x00A7,
|
|
0x00A8, 0x00A9, 0x021E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x021F,
|
|
0x00B0, 0x00B1, 0x01E8, 0x01E9, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
|
|
0x014A, 0x014B, 0x0166, 0x00BB, 0x0167, 0x00BD, 0x017D, 0x017E,
|
|
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
|
|
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
|
|
0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
|
|
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
|
|
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
|
|
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
|
|
0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
|
|
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF} },
|
|
|
|
|
|
// this one is generated from the charmap file located in /usr/share/i18n/charmaps
|
|
// on most Linux distributions. The thai character set tis620 is byte by byte equivalent
|
|
// to iso8859-11, so we name it 8859-11 here, but recognise the name tis620 too.
|
|
|
|
// $ for A in 8 9 A B C D E F ; do for B in 0 1 2 3 4 5 6 7 8 9 A B C D E F ; do echo x${A}${B} 0xFFFD ; done ; done > /tmp/digits ; ( cut -c25- < TIS-620 ; cat /tmp/digits ) | awk '/^x[89ABCDEF]/{ print $1, $2 }' | sed -e 's/<U/0x/' -e 's/>//' | sort | uniq -w4 | cut -c5- | paste '-d ' - - - - - - - - | sed -e 's/ /, /g' -e 's/$/,/' -e '$ s/,$/} },/' -e '1 s/^/{ /' > ~/tmp/tis-620
|
|
{ "TIS-620", "ISO 8859-11", 2259, // Thai character set mib enum taken from tis620 (which is byte by byte equivalent)
|
|
{ 0x20AC, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2026, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
|
|
0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
|
|
0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
|
|
0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
|
|
0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
|
|
0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
|
|
0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
|
|
0x0E38, 0x0E39, 0x0E3A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0E3F,
|
|
0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
|
|
0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
|
|
0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
|
|
0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD } },
|
|
|
|
/*
|
|
Name: hp-roman8 [HP-PCL5,RFC1345,KXS2]
|
|
MIBenum: 2004
|
|
Source: LaserJet IIP Printer User's Manual,
|
|
HP part no 33471-90901, Hewlet-Packard, June 1989.
|
|
Alias: roman8
|
|
Alias: r8
|
|
Alias: csHPRoman8
|
|
*/
|
|
{ "Roman8", "HP-Roman8", 2004,
|
|
{ 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
|
|
0x00A0, 0x00C0, 0x00C2, 0x00C8, 0x00CA, 0x00CB, 0x00CE, 0x00CF,
|
|
0x00B4, 0x02CB, 0x02C6, 0x00A8, 0x02DC, 0x00D9, 0x00DB, 0x20A4,
|
|
0x00AF, 0x00DD, 0x00FD, 0x00B0, 0x00C7, 0x00E7, 0x00D1, 0x00F1,
|
|
0x00A1, 0x00BF, 0x00A4, 0x00A3, 0x00A5, 0x00A7, 0x0192, 0x00A2,
|
|
0x00E2, 0x00EA, 0x00F4, 0x00FB, 0x00E1, 0x00E9, 0x00F3, 0x00FA,
|
|
0x00E0, 0x00E8, 0x00F2, 0x00F9, 0x00E4, 0x00EB, 0x00F6, 0x00FC,
|
|
0x00C5, 0x00EE, 0x00D8, 0x00C6, 0x00E5, 0x00ED, 0x00F8, 0x00E6,
|
|
0x00C4, 0x00EC, 0x00D6, 0x00DC, 0x00C9, 0x00EF, 0x00DF, 0x00D4,
|
|
0x00C1, 0x00C3, 0x00E3, 0x00D0, 0x00F0, 0x00CD, 0x00CC, 0x00D3,
|
|
0x00D2, 0x00D5, 0x00F5, 0x0160, 0x0161, 0x00DA, 0x0178, 0x00FF,
|
|
0x00DE, 0x00FE, 0x00B7, 0x00B5, 0x00B6, 0x00BE, 0x2014, 0x00BC,
|
|
0x00BD, 0x00AA, 0x00BA, 0x00AB, 0x25A0, 0x00BB, 0x00B1, 0xFFFD } }
|
|
|
|
// if you add more chacater sets at the end, change LAST_MIB above
|
|
};
|
|
|
|
QSimpleTextCodec::QSimpleTextCodec( int i )
|
|
: QTextCodec(), forwardIndex( i )
|
|
{
|
|
#ifndef Q_WS_QWS
|
|
reverseMap = 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
QSimpleTextCodec::~QSimpleTextCodec()
|
|
{
|
|
#ifndef Q_WS_QWS
|
|
delete reverseMap;
|
|
#else
|
|
if ( reverseOwner == this ) {
|
|
delete reverseMap;
|
|
reverseMap = 0;
|
|
reverseOwner = 0;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void QSimpleTextCodec::buildReverseMap()
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
if ( reverseOwner != this ) {
|
|
int m = 0;
|
|
int i = 0;
|
|
while( i < 128 ) {
|
|
if ( unicodevalues[forwardIndex].values[i] > m &&
|
|
unicodevalues[forwardIndex].values[i] < 0xfffd )
|
|
m = unicodevalues[forwardIndex].values[i];
|
|
i++;
|
|
}
|
|
m++;
|
|
if ( !reverseMap )
|
|
reverseMap = new QMemArray<unsigned char>( m );
|
|
if ( m > (int)(reverseMap->size()) )
|
|
reverseMap->resize( m );
|
|
for( i = 0; i < 128 && i < m; i++ )
|
|
(*reverseMap)[i] = (char)i;
|
|
for( ;i < m; i++ )
|
|
(*reverseMap)[i] = 0;
|
|
for( i=128; i<256; i++ ) {
|
|
int u = unicodevalues[forwardIndex].values[i-128];
|
|
if ( u < m )
|
|
(*reverseMap)[u] = (char)(unsigned char)(i);
|
|
}
|
|
reverseOwner = this;
|
|
}
|
|
#else
|
|
if ( !reverseMap ) {
|
|
QMemArray<unsigned char> **map = &((QSimpleTextCodec *)this)->reverseMap;
|
|
int m = 0;
|
|
int i = 0;
|
|
while( i < 128 ) {
|
|
if ( unicodevalues[forwardIndex].values[i] > m &&
|
|
unicodevalues[forwardIndex].values[i] < 0xfffd )
|
|
m = unicodevalues[forwardIndex].values[i];
|
|
i++;
|
|
}
|
|
m++;
|
|
*map = new QMemArray<unsigned char>( m );
|
|
for( i = 0; i < 128 && i < m; i++ )
|
|
(**map)[i] = (char)i;
|
|
for( ;i < m; i++ )
|
|
(**map)[i] = 0;
|
|
for( i=128; i<256; i++ ) {
|
|
int u = unicodevalues[forwardIndex].values[i-128];
|
|
if ( u < m )
|
|
(**map)[u] = (char)(unsigned char)(i);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
QString QSimpleTextCodec::toUnicode(const char* chars, int len) const
|
|
{
|
|
if ( len <= 0 || chars == 0 )
|
|
return QString::null;
|
|
|
|
const unsigned char * c = (const unsigned char *)chars;
|
|
int i;
|
|
|
|
for ( i = 0; i < len; i++ )
|
|
if ( c[i] == '\0' ) {
|
|
len = i;
|
|
break;
|
|
}
|
|
|
|
QString r;
|
|
r.setUnicode(0, len);
|
|
QChar* uc = (QChar*)r.unicode(); // const_cast
|
|
|
|
for ( i = 0; i < len; i++ ) {
|
|
if ( c[i] > 127 )
|
|
uc[i] = unicodevalues[forwardIndex].values[c[i]-128];
|
|
else
|
|
uc[i] = c[i];
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
QCString QSimpleTextCodec::fromUnicode(const QString& uc, int& len ) const
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
if ( this != reverseOwner )
|
|
#else
|
|
if ( !reverseMap )
|
|
#endif
|
|
((QSimpleTextCodec *)this)->buildReverseMap();
|
|
|
|
if ( len <0 || len > (int)uc.length() )
|
|
len = uc.length();
|
|
QCString r( len+1 );
|
|
int i = len;
|
|
int u;
|
|
const QChar* ucp = uc.unicode();
|
|
unsigned char* rp = (unsigned char *)r.data();
|
|
unsigned char* rmp = reverseMap->data();
|
|
int rmsize = (int) reverseMap->size();
|
|
while( i-- )
|
|
{
|
|
u = ucp->unicode();
|
|
*rp = u < 128 ? u : (( u < rmsize ) ? (*(rmp+u)) : '?' );
|
|
if ( *rp == 0 ) *rp = '?';
|
|
rp++;
|
|
ucp++;
|
|
}
|
|
r[len] = 0;
|
|
return r;
|
|
}
|
|
|
|
void QSimpleTextCodec::fromUnicode( const QChar *in, unsigned short *out, int length ) const
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
if ( this != reverseOwner )
|
|
#else
|
|
if ( !reverseMap )
|
|
#endif
|
|
((QSimpleTextCodec *)this)->buildReverseMap();
|
|
|
|
unsigned char* rmp = reverseMap->data();
|
|
int rmsize = (int) reverseMap->size();
|
|
while ( length-- ) {
|
|
unsigned short u = in->unicode();
|
|
*out = u < 128 ? u : (( u < rmsize ) ? (*(rmp+u)) : 0 );
|
|
++in;
|
|
++out;
|
|
}
|
|
}
|
|
|
|
unsigned short QSimpleTextCodec::characterFromUnicode(const QString &str, int pos) const
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
if ( this != reverseOwner )
|
|
#else
|
|
if ( !reverseMap )
|
|
#endif
|
|
((QSimpleTextCodec *)this)->buildReverseMap();
|
|
|
|
unsigned short u = str[pos].unicode();
|
|
unsigned char* rmp = reverseMap->data();
|
|
int rmsize = (int) reverseMap->size();
|
|
return u < 128 ? u : (( u < rmsize ) ? (*(rmp+u)) : 0 );
|
|
}
|
|
|
|
bool QSimpleTextCodec::canEncode( QChar ch ) const
|
|
{
|
|
#ifdef Q_WS_QWS
|
|
if ( this != reverseOwner )
|
|
#else
|
|
if ( !reverseMap )
|
|
#endif
|
|
((QSimpleTextCodec *)this)->buildReverseMap();
|
|
|
|
unsigned short u = ch.unicode();
|
|
unsigned char* rmp = reverseMap->data();
|
|
int rmsize = (int) reverseMap->size();
|
|
return u < 128 ? TRUE : (( u < rmsize ) ? (*(rmp+u) != 0) : FALSE );
|
|
}
|
|
|
|
const char* QSimpleTextCodec::name() const
|
|
{
|
|
return unicodevalues[forwardIndex].cs;
|
|
}
|
|
|
|
const char* QSimpleTextCodec::mimeName() const
|
|
{
|
|
return unicodevalues[forwardIndex].mime;
|
|
}
|
|
|
|
|
|
int QSimpleTextCodec::mibEnum() const
|
|
{
|
|
return unicodevalues[forwardIndex].mib;
|
|
}
|
|
|
|
int QSimpleTextCodec::heuristicNameMatch(const char* hint) const
|
|
{
|
|
if ( qstricmp( hint, mimeName() ) == 0 )
|
|
return 10000; // return a large value
|
|
if ( hint[0]=='k' ) {
|
|
QCString lhint = QCString(hint).lower();
|
|
// Help people with messy fonts
|
|
if ( lhint == "koi8-1" )
|
|
return QTextCodec::heuristicNameMatch("koi8-r")-1;
|
|
if ( lhint == "koi8-ru" )
|
|
return QTextCodec::heuristicNameMatch("koi8-r")-1;
|
|
} else if ( hint[0] == 't' && mibEnum() == 2259 /* iso8859-11 */ ) {
|
|
// 8859-11 and tis620 are byte by byte equivalent
|
|
int i = simpleHeuristicNameMatch("tis620-0", hint);
|
|
if( !i )
|
|
i = simpleHeuristicNameMatch("tis-620", hint);
|
|
if( i ) return i;
|
|
} else if ( mibEnum() == 82 /* ISO 8859-6 */ ) {
|
|
int i = simpleHeuristicNameMatch("ISO 8859-6-I", hint);
|
|
if ( i )
|
|
return i;
|
|
}
|
|
return QTextCodec::heuristicNameMatch(hint);
|
|
}
|
|
|
|
int QSimpleTextCodec::heuristicContentMatch(const char* chars, int len) const
|
|
{
|
|
if ( len<1 || !chars )
|
|
return -1;
|
|
int i = 0;
|
|
const uchar * c = (const unsigned char *)chars;
|
|
int r = 0;
|
|
while( i<len && c && *c ) {
|
|
if ( *c >= 128 ) {
|
|
if ( unicodevalues[forwardIndex].values[(*c)-128] == 0xfffd )
|
|
return -1;
|
|
}
|
|
if ( (*c >= ' ' && *c < 127) ||
|
|
*c == '\n' || *c == '\t' || *c == '\r' )
|
|
r++;
|
|
i++;
|
|
c++;
|
|
}
|
|
if ( mibEnum()==4 )
|
|
r+=1;
|
|
return r;
|
|
}
|
|
|
|
#endif
|
|
|
|
class QLatin1Codec : public QTextCodec
|
|
{
|
|
public:
|
|
#if !defined(Q_NO_USING_KEYWORD)
|
|
using QTextCodec::fromUnicode;
|
|
using QTextCodec::toUnicode;
|
|
#endif
|
|
QString toUnicode(const char* chars, int len) const;
|
|
QCString fromUnicode(const QString& uc, int& lenInOut ) const;
|
|
void fromUnicode( const QChar *in, unsigned short *out, int length ) const;
|
|
unsigned short characterFromUnicode(const QString &str, int pos) const;
|
|
|
|
const char* name() const;
|
|
const char* mimeName() const;
|
|
int mibEnum() const;
|
|
|
|
int heuristicContentMatch(const char* chars, int len) const;
|
|
|
|
private:
|
|
int forwardIndex;
|
|
};
|
|
|
|
|
|
QString QLatin1Codec::toUnicode(const char* chars, int len) const
|
|
{
|
|
if ( chars == 0 )
|
|
return QString::null;
|
|
|
|
return QString::fromLatin1(chars, len);
|
|
}
|
|
|
|
|
|
QCString QLatin1Codec::fromUnicode(const QString& uc, int& len ) const
|
|
{
|
|
if ( len <0 || len > (int)uc.length() )
|
|
len = uc.length();
|
|
QCString r( len+1 );
|
|
char *d = r.data();
|
|
int i = 0;
|
|
const QChar *ch = uc.unicode();
|
|
while ( i < len ) {
|
|
d[i] = ch->row() ? '?' : ch->cell();
|
|
i++;
|
|
ch++;
|
|
}
|
|
r[len] = 0;
|
|
return r;
|
|
}
|
|
|
|
void QLatin1Codec::fromUnicode( const QChar *in, unsigned short *out, int length ) const
|
|
{
|
|
while ( length-- ) {
|
|
*out = in->row() ? 0 : in->cell();
|
|
++in;
|
|
++out;
|
|
}
|
|
}
|
|
|
|
unsigned short QLatin1Codec::characterFromUnicode(const QString &str, int pos) const
|
|
{
|
|
const QChar *ch = str.unicode() + pos;
|
|
if (ch->row())
|
|
return 0;
|
|
return (unsigned short) ch->cell();
|
|
}
|
|
|
|
|
|
const char* QLatin1Codec::name() const
|
|
{
|
|
return "ISO 8859-1";
|
|
}
|
|
|
|
const char* QLatin1Codec::mimeName() const
|
|
{
|
|
return "ISO-8859-1";
|
|
}
|
|
|
|
|
|
int QLatin1Codec::mibEnum() const
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
int QLatin1Codec::heuristicContentMatch(const char* chars, int len) const
|
|
{
|
|
if ( len<1 || !chars )
|
|
return -1;
|
|
int i = 0;
|
|
const uchar * c = (const unsigned char *)chars;
|
|
int r = 0;
|
|
while( i<len && c && *c ) {
|
|
if ( *c >= 0x80 && *c < 0xa0 )
|
|
return -1;
|
|
if ( (*c >= ' ' && *c < 127) ||
|
|
*c == '\n' || *c == '\t' || *c == '\r' )
|
|
r++;
|
|
i++;
|
|
c++;
|
|
}
|
|
if ( this == (const QTextCodec *)codecForLocale() )
|
|
r += 5;
|
|
return r;
|
|
}
|
|
|
|
class QLatin15Codec: public QLatin1Codec
|
|
{
|
|
public:
|
|
QString toUnicode(const char* chars, int len) const;
|
|
#if !defined(Q_NO_USING_KEYWORD)
|
|
using QLatin1Codec::fromUnicode;
|
|
#endif
|
|
QCString fromUnicode(const QString& uc, int& lenInOut ) const;
|
|
void fromUnicode( const QChar *in, unsigned short *out, int length ) const;
|
|
unsigned short characterFromUnicode(const QString &str, int pos) const;
|
|
|
|
const char* name() const;
|
|
const char* mimeName() const;
|
|
int mibEnum() const;
|
|
|
|
private:
|
|
int forwardIndex;
|
|
};
|
|
|
|
|
|
QString QLatin15Codec::toUnicode(const char* chars, int len) const
|
|
{
|
|
if ( chars == 0 )
|
|
return QString::null;
|
|
|
|
QString str = QString::fromLatin1(chars, len);
|
|
QChar *uc = (QChar *)str.unicode();
|
|
while( len-- ) {
|
|
switch( uc->unicode() ) {
|
|
case 0xa4:
|
|
*uc = 0x20ac;
|
|
break;
|
|
case 0xa6:
|
|
*uc = 0x0160;
|
|
break;
|
|
case 0xa8:
|
|
*uc = 0x0161;
|
|
break;
|
|
case 0xb4:
|
|
*uc = 0x017d;
|
|
break;
|
|
case 0xb8:
|
|
*uc = 0x017e;
|
|
break;
|
|
case 0xbc:
|
|
*uc = 0x0152;
|
|
break;
|
|
case 0xbd:
|
|
*uc = 0x0153;
|
|
break;
|
|
case 0xbe:
|
|
*uc = 0x0178;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
uc++;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static inline unsigned char
|
|
latin15CharFromUnicode( unsigned short uc, bool replacement = TRUE )
|
|
{
|
|
uchar c;
|
|
if ( uc < 0x0100 ) {
|
|
if ( uc > 0xa3 && uc < 0xbf ) {
|
|
switch( uc ) {
|
|
case 0xa4:
|
|
case 0xa6:
|
|
case 0xa8:
|
|
case 0xb4:
|
|
case 0xb8:
|
|
case 0xbc:
|
|
case 0xbd:
|
|
case 0xbe:
|
|
c = replacement ? '?' : 0;
|
|
break;
|
|
default:
|
|
c = (unsigned char) uc;
|
|
break;
|
|
}
|
|
} else {
|
|
c = (unsigned char) uc;
|
|
}
|
|
} else {
|
|
if ( uc == 0x20ac )
|
|
c = 0xa4;
|
|
else if ( (uc & 0xff00) == 0x0100 ) {
|
|
switch( uc ) {
|
|
case 0x0160:
|
|
c = 0xa6;
|
|
break;
|
|
case 0x0161:
|
|
c = 0xa8;
|
|
break;
|
|
case 0x017d:
|
|
c = 0xb4;
|
|
break;
|
|
case 0x017e:
|
|
c = 0xb8;
|
|
break;
|
|
case 0x0152:
|
|
c = 0xbc;
|
|
break;
|
|
case 0x0153:
|
|
c = 0xbd;
|
|
break;
|
|
case 0x0178:
|
|
c = 0xbe;
|
|
break;
|
|
default:
|
|
c = replacement ? '?' : 0;
|
|
}
|
|
} else {
|
|
c = replacement ? '?' : 0;
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
|
|
|
|
void QLatin15Codec::fromUnicode( const QChar *in, unsigned short *out, int length ) const
|
|
{
|
|
while ( length-- ) {
|
|
*out = latin15CharFromUnicode( in->unicode(), FALSE );
|
|
++in;
|
|
++out;
|
|
}
|
|
}
|
|
|
|
|
|
QCString QLatin15Codec::fromUnicode(const QString& uc, int& len ) const
|
|
{
|
|
if ( len <0 || len > (int)uc.length() )
|
|
len = uc.length();
|
|
QCString r( len+1 );
|
|
char *d = r.data();
|
|
int i = 0;
|
|
const QChar *ch = uc.unicode();
|
|
while ( i < len ) {
|
|
d[i] = latin15CharFromUnicode( ch->unicode() );
|
|
i++;
|
|
ch++;
|
|
}
|
|
r[len] = 0;
|
|
return r;
|
|
}
|
|
|
|
unsigned short QLatin15Codec::characterFromUnicode(const QString &str, int pos) const
|
|
{
|
|
return latin15CharFromUnicode( str.unicode()[pos].unicode(), FALSE );
|
|
}
|
|
|
|
|
|
const char* QLatin15Codec::name() const
|
|
{
|
|
return "ISO 8859-15";
|
|
}
|
|
|
|
const char* QLatin15Codec::mimeName() const
|
|
{
|
|
return "ISO-8859-15";
|
|
}
|
|
|
|
|
|
int QLatin15Codec::mibEnum() const
|
|
{
|
|
return 111;
|
|
}
|
|
|
|
static QTextCodec *checkForCodec(const char *name) {
|
|
QTextCodec *c = QTextCodec::codecForName(name);
|
|
if (!c) {
|
|
const char *at = strchr(name, '@');
|
|
if (at) {
|
|
QCString n(name, at - name + 1);
|
|
c = QTextCodec::codecForName(n.data());
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/* the next two functions are implicitely thread safe,
|
|
as they are only called by setup() which uses a mutex.
|
|
*/
|
|
static void setupLocaleMapper()
|
|
{
|
|
#ifdef Q_OS_WIN32
|
|
localeMapper = QTextCodec::codecForName( "System" );
|
|
#else
|
|
|
|
#if defined (_XOPEN_UNIX) && !defined(Q_OS_QNX6) && !defined(Q_OS_OSF) && !defined(Q_OS_MAC)
|
|
char *charset = nl_langinfo (CODESET);
|
|
if ( charset )
|
|
localeMapper = QTextCodec::codecForName( charset );
|
|
#endif
|
|
|
|
if ( !localeMapper ) {
|
|
// Very poorly defined and followed standards causes lots of code
|
|
// to try to get all the cases...
|
|
|
|
// Try to determine locale codeset from locale name assigned to
|
|
// LC_CTYPE category.
|
|
|
|
// First part is getting that locale name. First try setlocale() which
|
|
// definitely knows it, but since we cannot fully trust it, get ready
|
|
// to fall back to environment variables.
|
|
char * ctype = qstrdup( setlocale( LC_CTYPE, 0 ) );
|
|
|
|
// Get the first nonempty value from $LC_ALL, $LC_CTYPE, and $LANG
|
|
// environment variables.
|
|
char * lang = qstrdup( getenv("LC_ALL") );
|
|
if ( !lang || lang[0] == 0 || strcmp( lang, "C" ) == 0 ) {
|
|
if ( lang ) delete [] lang;
|
|
lang = qstrdup( getenv("LC_CTYPE") );
|
|
}
|
|
if ( !lang || lang[0] == 0 || strcmp( lang, "C" ) == 0 ) {
|
|
if ( lang ) delete [] lang;
|
|
lang = qstrdup( getenv("LANG") );
|
|
}
|
|
|
|
// Now try these in order:
|
|
// 1. CODESET from ctype if it contains a .CODESET part (e.g. en_US.ISO8859-15)
|
|
// 2. CODESET from lang if it contains a .CODESET part
|
|
// 3. ctype (maybe the locale is named "ISO-8859-1" or something)
|
|
// 4. locale (ditto)
|
|
// 5. check for "@euro"
|
|
// 6. guess locale from ctype unless ctype is "C"
|
|
// 7. guess locale from lang
|
|
|
|
// 1. CODESET from ctype if it contains a .CODESET part (e.g. en_US.ISO8859-15)
|
|
char * codeset = ctype ? strchr( ctype, '.' ) : 0;
|
|
if ( codeset && *codeset == '.' )
|
|
localeMapper = checkForCodec( codeset + 1 );
|
|
|
|
// 2. CODESET from lang if it contains a .CODESET part
|
|
codeset = lang ? strchr( lang, '.' ) : 0;
|
|
if ( !localeMapper && codeset && *codeset == '.' )
|
|
localeMapper = checkForCodec( codeset + 1 );
|
|
|
|
// 3. ctype (maybe the locale is named "ISO-8859-1" or something)
|
|
if ( !localeMapper && ctype && *ctype != 0 && strcmp (ctype, "C") != 0 )
|
|
localeMapper = checkForCodec( ctype );
|
|
|
|
// 4. locale (ditto)
|
|
if ( !localeMapper && lang && *lang != 0 )
|
|
localeMapper = checkForCodec( lang );
|
|
|
|
// 5. "@euro"
|
|
if ( ( !localeMapper && ctype && strstr( ctype, "@euro" ) ) || (lang && strstr( lang, "@euro" ) ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-15" );
|
|
|
|
// 6. guess locale from ctype unless ctype is "C"
|
|
// 7. guess locale from lang
|
|
char * try_by_name = ctype;
|
|
if ( ctype && *ctype != 0 && strcmp (ctype, "C") != 0 )
|
|
try_by_name = lang;
|
|
|
|
// Now do the guessing.
|
|
if ( lang && *lang && !localeMapper && try_by_name && *try_by_name ) {
|
|
if ( try_locale_list( iso8859_15locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-15" );
|
|
else if ( try_locale_list( iso8859_2locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-2" );
|
|
else if ( try_locale_list( iso8859_3locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-3" );
|
|
else if ( try_locale_list( iso8859_4locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-4" );
|
|
else if ( try_locale_list( iso8859_5locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-5" );
|
|
else if ( try_locale_list( iso8859_6locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-6" );
|
|
else if ( try_locale_list( iso8859_7locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-7" );
|
|
else if ( try_locale_list( iso8859_8locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-8-I" );
|
|
else if ( try_locale_list( iso8859_9locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-9" );
|
|
else if ( try_locale_list( iso8859_13locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-13" );
|
|
else if ( try_locale_list( tis_620locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-11" );
|
|
else if ( try_locale_list( koi8_ulocales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "KOI8-U" );
|
|
else if ( try_locale_list( cp_1251locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "CP 1251" );
|
|
else if ( try_locale_list( pt_154locales, lang ) )
|
|
localeMapper = QTextCodec::codecForName( "PT 154" );
|
|
else if ( try_locale_list( probably_koi8_rlocales, lang ) )
|
|
localeMapper = ru_RU_hack( lang );
|
|
}
|
|
|
|
delete [] ctype;
|
|
delete [] lang;
|
|
}
|
|
if ( localeMapper && localeMapper->mibEnum() == 11 )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-8-I" );
|
|
|
|
// If everything failed, we default to 8859-1
|
|
// We could perhaps default to 8859-15.
|
|
if ( !localeMapper )
|
|
localeMapper = QTextCodec::codecForName( "ISO 8859-1" );
|
|
#endif
|
|
}
|
|
|
|
|
|
static void realSetup()
|
|
{
|
|
#if defined(QT_CHECK_STATE)
|
|
if ( destroying_is_ok )
|
|
qWarning( "QTextCodec: creating new codec during codec cleanup!" );
|
|
#endif
|
|
all = new QValueList<QTextCodec*>;
|
|
|
|
(void)new QLatin1Codec;
|
|
(void)new QLatin15Codec;
|
|
(void)new QUtf8Codec;
|
|
(void)new QUtf16Codec;
|
|
|
|
#ifndef QT_NO_CODECS
|
|
int i = 0;
|
|
do {
|
|
(void)new QSimpleTextCodec( i );
|
|
} while( unicodevalues[i++].mib != LAST_MIB );
|
|
|
|
(void)new QTsciiCodec;
|
|
|
|
for (i = 0; i < 9; ++i) {
|
|
(void)new QIsciiCodec(i);
|
|
}
|
|
#endif // QT_NO_CODECS
|
|
#ifndef QT_NO_CODEC_HEBREW
|
|
(void)new QHebrewCodec;
|
|
#endif
|
|
#ifndef QT_NO_BIG_CODECS
|
|
(void)new QBig5Codec;
|
|
(void)new QBig5hkscsCodec;
|
|
(void)new QEucJpCodec;
|
|
(void)new QEucKrCodec;
|
|
(void)new QGb2312Codec;
|
|
(void)new QGbkCodec;
|
|
(void)new QGb18030Codec;
|
|
(void)new QJisCodec;
|
|
(void)new QSjisCodec;
|
|
#endif // QT_NO_BIG_CODECS
|
|
|
|
#ifdef Q_OS_WIN32
|
|
(void) new QWindowsLocalCodec;
|
|
#endif // Q_OS_WIN32
|
|
|
|
if ( !localeMapper )
|
|
setupLocaleMapper();
|
|
}
|
|
|
|
void QTextCodec::fromUnicodeInternal( const QChar *in, unsigned short *out, int length )
|
|
{
|
|
switch( mibEnum() ) {
|
|
#ifndef QT_NO_CODECS
|
|
case 2084:
|
|
case 2088:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 82:
|
|
case 10:
|
|
case 85:
|
|
case 12:
|
|
case 13:
|
|
case 109:
|
|
case 110:
|
|
case 2004:
|
|
case 2009:
|
|
case 2086:
|
|
case 2250:
|
|
case 2251:
|
|
case 2252:
|
|
case 2253:
|
|
case 2254:
|
|
case 2255:
|
|
case 2256:
|
|
case 2257:
|
|
case 2258:
|
|
case 2259:
|
|
((QSimpleTextCodec *)this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
#if !defined(QT_NO_BIG_CODECS) && defined(Q_WS_X11)
|
|
// the QFont*Codecs are only used on X11
|
|
|
|
case 15:
|
|
((QFontJis0201Codec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case 63:
|
|
((QFontJis0208Codec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case 36:
|
|
((QFontKsc5601Codec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case 57:
|
|
((QFontGb2312Codec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case -113:
|
|
((QFontGbkCodec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case -114:
|
|
((QFontGb18030_0Codec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case -2026:
|
|
((QFontBig5Codec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case -2101:
|
|
((QFontBig5hkscsCodec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case -4242:
|
|
((QFontLaoCodec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
#endif
|
|
#endif // QT_NO_CODECS
|
|
|
|
case 4:
|
|
((QLatin1Codec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
case 111:
|
|
((QLatin15Codec *) this)->fromUnicode( in, out, length );
|
|
break;
|
|
|
|
default:
|
|
{
|
|
QConstString string( in, length );
|
|
QString str = string.string();
|
|
for ( int i = 0; i < length; i++ )
|
|
out[i] = characterFromUnicode( str, i );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\fn QTextCodec* QTextCodec::codecForTr()
|
|
|
|
Returns the codec used by QObject::tr() on its argument. If this
|
|
function returns 0 (the default), tr() assumes Latin-1.
|
|
|
|
\sa setCodecForTr()
|
|
*/
|
|
|
|
/*!
|
|
\fn void QTextCodec::setCodecForTr(QTextCodec *c)
|
|
\nonreentrant
|
|
|
|
Sets the codec used by QObject::tr() on its argument to \a c. If
|
|
\a c is 0 (the default), tr() assumes Latin-1.
|
|
|
|
If the literal quoted text in the program is not in the Latin-1
|
|
encoding, this function can be used to set the appropriate
|
|
encoding. For example, software developed by Korean programmers
|
|
might use eucKR for all the text in the program, in which case the
|
|
main() function might look like this:
|
|
|
|
\code
|
|
int main(int argc, char** argv)
|
|
{
|
|
QApplication app(argc, argv);
|
|
... install any additional codecs ...
|
|
QTextCodec::setCodecForTr( QTextCodec::codecForName("eucKR") );
|
|
...
|
|
}
|
|
\endcode
|
|
|
|
Note that this is not the way to select the encoding that the \e
|
|
user has chosen. For example, to convert an application containing
|
|
literal English strings to Korean, all that is needed is for the
|
|
English strings to be passed through tr() and for translation
|
|
files to be loaded. For details of internationalization, see the
|
|
\link i18n.html Qt internationalization documentation\endlink.
|
|
|
|
\sa codecForTr(), setCodecForTr(), setCodecForCStrings()
|
|
*/
|
|
|
|
|
|
/*!
|
|
\fn QTextCodec* QTextCodec::codecForCStrings()
|
|
|
|
Returns the codec used by QString to convert to and from const
|
|
char* and QCStrings. If this function returns 0 (the default),
|
|
QString assumes Latin-1.
|
|
|
|
\sa setCodecForCStrings()
|
|
*/
|
|
|
|
/*!
|
|
\fn void QTextCodec::setCodecForCStrings(QTextCodec *c)
|
|
\nonreentrant
|
|
|
|
Sets the codec used by QString to convert to and from const char*
|
|
and QCStrings. If \a c is 0 (the default), QString assumes Latin-1.
|
|
|
|
\warning Some codecs do not preserve the characters in the ascii
|
|
range (0x00 to 0x7f). For example, the Japanese Shift-JIS
|
|
encoding maps the backslash character (0x5a) to the Yen character.
|
|
This leads to unexpected results when using the backslash
|
|
character to escape characters in strings used in e.g. regular
|
|
expressions. Use QString::fromLatin1() to preserve characters in
|
|
the ascii range when needed.
|
|
|
|
\sa codecForCStrings(), setCodecForTr(), setCodecForCStrings()
|
|
*/
|
|
|
|
|
|
QTextCodec *QTextCodec::cftr = 0;
|
|
QTextCodec *QTextCodec::cfcs = 0;
|
|
|
|
|
|
#endif // QT_NO_TEXTCODEC
|