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

**

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

#include <qdebug.h>

static const char *grapheme_break_string =

    "    enum GraphemeBreak {\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

};

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

    };

    GraphemeBreakList *d = breaks;

    while (d->name) {

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

        ++d;

    }

}

    "    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

};

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

    };

    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

};

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

    };

    SentenceBreakList *d = breaks;

    while (d->name) {

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

        ++d;

    }

}

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

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

    "\n"

    "    Q_CORE_EXPORT int QT_FASTCALL script(uint ucs4);\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;

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

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

};