/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the utils of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <qlist.h>

#include <qhash.h>

#include <qfile.h>

#include <qbytearray.h>

#include <qstring.h>

#include <qchar.h>

#include <qvector.h>

#include <qdebug.h>

#if 0

#include <private/qunicodetables_p.h>

#endif

#define DATA_VERSION_S "5.0"

#define DATA_VERSION_STR "QChar::Unicode_5_0"

#define LAST_CODEPOINT 0x10ffff

#define LAST_CODEPOINT_STR "0x10ffff"

static QHash<QByteArray, QChar::UnicodeVersion> age_map;

static void initAgeMap()

{

    struct AgeMap {

        const QChar::UnicodeVersion version;

        const char *age;

    } ageMap[] = {

        { QChar::Unicode_1_1,   "1.1" },

        { QChar::Unicode_2_0,   "2.0" },

        { QChar::Unicode_2_1_2, "2.1" },

        { QChar::Unicode_3_0,   "3.0" },

        { QChar::Unicode_3_1,   "3.1" },

        { QChar::Unicode_3_2,   "3.2" },

        { QChar::Unicode_4_0,   "4.0" },

        { QChar::Unicode_4_1,   "4.1" },

        { QChar::Unicode_5_0,   "5.0" },

        { QChar::Unicode_Unassigned, 0 }

    };

    AgeMap *d = ageMap;

    while (d->age) {

        age_map.insert(d->age, d->version);

        ++d;

    }

}

static const char *grapheme_break_string =

    "    enum GraphemeBreak {\n"

    "        GraphemeBreakOther,\n"

    "        GraphemeBreakCR,\n"

    "        GraphemeBreakLF,\n"

    "        GraphemeBreakControl,\n"

    "        GraphemeBreakExtend,\n"

    "        GraphemeBreakL,\n"

    "        GraphemeBreakV,\n"

    "        GraphemeBreakT,\n"

    "        GraphemeBreakLV,\n"

    "        GraphemeBreakLVT\n"

    "    };\n\n";

enum GraphemeBreak {

    GraphemeBreakOther,

    GraphemeBreakCR,

    GraphemeBreakLF,

    GraphemeBreakControl,

    GraphemeBreakExtend,

    GraphemeBreakL,

    GraphemeBreakV,

    GraphemeBreakT,

    GraphemeBreakLV,

    GraphemeBreakLVT

    , GraphemeBreak_Unassigned

};

static QHash<QByteArray, GraphemeBreak> grapheme_break_map;

static void initGraphemeBreak()

{

    struct GraphemeBreakList {

        GraphemeBreak brk;

        const char *name;

    } breaks[] = {

        { GraphemeBreakOther, "Other" },

        { GraphemeBreakCR, "CR" },

        { GraphemeBreakLF, "LF" },

        { GraphemeBreakControl, "Control" },

        { GraphemeBreakExtend, "Extend" },

        { GraphemeBreakL, "L" },

        { GraphemeBreakV, "V" },

        { GraphemeBreakT, "T" },

        { GraphemeBreakLV, "LV" },

        { GraphemeBreakLVT, "LVT" },

        { GraphemeBreak_Unassigned, 0 }

    };

    GraphemeBreakList *d = breaks;

    while (d->name) {

        grapheme_break_map.insert(d->name, d->brk);

        ++d;

    }

}

static const char *word_break_string =

    "    enum WordBreak {\n"

    "        WordBreakOther,\n"

    "        WordBreakFormat,\n"

    "        WordBreakKatakana,\n"

    "        WordBreakALetter,\n"

    "        WordBreakMidLetter,\n"

    "        WordBreakMidNum,\n"

    "        WordBreakNumeric,\n"

    "        WordBreakExtendNumLet\n"

    "    };\n\n";

enum WordBreak {

    WordBreakOther,

    WordBreakFormat,

    WordBreakKatakana,

    WordBreakALetter,

    WordBreakMidLetter,

    WordBreakMidNum,

    WordBreakNumeric,

    WordBreakExtendNumLet

    , WordBreak_Unassigned

};

static QHash<QByteArray, WordBreak> word_break_map;

static void initWordBreak()

{

    struct WordBreakList {

        WordBreak brk;

        const char *name;

    } breaks[] = {

        { WordBreakFormat, "Format" },

        { WordBreakFormat, "Extend" }, // these are copied in from GraphemeBreakProperty.txt

        { WordBreakKatakana, "Katakana" },

        { WordBreakALetter, "ALetter" },

        { WordBreakMidLetter, "MidLetter" },

        { WordBreakMidNum, "MidNum" },

        { WordBreakNumeric, "Numeric" },

        { WordBreakExtendNumLet, "ExtendNumLet" },

        { WordBreak_Unassigned, 0 }

    };

    WordBreakList *d = breaks;

    while (d->name) {

        word_break_map.insert(d->name, d->brk);

        ++d;

    }

}

static const char *sentence_break_string =

    "    enum SentenceBreak {\n"

    "        SentenceBreakOther,\n"

    "        SentenceBreakSep,\n"

    "        SentenceBreakFormat,\n"

    "        SentenceBreakSp,\n"

    "        SentenceBreakLower,\n"

    "        SentenceBreakUpper,\n"

    "        SentenceBreakOLetter,\n"

    "        SentenceBreakNumeric,\n"

    "        SentenceBreakATerm,\n"

    "        SentenceBreakSTerm,\n"

    "        SentenceBreakClose\n"

    "    };\n\n";

enum SentenceBreak {

    SentenceBreakOther,

    SentenceBreakSep,

    SentenceBreakFormat,

    SentenceBreakSp,

    SentenceBreakLower,

    SentenceBreakUpper,

    SentenceBreakOLetter,

    SentenceBreakNumeric,

    SentenceBreakATerm,

    SentenceBreakSTerm,

    SentenceBreakClose

    , SentenceBreak_Unassigned

};

static QHash<QByteArray, SentenceBreak> sentence_break_map;

static void initSentenceBreak()

{

    struct SentenceBreakList {

        SentenceBreak brk;

        const char *name;

    } breaks[] = {

        { SentenceBreakOther, "Other" },

        { SentenceBreakSep, "Sep" },

        { SentenceBreakFormat, "Format" },

        { SentenceBreakSp, "Sp" },

        { SentenceBreakLower, "Lower" },

        { SentenceBreakUpper, "Upper" },

        { SentenceBreakOLetter, "OLetter" },

        { SentenceBreakNumeric, "Numeric" },

        { SentenceBreakATerm, "ATerm" },

        { SentenceBreakSTerm, "STerm" },

        { SentenceBreakClose, "Close" },

        { SentenceBreak_Unassigned, 0 }

    };

    SentenceBreakList *d = breaks;

    while (d->name) {

        sentence_break_map.insert(d->name, d->brk);

        ++d;

    }

}

static const char *lineBreakClass =

    "    // see http://www.unicode.org/reports/tr14/tr14-19.html\n"

    "    // we don't use the XX, AI and CB properties and map them to AL instead.\n"

    "    // as we don't support any EBDIC based OS'es, NL is ignored and mapped to AL as well.\n"

    "    enum LineBreakClass {\n"

    "        LineBreak_OP, LineBreak_CL, LineBreak_QU, LineBreak_GL, LineBreak_NS,\n"

    "        LineBreak_EX, LineBreak_SY, LineBreak_IS, LineBreak_PR, LineBreak_PO,\n"

    "        LineBreak_NU, LineBreak_AL, LineBreak_ID, LineBreak_IN, LineBreak_HY,\n"

    "        LineBreak_BA, LineBreak_BB, LineBreak_B2, LineBreak_ZW, LineBreak_CM,\n"

    "        LineBreak_WJ, LineBreak_H2, LineBreak_H3, LineBreak_JL, LineBreak_JV,\n"

    "        LineBreak_JT, LineBreak_SA, LineBreak_SG,\n"

    "        LineBreak_SP, LineBreak_CR, LineBreak_LF, LineBreak_BK\n"

    "    };\n\n";

enum LineBreakClass {

    LineBreak_OP, LineBreak_CL, LineBreak_QU, LineBreak_GL, LineBreak_NS,

    LineBreak_EX, LineBreak_SY, LineBreak_IS, LineBreak_PR, LineBreak_PO,

    LineBreak_NU, LineBreak_AL, LineBreak_ID, LineBreak_IN, LineBreak_HY,

    LineBreak_BA, LineBreak_BB, LineBreak_B2, LineBreak_ZW, LineBreak_CM,

    LineBreak_WJ, LineBreak_H2, LineBreak_H3, LineBreak_JL, LineBreak_JV,

    LineBreak_JT, LineBreak_SA, LineBreak_SG,

    LineBreak_SP, LineBreak_CR, LineBreak_LF, LineBreak_BK

    , LineBreak_Unassigned

};

static QHash<QByteArray, LineBreakClass> line_break_map;

static void initLineBreak()

{

    // ### Classes XX and AI are left out and mapped to AL for now;

    // ### Class NL is ignored and mapped to AL as well.

    struct LineBreakList {

        LineBreakClass brk;

        const char *name;

    } breaks[] = {

        { LineBreak_BK, "BK" },

        { LineBreak_CR, "CR" },

        { LineBreak_LF, "LF" },

        { LineBreak_CM, "CM" },

        { LineBreak_AL, "NL" },

        { LineBreak_SG, "SG" },

        { LineBreak_WJ, "WJ" },

        { LineBreak_ZW, "ZW" },

        { LineBreak_GL, "GL" },

        { LineBreak_SP, "SP" },

        { LineBreak_B2, "B2" },

        { LineBreak_BA, "BA" },

        { LineBreak_BB, "BB" },

        { LineBreak_HY, "HY" },

        { LineBreak_AL, "CB" }, // ###

        { LineBreak_CL, "CL" },

        { LineBreak_EX, "EX" },

        { LineBreak_IN, "IN" },

        { LineBreak_NS, "NS" },

        { LineBreak_OP, "OP" },

        { LineBreak_QU, "QU" },

        { LineBreak_IS, "IS" },

        { LineBreak_NU, "NU" },

        { LineBreak_PO, "PO" },

        { LineBreak_PR, "PR" },

        { LineBreak_SY, "SY" },

        { LineBreak_AL, "AI" },

        { LineBreak_AL, "AL" },

        { LineBreak_H2, "H2" },

        { LineBreak_H3, "H3" },

        { LineBreak_ID, "ID" },

        { LineBreak_JL, "JL" },

        { LineBreak_JV, "JV" },

        { LineBreak_JT, "JT" },

        { LineBreak_SA, "SA" },

        { LineBreak_AL, "XX" },

        { LineBreak_Unassigned, 0 }

    };

    LineBreakList *d = breaks;

    while (d->name) {

        line_break_map.insert(d->name, d->brk);

        ++d;

    }

}

// Keep this one in sync with the code in createPropertyInfo

static const char *property_string =

    "    struct Properties {\n"

    "        ushort category         : 8; /* 5 needed */\n"

    "        ushort line_break_class : 8; /* 6 needed */\n"

    "        ushort direction        : 8; /* 5 needed */\n"

    "        ushort combiningClass   : 8;\n"

    "        ushort joining          : 2;\n"

    "        signed short digitValue : 6; /* 5 needed */\n"

    "        ushort unicodeVersion   : 4;\n"

    "        ushort lowerCaseSpecial : 1;\n"

    "        ushort upperCaseSpecial : 1;\n"

    "        ushort titleCaseSpecial : 1;\n"

    "        ushort caseFoldSpecial  : 1; /* currently unused */\n"

    "        signed short mirrorDiff    : 16;\n"

    "        signed short lowerCaseDiff : 16;\n"

    "        signed short upperCaseDiff : 16;\n"

    "        signed short titleCaseDiff : 16;\n"

    "        signed short caseFoldDiff  : 16;\n"

    "        ushort graphemeBreak    : 8; /* 4 needed */\n"

    "        ushort wordBreak        : 8; /* 4 needed */\n"

    "        ushort sentenceBreak    : 8; /* 4 needed */\n"

    "    };\n"

    "    Q_CORE_EXPORT const Properties * QT_FASTCALL properties(uint ucs4);\n"

    "    Q_CORE_EXPORT const Properties * QT_FASTCALL properties(ushort ucs2);\n";

static const char *methods =

    "    Q_CORE_EXPORT QUnicodeTables::LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4);\n"

    "    inline int lineBreakClass(const QChar &ch)\n"

    "    { return lineBreakClass(ch.unicode()); }\n"

    "\n"

    "    Q_CORE_EXPORT int QT_FASTCALL script(uint ucs4);\n"

    "    inline int script(const QChar &ch)\n"

    "    { return script(ch.unicode()); }\n\n";

struct PropertyFlags {

    bool operator ==(const PropertyFlags &o) {

        return (combiningClass == o.combiningClass

                && category == o.category

                && direction == o.direction

                && joining == o.joining

                && age == o.age

                && digitValue == o.digitValue

                && line_break_class == o.line_break_class

                && mirrorDiff == o.mirrorDiff

                && lowerCaseDiff == o.lowerCaseDiff

                && upperCaseDiff == o.upperCaseDiff

                && titleCaseDiff == o.titleCaseDiff

                && caseFoldDiff == o.caseFoldDiff

                && lowerCaseSpecial == o.lowerCaseSpecial

                && upperCaseSpecial == o.upperCaseSpecial

                && titleCaseSpecial == o.titleCaseSpecial

                && caseFoldSpecial == o.caseFoldSpecial

                && graphemeBreak == o.graphemeBreak

                && wordBreak == o.wordBreak

                && sentenceBreak == o.sentenceBreak

            );

    }

    // from UnicodeData.txt

    uchar combiningClass : 8;

    QChar::Category category : 5;

    QChar::Direction direction : 5;

    // from ArabicShaping.txt

    QChar::Joining joining : 2;

    // from DerivedAge.txt

    QChar::UnicodeVersion age : 4;

    int digitValue;

    uint line_break_class : 6;

    int mirrorDiff : 16;

    int lowerCaseDiff;

    int upperCaseDiff;

    int titleCaseDiff;

    int caseFoldDiff;

    bool lowerCaseSpecial;

    bool upperCaseSpecial;

    bool titleCaseSpecial;

    bool caseFoldSpecial;

    GraphemeBreak graphemeBreak;

    WordBreak wordBreak;

    SentenceBreak sentenceBreak;

};

static QList<int> specialCaseMap;

static int specialCaseMaxLen = 0;

static int appendToSpecialCaseMap(const QList<int> &map)

{

    QList<int> utf16map;

    for (int i = 0; i < map.size(); ++i) {

        int val = map.at(i);

        if (val > 0xffff) {

            utf16map << QChar::highSurrogate(val);

            utf16map << QChar::lowSurrogate(val);

        } else {

            utf16map << val;

        }

    }

    specialCaseMaxLen = qMax(specialCaseMaxLen, utf16map.size());

    utf16map << 0;

    for (int i = 0; i < specialCaseMap.size() - utf16map.size() + 1; ++i) {

        int j;

        for (j = 0; j < utf16map.size(); ++j) {

            if (specialCaseMap.at(i+j) != utf16map.at(j))

                break;

        }

        if (j == utf16map.size())

            return i;

    }

    int pos = specialCaseMap.size();

    specialCaseMap << utf16map;

    return pos;

}

struct UnicodeData {

    UnicodeData(int codepoint = 0) {

        p.category = QChar::Other_NotAssigned; // Cn

        p.combiningClass = 0;

        p.direction = QChar::DirL;

        // DirR for:  U+0590..U+05FF, U+07C0..U+08FF, U+FB1D..U+FB4F, U+10800..U+10FFF

        if ((codepoint >= 0x590 && codepoint <= 0x5ff)

            || (codepoint >= 0x7c0 && codepoint <= 0x8ff)

            || (codepoint >= 0xfb1d && codepoint <= 0xfb4f)

            || (codepoint >= 0x10800 && codepoint <= 0x10fff))

            p.direction = QChar::DirR;

        // DirAL for: U+0600..U+07BF, U+FB50..U+FDCF, U+FDF0..U+FDFF, U+FE70..U+FEFE

        if ((codepoint >= 0x600 && codepoint <= 0x7bf)

            || (codepoint >= 0xfb50 && codepoint <= 0xfdcf)

            || (codepoint >= 0xfdf0 && codepoint <= 0xfdff)

            || (codepoint >= 0xfe70 && codepoint <= 0xfefe))

            p.direction = QChar::DirAL;

        mirroredChar = 0;

        decompositionType = QChar::NoDecomposition;

        p.joining = QChar::OtherJoining;

        p.age = QChar::Unicode_Unassigned;

        p.mirrorDiff = 0;

        p.digitValue = -1;

        p.line_break_class = LineBreak_AL; // XX -> AL

        p.lowerCaseDiff = 0;

        p.upperCaseDiff = 0;

        p.titleCaseDiff = 0;

        p.caseFoldDiff = 0;

        p.lowerCaseSpecial = 0;

        p.upperCaseSpecial = 0;

        p.titleCaseSpecial = 0;

        p.caseFoldSpecial = 0;

        p.graphemeBreak = GraphemeBreakOther;

        p.wordBreak = WordBreakOther;

        p.sentenceBreak = SentenceBreakOther;

        propertyIndex = -1;

        excludedComposition = false;

    }

    PropertyFlags p;

    // from UnicodeData.txt

    QChar::Decomposition decompositionType;

    QList<int> decomposition;

    QList<int> specialFolding;

    // from BidiMirroring.txt

    int mirroredChar;

    // CompositionExclusions.txt

    bool excludedComposition;

    // computed position of unicode property set

    int propertyIndex;

};