1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

QUnicodeTables: some internal API renamings

Browse Source 
enums GraphemeBreak, WordBreak, and SentenceBreak has been renamed to
GraphemeBreakClass, WordBreakClass, and SentenceBreakClass respectively,
their values has been renamed to contain a '_' as logical enum-value separator
(just like many other nums in Qt, e.g. LineBreakClass);
*BreakFormat has been replaced with *Break_Extend (some format characters are
kind of subtype of the extender characters, not vice versa).

Change-Id: I9ddbcf8848da87409736c2d6d1798a62fa28cab8
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
This commit is contained in:
Konstantin Ritt 2012-06-17 04:55:07 +03:00 committed by Qt by Nokia
parent c1329fba13
commit b57e2162ef
4 changed files with 260 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/corelib/tools/qunicodetables.cpp
View File

@ -6339,24 +6339,24 @@ Q_CORE_EXPORT const Properties * QT_FASTCALL properties(ushort ucs2)
return qGetProp(ucs2); return qGetProp(ucs2);
} }
Q_CORE_EXPORT GraphemeBreak QT_FASTCALL graphemeBreakClass(uint ucs4) Q_CORE_EXPORT GraphemeBreakClass QT_FASTCALL graphemeBreakClass(uint ucs4)
{ {
return (GraphemeBreak)qGetProp(ucs4)->graphemeBreak; return (GraphemeBreakClass)qGetProp(ucs4)->graphemeBreakClass;
} }
Q_CORE_EXPORT WordBreak QT_FASTCALL wordBreakClass(uint ucs4) Q_CORE_EXPORT WordBreakClass QT_FASTCALL wordBreakClass(uint ucs4)
{ {
return (WordBreak)qGetProp(ucs4)->wordBreak; return (WordBreakClass)qGetProp(ucs4)->wordBreakClass;
} }
Q_CORE_EXPORT SentenceBreak QT_FASTCALL sentenceBreakClass(uint ucs4) Q_CORE_EXPORT SentenceBreakClass QT_FASTCALL sentenceBreakClass(uint ucs4)
{ {
return (SentenceBreak)qGetProp(ucs4)->sentenceBreak; return (SentenceBreakClass)qGetProp(ucs4)->sentenceBreakClass;
} }
Q_CORE_EXPORT LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4) Q_CORE_EXPORT LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4)
{ {
return (LineBreakClass)qGetProp(ucs4)->line_break_class; return (LineBreakClass)qGetProp(ucs4)->lineBreakClass;
} }
Q_CORE_EXPORT Script QT_FASTCALL script(uint ucs4) Q_CORE_EXPORT Script QT_FASTCALL script(uint ucs4)

102
src/corelib/tools/qunicodetables_p.h
View File

@ -79,10 +79,10 @@ struct Properties {
ushort titleCaseSpecial : 1; ushort titleCaseSpecial : 1;
ushort caseFoldSpecial : 1; ushort caseFoldSpecial : 1;
ushort unicodeVersion : 4; ushort unicodeVersion : 4;
ushort graphemeBreak : 8; /* 4 used */ ushort graphemeBreakClass : 8; /* 4 used */
ushort wordBreak : 8; /* 4 used */ ushort wordBreakClass : 8; /* 4 used */
ushort sentenceBreak : 8; /* 4 used */ ushort sentenceBreakClass : 8; /* 4 used */
ushort line_break_class : 8; /* 6 used */ ushort lineBreakClass : 8; /* 6 used */
ushort script : 8; /* 5 used */ ushort script : 8; /* 5 used */
}; };
@ -196,51 +196,51 @@ enum Script {
Takri = Common Takri = Common
}; };
enum GraphemeBreak { enum GraphemeBreakClass {
GraphemeBreakOther, GraphemeBreak_Other,
GraphemeBreakCR, GraphemeBreak_CR,
GraphemeBreakLF, GraphemeBreak_LF,
GraphemeBreakControl, GraphemeBreak_Control,
GraphemeBreakExtend, GraphemeBreak_Extend,
GraphemeBreakPrepend, GraphemeBreak_Prepend,
GraphemeBreakSpacingMark, GraphemeBreak_SpacingMark,
GraphemeBreakL, GraphemeBreak_L,
GraphemeBreakV, GraphemeBreak_V,
GraphemeBreakT, GraphemeBreak_T,
GraphemeBreakLV, GraphemeBreak_LV,
GraphemeBreakLVT GraphemeBreak_LVT
}; };
enum WordBreak { enum WordBreakClass {
WordBreakOther, WordBreak_Other,
WordBreakCR, WordBreak_CR,
WordBreakLF, WordBreak_LF,
WordBreakNewline, WordBreak_Newline,
WordBreakFormat, WordBreak_Extend,
WordBreakKatakana, WordBreak_Katakana,
WordBreakALetter, WordBreak_ALetter,
WordBreakMidNumLet, WordBreak_MidNumLet,
WordBreakMidLetter, WordBreak_MidLetter,
WordBreakMidNum, WordBreak_MidNum,
WordBreakNumeric, WordBreak_Numeric,
WordBreakExtendNumLet WordBreak_ExtendNumLet
}; };
enum SentenceBreak { enum SentenceBreakClass {
SentenceBreakOther, SentenceBreak_Other,
SentenceBreakCR, SentenceBreak_CR,
SentenceBreakLF, SentenceBreak_LF,
SentenceBreakSep, SentenceBreak_Sep,
SentenceBreakFormat, SentenceBreak_Extend,
SentenceBreakSp, SentenceBreak_Sp,
SentenceBreakLower, SentenceBreak_Lower,
SentenceBreakUpper, SentenceBreak_Upper,
SentenceBreakOLetter, SentenceBreak_OLetter,
SentenceBreakNumeric, SentenceBreak_Numeric,
SentenceBreakATerm, SentenceBreak_ATerm,
SentenceBreakSContinue, SentenceBreak_SContinue,
SentenceBreakSTerm, SentenceBreak_STerm,
SentenceBreakClose SentenceBreak_Close
}; };
// see http://www.unicode.org/reports/tr14/tr14-28.html // see http://www.unicode.org/reports/tr14/tr14-28.html
@ -255,16 +255,16 @@ enum LineBreakClass {
LineBreak_SG, LineBreak_SP, LineBreak_CR, LineBreak_LF, LineBreak_BK LineBreak_SG, LineBreak_SP, LineBreak_CR, LineBreak_LF, LineBreak_BK
}; };
Q_CORE_EXPORT GraphemeBreak QT_FASTCALL graphemeBreakClass(uint ucs4); Q_CORE_EXPORT GraphemeBreakClass QT_FASTCALL graphemeBreakClass(uint ucs4);
inline GraphemeBreak graphemeBreakClass(QChar ch) inline GraphemeBreakClass graphemeBreakClass(QChar ch)
{ return graphemeBreakClass(ch.unicode()); } { return graphemeBreakClass(ch.unicode()); }
Q_CORE_EXPORT WordBreak QT_FASTCALL wordBreakClass(uint ucs4); Q_CORE_EXPORT WordBreakClass QT_FASTCALL wordBreakClass(uint ucs4);
inline WordBreak wordBreakClass(QChar ch) inline WordBreakClass wordBreakClass(QChar ch)
{ return wordBreakClass(ch.unicode()); } { return wordBreakClass(ch.unicode()); }
Q_CORE_EXPORT SentenceBreak QT_FASTCALL sentenceBreakClass(uint ucs4); Q_CORE_EXPORT SentenceBreakClass QT_FASTCALL sentenceBreakClass(uint ucs4);
inline SentenceBreak sentenceBreakClass(QChar ch) inline SentenceBreakClass sentenceBreakClass(QChar ch)
{ return sentenceBreakClass(ch.unicode()); } { return sentenceBreakClass(ch.unicode()); }
Q_CORE_EXPORT LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4); Q_CORE_EXPORT LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4);

46
src/corelib/tools/qunicodetools.cpp
View File

@ -59,7 +59,7 @@ namespace QUnicodeTools {
namespace GB { namespace GB {
static const uchar breakTable[QUnicodeTables::GraphemeBreakLVT + 1][QUnicodeTables::GraphemeBreakLVT + 1] = { static const uchar breakTable[QUnicodeTables::GraphemeBreak_LVT + 1][QUnicodeTables::GraphemeBreak_LVT + 1] = {
// Other CR LF Control Extend Prepend S-Mark L V T LV LVT // Other CR LF Control Extend Prepend S-Mark L V T LV LVT
{ true , true , true , true , false, true , false, true , true , true , true , true }, // Other { true , true , true , true , false, true , false, true , true , true , true , true }, // Other
{ true , true , false, true , true , true , true , true , true , true , true , true }, // CR { true , true , false, true , true , true , true , true , true , true , true , true }, // CR
@ -79,7 +79,7 @@ static const uchar breakTable[QUnicodeTables::GraphemeBreakLVT + 1][QUnicodeTabl
static void getGraphemeBreaks(const ushort *string, quint32 len, HB_CharAttributes *attributes) static void getGraphemeBreaks(const ushort *string, quint32 len, HB_CharAttributes *attributes)
{ {
QUnicodeTables::GraphemeBreak lcls = QUnicodeTables::GraphemeBreakLF; // to meet GB1 QUnicodeTables::GraphemeBreakClass lcls = QUnicodeTables::GraphemeBreak_LF; // to meet GB1
for (quint32 i = 0; i != len; ++i) { for (quint32 i = 0; i != len; ++i) {
quint32 pos = i; quint32 pos = i;
uint ucs4 = string[i]; uint ucs4 = string[i];
@ -92,7 +92,7 @@ static void getGraphemeBreaks(const ushort *string, quint32 len, HB_CharAttribut
} }
const QUnicodeTables::Properties *prop = QUnicodeTables::properties(ucs4); const QUnicodeTables::Properties *prop = QUnicodeTables::properties(ucs4);
QUnicodeTables::GraphemeBreak cls = (QUnicodeTables::GraphemeBreak) prop->graphemeBreak; QUnicodeTables::GraphemeBreakClass cls = (QUnicodeTables::GraphemeBreakClass) prop->graphemeBreakClass;
attributes[pos].charStop = GB::breakTable[lcls][cls]; attributes[pos].charStop = GB::breakTable[lcls][cls];
@ -109,13 +109,13 @@ enum Action {
Lookup = 2 Lookup = 2
}; };
static const uchar breakTable[QUnicodeTables::WordBreakExtendNumLet + 1][QUnicodeTables::WordBreakExtendNumLet + 1] = { static const uchar breakTable[QUnicodeTables::WordBreak_ExtendNumLet + 1][QUnicodeTables::WordBreak_ExtendNumLet + 1] = {
// Other CR LF Newline Format Katakana ALetter MidNumLet MidLetter MidNum Numeric ExtendNumLet // Other CR LF Newline Extend Katakana ALetter MidNumLet MidLetter MidNum Numeric ExtendNumLet
{ Break , Break , Break , Break , NoBreak, Break , Break , Break , Break , Break , Break , Break }, // Other { Break , Break , Break , Break , NoBreak, Break , Break , Break , Break , Break , Break , Break }, // Other
{ Break , Break , NoBreak, Break , Break , Break , Break , Break , Break , Break , Break , Break }, // CR { Break , Break , NoBreak, Break , Break , Break , Break , Break , Break , Break , Break , Break }, // CR
{ Break , Break , Break , Break , Break , Break , Break , Break , Break , Break , Break , Break }, // LF { Break , Break , Break , Break , Break , Break , Break , Break , Break , Break , Break , Break }, // LF
{ Break , Break , Break , Break , Break , Break , Break , Break , Break , Break , Break , Break }, // Newline { Break , Break , Break , Break , Break , Break , Break , Break , Break , Break , Break , Break }, // Newline
{ Break , Break , Break , Break , NoBreak, Break , Break , Break , Break , Break , Break , Break }, // Format { Break , Break , Break , Break , NoBreak, Break , Break , Break , Break , Break , Break , Break }, // Extend
{ Break , Break , Break , Break , NoBreak, NoBreak, Break , Break , Break , Break , Break , NoBreak }, // Katakana { Break , Break , Break , Break , NoBreak, NoBreak, Break , Break , Break , Break , Break , NoBreak }, // Katakana
{ Break , Break , Break , Break , NoBreak, Break , NoBreak, Lookup , Lookup , Break , NoBreak, NoBreak }, // ALetter { Break , Break , Break , Break , NoBreak, Break , NoBreak, Lookup , Lookup , Break , NoBreak, NoBreak }, // ALetter
{ Break , Break , Break , Break , NoBreak, Break , Break , Break , Break , Break , Break , Break }, // MidNumLet { Break , Break , Break , Break , NoBreak, Break , Break , Break , Break , Break , Break , Break }, // MidNumLet
@ -129,7 +129,7 @@ static const uchar breakTable[QUnicodeTables::WordBreakExtendNumLet + 1][QUnicod
static void getWordBreaks(const ushort *string, quint32 len, HB_CharAttributes *attributes) static void getWordBreaks(const ushort *string, quint32 len, HB_CharAttributes *attributes)
{ {
QUnicodeTables::WordBreak cls = QUnicodeTables::WordBreakLF; // to meet WB1 QUnicodeTables::WordBreakClass cls = QUnicodeTables::WordBreak_LF; // to meet WB1
for (quint32 i = 0; i != len; ++i) { for (quint32 i = 0; i != len; ++i) {
quint32 pos = i; quint32 pos = i;
uint ucs4 = string[i]; uint ucs4 = string[i];
@ -142,7 +142,7 @@ static void getWordBreaks(const ushort *string, quint32 len, HB_CharAttributes *
} }
const QUnicodeTables::Properties *prop = QUnicodeTables::properties(ucs4); const QUnicodeTables::Properties *prop = QUnicodeTables::properties(ucs4);
QUnicodeTables::WordBreak ncls = (QUnicodeTables::WordBreak) prop->wordBreak; QUnicodeTables::WordBreakClass ncls = (QUnicodeTables::WordBreakClass) prop->wordBreakClass;
uchar action = WB::breakTable[cls][ncls]; uchar action = WB::breakTable[cls][ncls];
if (Q_UNLIKELY(action == WB::Lookup)) { if (Q_UNLIKELY(action == WB::Lookup)) {
@ -158,8 +158,8 @@ static void getWordBreaks(const ushort *string, quint32 len, HB_CharAttributes *
} }
prop = QUnicodeTables::properties(ucs4); prop = QUnicodeTables::properties(ucs4);
QUnicodeTables::WordBreak tcls = (QUnicodeTables::WordBreak) prop->wordBreak; QUnicodeTables::WordBreakClass tcls = (QUnicodeTables::WordBreakClass) prop->wordBreakClass;
if (Q_UNLIKELY(tcls == QUnicodeTables::WordBreakFormat)) if (Q_UNLIKELY(tcls == QUnicodeTables::WordBreak_Extend))
continue; continue;
if (Q_LIKELY(tcls == cls)) { if (Q_LIKELY(tcls == cls)) {
i = lookahead; i = lookahead;
@ -168,7 +168,7 @@ static void getWordBreaks(const ushort *string, quint32 len, HB_CharAttributes *
} }
break; break;
} }
} else if (Q_UNLIKELY(ncls == QUnicodeTables::WordBreakFormat)) { } else if (Q_UNLIKELY(ncls == QUnicodeTables::WordBreak_Extend)) {
// WB4: X(Extend|Format)* -> X // WB4: X(Extend|Format)* -> X
if (Q_LIKELY(action != WB::Break)) if (Q_LIKELY(action != WB::Break))
continue; continue;
@ -198,8 +198,8 @@ enum State {
Lookup Lookup
}; };
static const uchar breakTable[BAfter + 1][QUnicodeTables::SentenceBreakClose + 1] = { static const uchar breakTable[BAfter + 1][QUnicodeTables::SentenceBreak_Close + 1] = {
// Other CR LF Sep Format Sp Lower Upper OLetter Numeric ATerm SContinue STerm Close // Other CR LF Sep Extend Sp Lower Upper OLetter Numeric ATerm SContinue STerm Close
{ Initial, BAfterC, BAfter , BAfter , Initial, Initial, Initial, Upper , Initial, Initial, ATerm , Initial, STerm , Initial }, // Initial { Initial, BAfterC, BAfter , BAfter , Initial, Initial, Initial, Upper , Initial, Initial, ATerm , Initial, STerm , Initial }, // Initial
{ Initial, BAfterC, BAfter , BAfter , Upper , Initial, Initial, Upper , Initial, Initial, UpATerm, STerm , STerm , Initial }, // Upper { Initial, BAfterC, BAfter , BAfter , Upper , Initial, Initial, Upper , Initial, Initial, UpATerm, STerm , STerm , Initial }, // Upper
@ -232,7 +232,7 @@ static void getSentenceBreaks(const ushort *string, quint32 len, HB_CharAttribut
} }
const QUnicodeTables::Properties *prop = QUnicodeTables::properties(ucs4); const QUnicodeTables::Properties *prop = QUnicodeTables::properties(ucs4);
QUnicodeTables::SentenceBreak ncls = (QUnicodeTables::SentenceBreak) prop->sentenceBreak; QUnicodeTables::SentenceBreakClass ncls = (QUnicodeTables::SentenceBreakClass) prop->sentenceBreakClass;
Q_ASSERT(state <= SB::BAfter); Q_ASSERT(state <= SB::BAfter);
state = SB::breakTable[state][ncls]; state = SB::breakTable[state][ncls];
@ -249,16 +249,16 @@ static void getSentenceBreaks(const ushort *string, quint32 len, HB_CharAttribut
} }
prop = QUnicodeTables::properties(ucs4); prop = QUnicodeTables::properties(ucs4);
QUnicodeTables::SentenceBreak tcls = (QUnicodeTables::SentenceBreak) prop->sentenceBreak; QUnicodeTables::SentenceBreakClass tcls = (QUnicodeTables::SentenceBreakClass) prop->sentenceBreakClass;
switch (tcls) { switch (tcls) {
case QUnicodeTables::SentenceBreakOther: case QUnicodeTables::SentenceBreak_Other:
case QUnicodeTables::SentenceBreakFormat: case QUnicodeTables::SentenceBreak_Extend:
case QUnicodeTables::SentenceBreakSp: case QUnicodeTables::SentenceBreak_Sp:
case QUnicodeTables::SentenceBreakNumeric: case QUnicodeTables::SentenceBreak_Numeric:
case QUnicodeTables::SentenceBreakSContinue: case QUnicodeTables::SentenceBreak_SContinue:
case QUnicodeTables::SentenceBreakClose: case QUnicodeTables::SentenceBreak_Close:
continue; continue;
case QUnicodeTables::SentenceBreakLower: case QUnicodeTables::SentenceBreak_Lower:
i = lookahead; i = lookahead;
state = SB::Initial; state = SB::Initial;
break; break;
@ -422,7 +422,7 @@ static void getLineBreaks(const ushort *string, quint32 len, HB_CharAttributes *
} }
const QUnicodeTables::Properties *prop = QUnicodeTables::properties(ucs4); const QUnicodeTables::Properties *prop = QUnicodeTables::properties(ucs4);
QUnicodeTables::LineBreakClass ncls = (QUnicodeTables::LineBreakClass) prop->line_break_class; QUnicodeTables::LineBreakClass ncls = (QUnicodeTables::LineBreakClass) prop->lineBreakClass;
if (Q_UNLIKELY(ncls == QUnicodeTables::LineBreak_SA)) { if (Q_UNLIKELY(ncls == QUnicodeTables::LineBreak_SA)) {
// LB1: resolve SA to AL, except of those that have Category Mn or Mc be resolved to CM // LB1: resolve SA to AL, except of those that have Category Mn or Mc be resolved to CM

358
util/unicode/main.cpp
View File

@ -247,59 +247,59 @@ static void initJoiningMap()
} }
static const char *grapheme_break_string = static const char *grapheme_break_class_string =
"enum GraphemeBreak {\n" "enum GraphemeBreakClass {\n"
" GraphemeBreakOther,\n" " GraphemeBreak_Other,\n"
" GraphemeBreakCR,\n" " GraphemeBreak_CR,\n"
" GraphemeBreakLF,\n" " GraphemeBreak_LF,\n"
" GraphemeBreakControl,\n" " GraphemeBreak_Control,\n"
" GraphemeBreakExtend,\n" " GraphemeBreak_Extend,\n"
" GraphemeBreakPrepend,\n" " GraphemeBreak_Prepend,\n"
" GraphemeBreakSpacingMark,\n" " GraphemeBreak_SpacingMark,\n"
" GraphemeBreakL,\n" " GraphemeBreak_L,\n"
" GraphemeBreakV,\n" " GraphemeBreak_V,\n"
" GraphemeBreakT,\n" " GraphemeBreak_T,\n"
" GraphemeBreakLV,\n" " GraphemeBreak_LV,\n"
" GraphemeBreakLVT\n" " GraphemeBreak_LVT\n"
"};\n\n"; "};\n\n";
enum GraphemeBreak { enum GraphemeBreakClass {
GraphemeBreakOther, GraphemeBreak_Other,
GraphemeBreakCR, GraphemeBreak_CR,
GraphemeBreakLF, GraphemeBreak_LF,
GraphemeBreakControl, GraphemeBreak_Control,
GraphemeBreakExtend, GraphemeBreak_Extend,
GraphemeBreakPrepend, GraphemeBreak_Prepend,
GraphemeBreakSpacingMark, GraphemeBreak_SpacingMark,
GraphemeBreakL, GraphemeBreak_L,
GraphemeBreakV, GraphemeBreak_V,
GraphemeBreakT, GraphemeBreak_T,
GraphemeBreakLV, GraphemeBreak_LV,
GraphemeBreakLVT GraphemeBreak_LVT
, GraphemeBreak_Unassigned , GraphemeBreak_Unassigned
}; };
static QHash<QByteArray, GraphemeBreak> grapheme_break_map; static QHash<QByteArray, GraphemeBreakClass> grapheme_break_map;
static void initGraphemeBreak() static void initGraphemeBreak()
{ {
struct GraphemeBreakList { struct GraphemeBreakList {
GraphemeBreak brk; GraphemeBreakClass brk;
const char *name; const char *name;
} breaks[] = { } breaks[] = {
{ GraphemeBreakOther, "Other" }, { GraphemeBreak_Other, "Other" },
{ GraphemeBreakCR, "CR" }, { GraphemeBreak_CR, "CR" },
{ GraphemeBreakLF, "LF" }, { GraphemeBreak_LF, "LF" },
{ GraphemeBreakControl, "Control" }, { GraphemeBreak_Control, "Control" },
{ GraphemeBreakExtend, "Extend" }, { GraphemeBreak_Extend, "Extend" },
{ GraphemeBreakPrepend, "Prepend" }, { GraphemeBreak_Prepend, "Prepend" },
{ GraphemeBreakSpacingMark, "SpacingMark" }, { GraphemeBreak_SpacingMark, "SpacingMark" },
{ GraphemeBreakL, "L" }, { GraphemeBreak_L, "L" },
{ GraphemeBreakV, "V" }, { GraphemeBreak_V, "V" },
{ GraphemeBreakT, "T" }, { GraphemeBreak_T, "T" },
{ GraphemeBreakLV, "LV" }, { GraphemeBreak_LV, "LV" },
{ GraphemeBreakLVT, "LVT" }, { GraphemeBreak_LVT, "LVT" },
{ GraphemeBreak_Unassigned, 0 } { GraphemeBreak_Unassigned, 0 }
}; };
GraphemeBreakList *d = breaks; GraphemeBreakList *d = breaks;
@ -310,60 +310,60 @@ static void initGraphemeBreak()
} }
static const char *word_break_string = static const char *word_break_class_string =
"enum WordBreak {\n" "enum WordBreakClass {\n"
" WordBreakOther,\n" " WordBreak_Other,\n"
" WordBreakCR,\n" " WordBreak_CR,\n"
" WordBreakLF,\n" " WordBreak_LF,\n"
" WordBreakNewline,\n" " WordBreak_Newline,\n"
" WordBreakFormat,\n" " WordBreak_Extend,\n"
" WordBreakKatakana,\n" " WordBreak_Katakana,\n"
" WordBreakALetter,\n" " WordBreak_ALetter,\n"
" WordBreakMidNumLet,\n" " WordBreak_MidNumLet,\n"
" WordBreakMidLetter,\n" " WordBreak_MidLetter,\n"
" WordBreakMidNum,\n" " WordBreak_MidNum,\n"
" WordBreakNumeric,\n" " WordBreak_Numeric,\n"
" WordBreakExtendNumLet\n" " WordBreak_ExtendNumLet\n"
"};\n\n"; "};\n\n";
enum WordBreak { enum WordBreakClass {
WordBreakOther, WordBreak_Other,
WordBreakCR, WordBreak_CR,
WordBreakLF, WordBreak_LF,
WordBreakNewline, WordBreak_Newline,
WordBreakFormat, WordBreak_Extend,
WordBreakKatakana, WordBreak_Katakana,
WordBreakALetter, WordBreak_ALetter,
WordBreakMidNumLet, WordBreak_MidNumLet,
WordBreakMidLetter, WordBreak_MidLetter,
WordBreakMidNum, WordBreak_MidNum,
WordBreakNumeric, WordBreak_Numeric,
WordBreakExtendNumLet WordBreak_ExtendNumLet
, WordBreak_Unassigned , WordBreak_Unassigned
}; };
static QHash<QByteArray, WordBreak> word_break_map; static QHash<QByteArray, WordBreakClass> word_break_map;
static void initWordBreak() static void initWordBreak()
{ {
struct WordBreakList { struct WordBreakList {
WordBreak brk; WordBreakClass brk;
const char *name; const char *name;
} breaks[] = { } breaks[] = {
{ WordBreakOther, "Other" }, { WordBreak_Other, "Other" },
{ WordBreakCR, "CR" }, { WordBreak_CR, "CR" },
{ WordBreakLF, "LF" }, { WordBreak_LF, "LF" },
{ WordBreakNewline, "Newline" }, { WordBreak_Newline, "Newline" },
{ WordBreakFormat, "Extend" }, { WordBreak_Extend, "Extend" },
{ WordBreakFormat, "Format" }, { WordBreak_Extend, "Format" },
{ WordBreakKatakana, "Katakana" }, { WordBreak_Katakana, "Katakana" },
{ WordBreakALetter, "ALetter" }, { WordBreak_ALetter, "ALetter" },
{ WordBreakMidNumLet, "MidNumLet" }, { WordBreak_MidNumLet, "MidNumLet" },
{ WordBreakMidLetter, "MidLetter" }, { WordBreak_MidLetter, "MidLetter" },
{ WordBreakMidNum, "MidNum" }, { WordBreak_MidNum, "MidNum" },
{ WordBreakNumeric, "Numeric" }, { WordBreak_Numeric, "Numeric" },
{ WordBreakExtendNumLet, "ExtendNumLet" }, { WordBreak_ExtendNumLet, "ExtendNumLet" },
{ WordBreak_Unassigned, 0 } { WordBreak_Unassigned, 0 }
}; };
WordBreakList *d = breaks; WordBreakList *d = breaks;
@ -374,66 +374,66 @@ static void initWordBreak()
} }
static const char *sentence_break_string = static const char *sentence_break_class_string =
"enum SentenceBreak {\n" "enum SentenceBreakClass {\n"
" SentenceBreakOther,\n" " SentenceBreak_Other,\n"
" SentenceBreakCR,\n" " SentenceBreak_CR,\n"
" SentenceBreakLF,\n" " SentenceBreak_LF,\n"
" SentenceBreakSep,\n" " SentenceBreak_Sep,\n"
" SentenceBreakFormat,\n" " SentenceBreak_Extend,\n"
" SentenceBreakSp,\n" " SentenceBreak_Sp,\n"
" SentenceBreakLower,\n" " SentenceBreak_Lower,\n"
" SentenceBreakUpper,\n" " SentenceBreak_Upper,\n"
" SentenceBreakOLetter,\n" " SentenceBreak_OLetter,\n"
" SentenceBreakNumeric,\n" " SentenceBreak_Numeric,\n"
" SentenceBreakATerm,\n" " SentenceBreak_ATerm,\n"
" SentenceBreakSContinue,\n" " SentenceBreak_SContinue,\n"
" SentenceBreakSTerm,\n" " SentenceBreak_STerm,\n"
" SentenceBreakClose\n" " SentenceBreak_Close\n"
"};\n\n"; "};\n\n";
enum SentenceBreak { enum SentenceBreakClass {
SentenceBreakOther, SentenceBreak_Other,
SentenceBreakCR, SentenceBreak_CR,
SentenceBreakLF, SentenceBreak_LF,
SentenceBreakSep, SentenceBreak_Sep,
SentenceBreakFormat, SentenceBreak_Extend,
SentenceBreakSp, SentenceBreak_Sp,
SentenceBreakLower, SentenceBreak_Lower,
SentenceBreakUpper, SentenceBreak_Upper,
SentenceBreakOLetter, SentenceBreak_OLetter,
SentenceBreakNumeric, SentenceBreak_Numeric,
SentenceBreakATerm, SentenceBreak_ATerm,
SentenceBreakSContinue, SentenceBreak_SContinue,
SentenceBreakSTerm, SentenceBreak_STerm,
SentenceBreakClose SentenceBreak_Close
, SentenceBreak_Unassigned , SentenceBreak_Unassigned
}; };
static QHash<QByteArray, SentenceBreak> sentence_break_map; static QHash<QByteArray, SentenceBreakClass> sentence_break_map;
static void initSentenceBreak() static void initSentenceBreak()
{ {
struct SentenceBreakList { struct SentenceBreakList {
SentenceBreak brk; SentenceBreakClass brk;
const char *name; const char *name;
} breaks[] = { } breaks[] = {
{ SentenceBreakOther, "Other" }, { SentenceBreak_Other, "Other" },
{ SentenceBreakCR, "CR" }, { SentenceBreak_CR, "CR" },
{ SentenceBreakLF, "LF" }, { SentenceBreak_LF, "LF" },
{ SentenceBreakSep, "Sep" }, { SentenceBreak_Sep, "Sep" },
{ SentenceBreakFormat, "Extend" }, { SentenceBreak_Extend, "Extend" },
{ SentenceBreakFormat, "Format" }, { SentenceBreak_Extend, "Format" },
{ SentenceBreakSp, "Sp" }, { SentenceBreak_Sp, "Sp" },
{ SentenceBreakLower, "Lower" }, { SentenceBreak_Lower, "Lower" },
{ SentenceBreakUpper, "Upper" }, { SentenceBreak_Upper, "Upper" },
{ SentenceBreakOLetter, "OLetter" }, { SentenceBreak_OLetter, "OLetter" },
{ SentenceBreakNumeric, "Numeric" }, { SentenceBreak_Numeric, "Numeric" },
{ SentenceBreakATerm, "ATerm" }, { SentenceBreak_ATerm, "ATerm" },
{ SentenceBreakSContinue, "SContinue" }, { SentenceBreak_SContinue, "SContinue" },
{ SentenceBreakSTerm, "STerm" }, { SentenceBreak_STerm, "STerm" },
{ SentenceBreakClose, "Close" }, { SentenceBreak_Close, "Close" },
{ SentenceBreak_Unassigned, 0 } { SentenceBreak_Unassigned, 0 }
}; };
SentenceBreakList *d = breaks; SentenceBreakList *d = breaks;
@ -548,10 +548,10 @@ static const char *property_string =
" ushort titleCaseSpecial : 1;\n" " ushort titleCaseSpecial : 1;\n"
" ushort caseFoldSpecial : 1;\n" " ushort caseFoldSpecial : 1;\n"
" ushort unicodeVersion : 4;\n" " ushort unicodeVersion : 4;\n"
" ushort graphemeBreak : 8; /* 4 used */\n" " ushort graphemeBreakClass : 8; /* 4 used */\n"
" ushort wordBreak : 8; /* 4 used */\n" " ushort wordBreakClass : 8; /* 4 used */\n"
" ushort sentenceBreak : 8; /* 4 used */\n" " ushort sentenceBreakClass : 8; /* 4 used */\n"
" ushort line_break_class : 8; /* 6 used */\n" " ushort lineBreakClass : 8; /* 6 used */\n"
" ushort script : 8; /* 5 used */\n" " ushort script : 8; /* 5 used */\n"
"};\n\n" "};\n\n"
"Q_CORE_EXPORT const Properties * QT_FASTCALL properties(uint ucs4);\n" "Q_CORE_EXPORT const Properties * QT_FASTCALL properties(uint ucs4);\n"
@ -559,16 +559,16 @@ static const char *property_string =
"\n"; "\n";
static const char *methods = static const char *methods =
"Q_CORE_EXPORT GraphemeBreak QT_FASTCALL graphemeBreakClass(uint ucs4);\n" "Q_CORE_EXPORT GraphemeBreakClass QT_FASTCALL graphemeBreakClass(uint ucs4);\n"
"inline GraphemeBreak graphemeBreakClass(QChar ch)\n" "inline GraphemeBreakClass graphemeBreakClass(QChar ch)\n"
"{ return graphemeBreakClass(ch.unicode()); }\n" "{ return graphemeBreakClass(ch.unicode()); }\n"
"\n" "\n"
"Q_CORE_EXPORT WordBreak QT_FASTCALL wordBreakClass(uint ucs4);\n" "Q_CORE_EXPORT WordBreakClass QT_FASTCALL wordBreakClass(uint ucs4);\n"
"inline WordBreak wordBreakClass(QChar ch)\n" "inline WordBreakClass wordBreakClass(QChar ch)\n"
"{ return wordBreakClass(ch.unicode()); }\n" "{ return wordBreakClass(ch.unicode()); }\n"
"\n" "\n"
"Q_CORE_EXPORT SentenceBreak QT_FASTCALL sentenceBreakClass(uint ucs4);\n" "Q_CORE_EXPORT SentenceBreakClass QT_FASTCALL sentenceBreakClass(uint ucs4);\n"
"inline SentenceBreak sentenceBreakClass(QChar ch)\n" "inline SentenceBreakClass sentenceBreakClass(QChar ch)\n"
"{ return sentenceBreakClass(ch.unicode()); }\n" "{ return sentenceBreakClass(ch.unicode()); }\n"
"\n" "\n"
"Q_CORE_EXPORT LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4);\n" "Q_CORE_EXPORT LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4);\n"
@ -599,10 +599,10 @@ struct PropertyFlags {
&& upperCaseSpecial == o.upperCaseSpecial && upperCaseSpecial == o.upperCaseSpecial
&& titleCaseSpecial == o.titleCaseSpecial && titleCaseSpecial == o.titleCaseSpecial
&& caseFoldSpecial == o.caseFoldSpecial && caseFoldSpecial == o.caseFoldSpecial
&& graphemeBreak == o.graphemeBreak && graphemeBreakClass == o.graphemeBreakClass
&& wordBreak == o.wordBreak && wordBreakClass == o.wordBreakClass
&& sentenceBreak == o.sentenceBreak && sentenceBreakClass == o.sentenceBreakClass
&& line_break_class == o.line_break_class && lineBreakClass == o.lineBreakClass
&& script == o.script && script == o.script
); );
} }
@ -626,10 +626,10 @@ struct PropertyFlags {
bool upperCaseSpecial; bool upperCaseSpecial;
bool titleCaseSpecial; bool titleCaseSpecial;
bool caseFoldSpecial; bool caseFoldSpecial;
GraphemeBreak graphemeBreak; GraphemeBreakClass graphemeBreakClass;
WordBreak wordBreak; WordBreakClass wordBreakClass;
SentenceBreak sentenceBreak; SentenceBreakClass sentenceBreakClass;
LineBreakClass line_break_class; LineBreakClass lineBreakClass;
int script; int script;
}; };
@ -702,7 +702,7 @@ struct UnicodeData {
p.direction = QChar::DirR; p.direction = QChar::DirR;
} }
p.line_break_class = LineBreak_AL; // XX -> AL p.lineBreakClass = LineBreak_AL; // XX -> AL
// LineBreak.txt // LineBreak.txt
// The unassigned code points that default to "ID" include ranges in the following blocks: // The unassigned code points that default to "ID" include ranges in the following blocks:
// [U+3400..U+4DBF, U+4E00..U+9FFF, U+F900..U+FAFF, U+20000..U+2A6DF, U+2A700..U+2B73F, U+2B740..U+2B81F, U+2F800..U+2FA1F, U+20000..U+2FFFD, U+30000..U+3FFFD] // [U+3400..U+4DBF, U+4E00..U+9FFF, U+F900..U+FAFF, U+20000..U+2A6DF, U+2A700..U+2B73F, U+2B740..U+2B81F, U+2F800..U+2FA1F, U+20000..U+2FFFD, U+30000..U+3FFFD]
@ -715,7 +715,7 @@ struct UnicodeData {
|| (codepoint >= 0x2F800 && codepoint <= 0x2FA1F) || (codepoint >= 0x2F800 && codepoint <= 0x2FA1F)
|| (codepoint >= 0x20000 && codepoint <= 0x2FFFD) || (codepoint >= 0x20000 && codepoint <= 0x2FFFD)
|| (codepoint >= 0x30000 && codepoint <= 0x3FFFD)) { || (codepoint >= 0x30000 && codepoint <= 0x3FFFD)) {
p.line_break_class = LineBreak_ID; p.lineBreakClass = LineBreak_ID;
} }
mirroredChar = 0; mirroredChar = 0;
@ -732,9 +732,9 @@ struct UnicodeData {
p.upperCaseSpecial = 0; p.upperCaseSpecial = 0;
p.titleCaseSpecial = 0; p.titleCaseSpecial = 0;
p.caseFoldSpecial = 0; p.caseFoldSpecial = 0;
p.graphemeBreak = GraphemeBreakOther; p.graphemeBreakClass = GraphemeBreak_Other;
p.wordBreak = WordBreakOther; p.wordBreakClass = WordBreak_Other;
p.sentenceBreak = SentenceBreakOther; p.sentenceBreakClass = SentenceBreak_Other;
p.script = 0; // Common p.script = 0; // Common
propertyIndex = -1; propertyIndex = -1;
excludedComposition = false; excludedComposition = false;
@ -1299,7 +1299,7 @@ static void readLineBreak()
for (int codepoint = from; codepoint <= to; ++codepoint) { for (int codepoint = from; codepoint <= to; ++codepoint) {
UnicodeData &d = UnicodeData::valueRef(codepoint); UnicodeData &d = UnicodeData::valueRef(codepoint);
d.p.line_break_class = lb; d.p.lineBreakClass = lb;
} }
} }
} }
@ -1506,13 +1506,13 @@ static void readGraphemeBreak()
Q_ASSERT(ok); Q_ASSERT(ok);
} }
GraphemeBreak brk = grapheme_break_map.value(l[1], GraphemeBreak_Unassigned); GraphemeBreakClass brk = grapheme_break_map.value(l[1], GraphemeBreak_Unassigned);
if (brk == GraphemeBreak_Unassigned) if (brk == GraphemeBreak_Unassigned)
qFatal("unassigned grapheme break class: %s", l[1].constData()); qFatal("unassigned grapheme break class: %s", l[1].constData());
for (int codepoint = from; codepoint <= to; ++codepoint) { for (int codepoint = from; codepoint <= to; ++codepoint) {
UnicodeData &ud = UnicodeData::valueRef(codepoint); UnicodeData &ud = UnicodeData::valueRef(codepoint);
ud.p.graphemeBreak = brk; ud.p.graphemeBreakClass = brk;
} }
} }
} }
@ -1557,13 +1557,13 @@ static void readWordBreak()
Q_ASSERT(ok); Q_ASSERT(ok);
} }
WordBreak brk = word_break_map.value(l[1], WordBreak_Unassigned); WordBreakClass brk = word_break_map.value(l[1], WordBreak_Unassigned);
if (brk == WordBreak_Unassigned) if (brk == WordBreak_Unassigned)
qFatal("unassigned word break class: %s", l[1].constData()); qFatal("unassigned word break class: %s", l[1].constData());
for (int codepoint = from; codepoint <= to; ++codepoint) { for (int codepoint = from; codepoint <= to; ++codepoint) {
UnicodeData &ud = UnicodeData::valueRef(codepoint); UnicodeData &ud = UnicodeData::valueRef(codepoint);
ud.p.wordBreak = brk; ud.p.wordBreakClass = brk;
} }
} }
} }
@ -1608,13 +1608,13 @@ static void readSentenceBreak()
Q_ASSERT(ok); Q_ASSERT(ok);
} }
SentenceBreak brk = sentence_break_map.value(l[1], SentenceBreak_Unassigned); SentenceBreakClass brk = sentence_break_map.value(l[1], SentenceBreak_Unassigned);
if (brk == SentenceBreak_Unassigned) if (brk == SentenceBreak_Unassigned)
qFatal("unassigned sentence break class: %s", l[1].constData()); qFatal("unassigned sentence break class: %s", l[1].constData());
for (int codepoint = from; codepoint <= to; ++codepoint) { for (int codepoint = from; codepoint <= to; ++codepoint) {
UnicodeData &ud = UnicodeData::valueRef(codepoint); UnicodeData &ud = UnicodeData::valueRef(codepoint);
ud.p.sentenceBreak = brk; ud.p.sentenceBreakClass = brk;
} }
} }
} }
@ -2183,17 +2183,17 @@ static QByteArray createPropertyInfo()
// " ushort unicodeVersion : 4;\n" // " ushort unicodeVersion : 4;\n"
out += QByteArray::number( p.age ); out += QByteArray::number( p.age );
out += ", "; out += ", ";
// " ushort graphemeBreak : 8; /* 4 used */\n" // " ushort graphemeBreakClass : 8; /* 4 used */\n"
// " ushort wordBreak : 8; /* 4 used */\n" // " ushort wordBreakClass : 8; /* 4 used */\n"
// " ushort sentenceBreak : 8; /* 4 used */\n" // " ushort sentenceBreakClass : 8; /* 4 used */\n"
// " ushort line_break_class : 8; /* 6 used */\n" // " ushort lineBreakClass : 8; /* 6 used */\n"
out += QByteArray::number( p.graphemeBreak ); out += QByteArray::number( p.graphemeBreakClass );
out += ", "; out += ", ";
out += QByteArray::number( p.wordBreak ); out += QByteArray::number( p.wordBreakClass );
out += ", "; out += ", ";
out += QByteArray::number( p.sentenceBreak ); out += QByteArray::number( p.sentenceBreakClass );
out += ", "; out += ", ";
out += QByteArray::number( p.line_break_class ); out += QByteArray::number( p.lineBreakClass );
out += ", "; out += ", ";
// " ushort script : 8; /* 5 used */\n" // " ushort script : 8; /* 5 used */\n"
out += QByteArray::number( p.script ); out += QByteArray::number( p.script );
@ -2225,24 +2225,24 @@ static QByteArray createPropertyInfo()
" return qGetProp(ucs2);\n" " return qGetProp(ucs2);\n"
"}\n\n"; "}\n\n";
out += "Q_CORE_EXPORT GraphemeBreak QT_FASTCALL graphemeBreakClass(uint ucs4)\n" out += "Q_CORE_EXPORT GraphemeBreakClass QT_FASTCALL graphemeBreakClass(uint ucs4)\n"
"{\n" "{\n"
" return (GraphemeBreak)qGetProp(ucs4)->graphemeBreak;\n" " return (GraphemeBreakClass)qGetProp(ucs4)->graphemeBreakClass;\n"
"}\n" "}\n"
"\n" "\n"
"Q_CORE_EXPORT WordBreak QT_FASTCALL wordBreakClass(uint ucs4)\n" "Q_CORE_EXPORT WordBreakClass QT_FASTCALL wordBreakClass(uint ucs4)\n"
"{\n" "{\n"
" return (WordBreak)qGetProp(ucs4)->wordBreak;\n" " return (WordBreakClass)qGetProp(ucs4)->wordBreakClass;\n"
"}\n" "}\n"
"\n" "\n"
"Q_CORE_EXPORT SentenceBreak QT_FASTCALL sentenceBreakClass(uint ucs4)\n" "Q_CORE_EXPORT SentenceBreakClass QT_FASTCALL sentenceBreakClass(uint ucs4)\n"
"{\n" "{\n"
" return (SentenceBreak)qGetProp(ucs4)->sentenceBreak;\n" " return (SentenceBreakClass)qGetProp(ucs4)->sentenceBreakClass;\n"
"}\n" "}\n"
"\n" "\n"
"Q_CORE_EXPORT LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4)\n" "Q_CORE_EXPORT LineBreakClass QT_FASTCALL lineBreakClass(uint ucs4)\n"
"{\n" "{\n"
" return (LineBreakClass)qGetProp(ucs4)->line_break_class;\n" " return (LineBreakClass)qGetProp(ucs4)->lineBreakClass;\n"
"}\n" "}\n"
"\n" "\n"
"Q_CORE_EXPORT Script QT_FASTCALL script(uint ucs4)\n" "Q_CORE_EXPORT Script QT_FASTCALL script(uint ucs4)\n"
@ -2819,9 +2819,9 @@ int main(int, char **)
f.write("namespace QUnicodeTables {\n\n"); f.write("namespace QUnicodeTables {\n\n");
f.write(property_string); f.write(property_string);
f.write(scriptEnumDeclaration); f.write(scriptEnumDeclaration);
f.write(grapheme_break_string); f.write(grapheme_break_class_string);
f.write(word_break_string); f.write(word_break_class_string);
f.write(sentence_break_string); f.write(sentence_break_class_string);
f.write(line_break_class_string); f.write(line_break_class_string);
f.write(methods); f.write(methods);
f.write("} // namespace QUnicodeTables\n\n" f.write("} // namespace QUnicodeTables\n\n"