QTextCodecFromIOD Class Reference

Inheritance diagram for QTextCodecFromIOD:

Public Member Functions
	QTextCodecFromIOD (QIODevice *iod)
	~QTextCodecFromIOD ()
bool	ok () const
QTextDecoder *	makeDecoder () const
const char *	name () const
int	mibEnum () const
int	heuristicContentMatch (const char *, int) const
int	heuristicNameMatch (const char *hint) const
QString	toUnicode (const char *chars, int len) const
QCString	fromUnicode (const QString &uc, int &lenInOut) const
Public Member Functions inherited from QTextCodec
virtual	~QTextCodec ()
virtual QTextEncoder *	makeEncoder () const
QCString	fromUnicode (const QString &uc) const
QString	toUnicode (const QByteArray &, int len) const
QString	toUnicode (const QByteArray &) const
QString	toUnicode (const char *chars) const
virtual bool	canEncode (QChar) const
virtual bool	canEncode (const QString &) const

Private Member Functions
bool	stateless () const

Private Attributes
QCString	n
char **	from_unicode_page
char ***	from_unicode_page_multibyte
char	unkn
ushort *	to_unicode
QMultiByteUnicodeTable *	to_unicode_multibyte
int	max_bytes_per_char
QStrList	aliases

Friends
class	QTextCodecFromIODDecoder

Additional Inherited Members
Static Public Member Functions inherited from QTextCodec
static QTextCodec *	loadCharmap (QIODevice *)
static QTextCodec *	loadCharmapFile (QString filename)
static QTextCodec *	codecForMib (int mib)
static QTextCodec *	codecForName (const char *hint, int accuracy=0)
static QTextCodec *	codecForContent (const char *chars, int len)
static QTextCodec *	codecForIndex (int i)
static QTextCodec *	codecForLocale ()
static void	deleteAllCodecs ()
static const char *	locale ()
Protected Member Functions inherited from QTextCodec
	QTextCodec ()
Static Protected Member Functions inherited from QTextCodec
static int	simpleHeuristicNameMatch (const char *name, const char *hint)

Detailed Description

Definition at line 953 of file qtextcodec.cpp.

Constructor & Destructor Documentation

QTextCodecFromIOD::QTextCodecFromIOD ( QIODevice *  iod )

inline

Definition at line 973 of file qtextcodec.cpp.

    {
        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=0,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 = (int)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::~QTextCodecFromIOD ( )

inline

Definition at line 1103 of file qtextcodec.cpp.

    {
        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;
    }

Member Function Documentation

QCString QTextCodecFromIOD::fromUnicode ( const QString &  uc, int &  lenInOut  ) const

inlinevirtual

Subclasses of QTextCodec must reimplement either this function or makeEncoder(). It converts the first lenInOut characters of uc from Unicode to the encoding of the subclass. If lenInOut is negative or too large, the length of uc is used instead.

The value returned is the property of the caller, which is responsible for deleting it with "delete []". The length of the resulting Unicode character sequence is returned in lenInOut.

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 must reimplement one function or the other to avoid infinite recursion.

Reimplemented from QTextCodec.

Definition at line 1189 of file qtextcodec.cpp.

    {
        if (lenInOut > (int)uc.length())
            lenInOut = uc.length();
        int rlen = lenInOut*max_bytes_per_char;
        QCString rstr(rlen);
        char* cursor = rstr.rawData();
        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;
    }

int QTextCodecFromIOD::heuristicContentMatch ( const char *  chars, int  len  ) const

inlinevirtual

Subclasses of QTextCodec must reimplement this function. It examines the first len bytes of 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. Any negative return value indicates that the text is detectably not in the encoding (eg. it contains undefined characters). 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 len. Thus, most decoders will return -1, 0, or -len.

The characters are not null terminated.

See also

codecForContent().

Implements QTextCodec.

Definition at line 1146 of file qtextcodec.cpp.

    {
        return 0;
    }

int QTextCodecFromIOD::heuristicNameMatch ( const char *  hint ) const

inlinevirtual

Returns a value indicating how likely this decoder is for decoding some format that has the given name.

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.

Reimplemented from QTextCodec.

Definition at line 1151 of file qtextcodec.cpp.

    {
        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;
    }

QTextDecoder* QTextCodecFromIOD::makeDecoder ( ) const

inlinevirtual

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 sufficient for only the simplest encodings where each byte corresponds to exactly one Unicode character.

The caller is responsible for deleting the returned object.

Reimplemented from QTextCodec.

Definition at line 1128 of file qtextcodec.cpp.

    {
        if ( stateless() )
            return QTextCodec::makeDecoder();
        else
            return new QTextCodecFromIODDecoder(this);
    }

int QTextCodecFromIOD::mibEnum ( ) const

inlinevirtual

Subclasses of QTextCodec must reimplement this function. It returns the MIBenum (see the IANA character-sets encoding file for more information). It is important that each QTextCodec subclass return the correct unique value for this function.

Implements QTextCodec.

Definition at line 1141 of file qtextcodec.cpp.

    {
        return 0; // #### Unknown.
    }

const char* QTextCodecFromIOD::name ( ) const

inlinevirtual

Subclasses of QTextCodec 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:

• 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 hint, such as "iso8859-1" for Latin-1 fonts, "koi8-r" for Russian KOI8 fonts. The default algorithm of heuristicNameMatch() uses name().
• Some applications may use this function to present encodings to the end user.

Implements QTextCodec.

Definition at line 1136 of file qtextcodec.cpp.

    {
        return n;
    }

bool QTextCodecFromIOD::ok ( ) const

inline

Definition at line 1123 of file qtextcodec.cpp.

    {
        return !!from_unicode_page;
    }

bool QTextCodecFromIOD::stateless ( ) const

inlineprivate

Definition at line 970 of file qtextcodec.cpp.

{ return !to_unicode_multibyte; }

QString QTextCodecFromIOD::toUnicode ( const char *  chars, int  len  ) const

inlinevirtual

Subclasses of QTextCodec must reimplement this function or makeDecoder(). It converts the first len characters of 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 must reimplement one function or the other to avoid infinite recursion.

Reimplemented from QTextCodec.

Definition at line 1165 of file qtextcodec.cpp.

    {
        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;
    }

Friends And Related Function Documentation

friend class QTextCodecFromIODDecoder

friend

Definition at line 954 of file qtextcodec.cpp.

Member Data Documentation

QStrList QTextCodecFromIOD::aliases

private

Definition at line 968 of file qtextcodec.cpp.

char** QTextCodecFromIOD::from_unicode_page

private

Definition at line 960 of file qtextcodec.cpp.

char*** QTextCodecFromIOD::from_unicode_page_multibyte

private

Definition at line 961 of file qtextcodec.cpp.

int QTextCodecFromIOD::max_bytes_per_char

private

Definition at line 967 of file qtextcodec.cpp.

QCString QTextCodecFromIOD::n

private

Definition at line 956 of file qtextcodec.cpp.

ushort* QTextCodecFromIOD::to_unicode

private

Definition at line 965 of file qtextcodec.cpp.

QMultiByteUnicodeTable* QTextCodecFromIOD::to_unicode_multibyte

private

Definition at line 966 of file qtextcodec.cpp.

char QTextCodecFromIOD::unkn

private

Definition at line 962 of file qtextcodec.cpp.

---

The documentation for this class was generated from the following file:

• doxygen-1.8.11/qtools/qtextcodec.cpp