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

**

** 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 <qstring.h>

#include <qchar.h>

#include <private/qunicodetables_p.h>

#include <qvector.h>

#include <qdebug.h>

static struct AgeMap {

    const char *age;

    const QChar::UnicodeVersion version;

} ageMap [] = {

    { "1.1", QChar::Unicode_1_1 },

    { "2.0", QChar::Unicode_2_0 },

    { "2.1", QChar::Unicode_2_1_2 },

    { "3.0", QChar::Unicode_3_0 },

    { "3.1", QChar::Unicode_3_1 },

    { "3.2", QChar::Unicode_3_2 },

    { "4.0", QChar::Unicode_4_0 },

    { "4.1", QChar::Unicode_4_1 },

    { "5.0", QChar::Unicode_5_0 },

    { 0, QChar::Unicode_Unassigned }

};

#define CURRENT_UNICODE_VERSION "QChar::Unicode_5_0"

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

};

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" },

        { GraphemeBreakOther, 0 }

    };

    GraphemeBreakList *d = breaks;

    while (d->name) {

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

        ++d;

    }

}

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

};

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" },

        { WordBreakFormat,  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

};

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" },

        { SentenceBreakOther,  0 }

    };

    SentenceBreakList *d = breaks;

    while (d->name) {

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

        ++d;

    }

}

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

const char *property_string =

    "    struct Properties {\n"

    "        ushort category : 8;\n"

    "        ushort line_break_class : 8;\n"

    "        ushort direction : 8;\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;\n"

    "        ushort wordBreak : 8;\n"

    "        ushort sentenceBreak : 8;\n"

    "    };\n"

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

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

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";

const char *methods =

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

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

    "        return QUnicodeTables::lineBreakClass(ch.unicode());\n"

    "    }\n"

    "\n"

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

    "    Q_CORE_EXPORT_INLINE int QT_FASTCALL script(const QChar &ch) {\n"

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

    "    }\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 : 5;

    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;

};

QList<int> specialCaseMap;

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::NoCategory;

        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 = QUnicodeTables::LineBreak_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;

};

enum UniDataFields {

    UD_Value,

    UD_Name,

    UD_Category,

    UD_CombiningClass,

    UD_BidiCategory,

    UD_Decomposition,

    UD_DecimalDigitValue,

    UD_DigitValue,

    UD_NumericValue,

    UD_Mirrored,

    UD_OldName,

    UD_Comment,

    UD_UpperCase,

    UD_LowerCase,

    UD_TitleCase

};

QHash<QByteArray, QChar::Category> categoryMap;

static void initCategoryMap()

{

    struct Cat {

        QChar::Category cat;

        const char *name;

    } categories [] = {

        { QChar::Mark_NonSpacing,          "Mn" },

        { QChar::Mark_SpacingCombining,    "Mc" },

        { QChar::Mark_Enclosing,           "Me" },

        { QChar::Number_DecimalDigit,      "Nd" },

        { QChar::Number_Letter,            "Nl" },

        { QChar::Number_Other,             "No" },

        { QChar::Separator_Space,          "Zs" },

        { QChar::Separator_Line,           "Zl" },

        { QChar::Separator_Paragraph,      "Zp" },

        { QChar::Other_Control,            "Cc" },

        { QChar::Other_Format,             "Cf" },

        { QChar::Other_Surrogate,          "Cs" },

        { QChar::Other_PrivateUse,         "Co" },

        { QChar::Other_NotAssigned,        "Cn" },

        { QChar::Letter_Uppercase,         "Lu" },

        { QChar::Letter_Lowercase,         "Ll" },

        { QChar::Letter_Titlecase,         "Lt" },

        { QChar::Letter_Modifier,          "Lm" },

        { QChar::Letter_Other,             "Lo" },

        { QChar::Punctuation_Connector,    "Pc" },

        { QChar::Punctuation_Dash,         "Pd" },

        { QChar::Punctuation_Open,         "Ps" },

        { QChar::Punctuation_Close,        "Pe" },

        { QChar::Punctuation_InitialQuote, "Pi" },

        { QChar::Punctuation_FinalQuote,   "Pf" },

        { QChar::Punctuation_Other,        "Po" },

        { QChar::Symbol_Math,              "Sm" },

        { QChar::Symbol_Currency,          "Sc" },

        { QChar::Symbol_Modifier,          "Sk" },

        { QChar::Symbol_Other,             "So" },

        { QChar::NoCategory, 0 }

    };

    Cat *c = categories;

    while (c->cat != QChar::NoCategory) {

        categoryMap.insert(c->name, c->cat);

        ++c;

    }

}

QHash<QByteArray, QChar::Direction> directionMap;

static void initDirectionMap()

{

    struct Dir {

        QChar::Direction dir;

        const char *name;

    } directions[] = {

        { QChar::DirL, "L" },

        { QChar::DirR, "R" },

        { QChar::DirEN, "EN" },

        { QChar::DirES, "ES" },

        { QChar::DirET, "ET" },

        { QChar::DirAN, "AN" },

        { QChar::DirCS, "CS" },

        { QChar::DirB, "B" },

        { QChar::DirS, "S" },

        { QChar::DirWS, "WS" },

        { QChar::DirON, "ON" },

        { QChar::DirLRE, "LRE" },

        { QChar::DirLRO, "LRO" },

        { QChar::DirAL, "AL" },

        { QChar::DirRLE, "RLE" },

        { QChar::DirRLO, "RLO" },

        { QChar::DirPDF, "PDF" },

        { QChar::DirNSM, "NSM" },

        { QChar::DirBN, "BN" },

        { QChar::DirL, 0 }

    };

    Dir *d = directions;

    while (d->name) {

        directionMap.insert(d->name, d->dir);

        ++d;

    }

}