MCL/sf/os/textandloc: comparison fontservices/textshaperplugin/IcuSource/layout/KhmerReordering.cpp

equal deleted inserted replaced

--1:000000000000
+:1fb32624e06b
+/*
+*
+* (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved
+*
+* This file is a modification of the ICU file IndicReordering.cpp
+* by Jens Herden and Javier Sola for Khmer language
+*
+*/
+#include "LETypes.h"
+#include "KhmerReordering.h"
+#include "LEGlyphStorage.h"
+U_NAMESPACE_BEGIN
+// Characters that get refered to by name...
+enum
+{
+C_SIGN_ZWNJ     = 0x200C,
+C_SIGN_ZWJ      = 0x200D,
+C_DOTTED_CIRCLE = 0x25CC,
+C_RO            = 0x179A,
+C_VOWEL_AA      = 0x17B6,
+C_SIGN_NIKAHIT  = 0x17C6,
+C_VOWEL_E       = 0x17C1,
+C_COENG         = 0x17D2
+};
+enum
+{
+// simple classes, they are used in the statetable (in this file) to control the length of a syllable
+// they are also used to know where a character should be placed (location in reference to the base character)
+// and also to know if a character, when independtly displayed, should be displayed with a dotted-circle to
+// indicate error in syllable construction
+_xx = KhmerClassTable::CC_RESERVED,
+_sa = KhmerClassTable::CC_SIGN_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_POS_ABOVE,
+_sp = KhmerClassTable::CC_SIGN_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE| KhmerClassTable::CF_POS_AFTER,
+_c1 = KhmerClassTable::CC_CONSONANT | KhmerClassTable::CF_CONSONANT,
+_c2 = KhmerClassTable::CC_CONSONANT2 | KhmerClassTable::CF_CONSONANT,
+_c3 = KhmerClassTable::CC_CONSONANT3 | KhmerClassTable::CF_CONSONANT,
+_rb = KhmerClassTable::CC_ROBAT | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE,
+_cs = KhmerClassTable::CC_CONSONANT_SHIFTER | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_SHIFTER,
+_dl = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BEFORE | KhmerClassTable::CF_DOTTED_CIRCLE,
+_db = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BELOW | KhmerClassTable::CF_DOTTED_CIRCLE,
+_da = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_ABOVE_VOWEL,
+_dr = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE,
+_co = KhmerClassTable::CC_COENG | KhmerClassTable::CF_COENG | KhmerClassTable::CF_DOTTED_CIRCLE,
+// split vowel
+_va = _da | KhmerClassTable::CF_SPLIT_VOWEL,
+_vr = _dr | KhmerClassTable::CF_SPLIT_VOWEL
+};
+// Character class tables
+// _xx character does not combine into syllable, such as numbers, puntuation marks, non-Khmer signs...
+// _sa Sign placed above the base
+// _sp Sign placed after the base
+// _c1 Consonant of type 1 or independent vowel (independent vowels behave as type 1 consonants)
+// _c2 Consonant of type 2 (only RO)
+// _c3 Consonant of type 3
+// _rb Khmer sign robat u17CC. combining mark for subscript consonants
+// _cd Consonant-shifter
+// _dl Dependent vowel placed before the base (left of the base)
+// _db Dependent vowel placed below the base
+// _da Dependent vowel placed above the base
+// _dr Dependent vowel placed behind the base (right of the base)
+// _co Khmer combining mark COENG u17D2, combines with the consonant or independent vowel following
+//     it to create a subscript consonant or independent vowel
+// _va Khmer split vowel in wich the first part is before the base and the second one above the base
+// _vr Khmer split vowel in wich the first part is before the base and the second one behind (right of) the base
+static const KhmerClassTable::CharClass khmerCharClasses[] =
+{
+_c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, // 1780 - 178F
+_c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c2, _c1, _c1, _c1, _c3, _c3, // 1790 - 179F
+_c1, _c3, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, // 17A0 - 17AF
+_c1, _c1, _c1, _c1, _dr, _dr, _dr, _da, _da, _da, _da, _db, _db, _db, _va, _vr, // 17B0 - 17BF
+_vr, _dl, _dl, _dl, _vr, _vr, _sa, _sp, _sp, _cs, _cs, _sa, _rb, _sa, _sa, _sa, // 17C0 - 17CF
+_sa, _sa, _co, _sa, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _sa, _xx, _xx, // 17D0 - 17DF
+};
+//
+// Khmer Class Tables
+//
+//
+// The range of characters defined in the above table is defined here. FOr Khmer 1780 to 17DF
+// Even if the Khmer range is bigger, all other characters are not combinable, and therefore treated
+// as _xx
+static const KhmerClassTable khmerClassTable = {0x1780, 0x17df, khmerCharClasses};
+// Below we define how a character in the input string is either in the khmerCharClasses table
+// (in which case we get its type back), a ZWJ or ZWNJ (two characters that may appear
+// within the syllable, but are not in the table) we also get their type back, or an unknown object
+// in which case we get _xx (CC_RESERVED) back
+KhmerClassTable::CharClass KhmerClassTable::getCharClass(LEUnicode ch) const
+{
+if (ch == C_SIGN_ZWJ) {
+return CC_ZERO_WIDTH_J_MARK;
+}
+if (ch == C_SIGN_ZWNJ) {
+return CC_ZERO_WIDTH_NJ_MARK;
+}
+if (ch < firstChar || ch > lastChar) {
+return CC_RESERVED;
+}
+return classTable[ch - firstChar];
+}
+const KhmerClassTable *KhmerClassTable::getKhmerClassTable()
+{
+return &khmerClassTable;
+}
+class ReorderingOutput : public UMemory {
+private:
+le_int32 fOutIndex;
+LEUnicode *fOutChars;
+LEGlyphStorage &fGlyphStorage;
+public:
+ReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage)
+: fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage)
+{
+// nothing else to do...
+}
+~ReorderingOutput()
+{
+// nothing to do here...
+}
+void writeChar(LEUnicode ch, le_uint32 charIndex, const LETag *charTags)
+{
+LEErrorCode success = LE_NO_ERROR;
+fOutChars[fOutIndex] = ch;
+fGlyphStorage.setCharIndex(fOutIndex, charIndex, success);
+fGlyphStorage.setAuxData(fOutIndex, (void *) charTags, success);
+fOutIndex += 1;
+}
+le_int32 getOutputIndex()
+{
+return fOutIndex;
+}
+};
+static const LETag emptyTag       = 0x00000000; // ''
+//TODO remove unused flags
+//static const LETag nuktFeatureTag = LE_NUKT_FEATURE_TAG;
+//static const LETag akhnFeatureTag = LE_AKHN_FEATURE_TAG;
+//static const LETag rphfFeatureTag = LE_RPHF_FEATURE_TAG;
+static const LETag blwfFeatureTag = LE_BLWF_FEATURE_TAG;
+//static const LETag halfFeatureTag = LE_HALF_FEATURE_TAG;
+static const LETag pstfFeatureTag = LE_PSTF_FEATURE_TAG;
+//static const LETag vatuFeatureTag = LE_VATU_FEATURE_TAG;
+static const LETag presFeatureTag = LE_PRES_FEATURE_TAG;
+static const LETag blwsFeatureTag = LE_BLWS_FEATURE_TAG;
+static const LETag abvsFeatureTag = LE_ABVS_FEATURE_TAG;
+static const LETag pstsFeatureTag = LE_PSTS_FEATURE_TAG;
+//static const LETag halnFeatureTag = LE_HALN_FEATURE_TAG;
+static const LETag blwmFeatureTag = LE_BLWM_FEATURE_TAG;
+static const LETag abvmFeatureTag = LE_ABVM_FEATURE_TAG;
+static const LETag distFeatureTag = LE_DIST_FEATURE_TAG;
+static const LETag prefFeatureTag = LE_PREF_FEATURE_TAG;
+static const LETag abvfFeatureTag = LE_ABVF_FEATURE_TAG;
+static const LETag cligFeatureTag = LE_CLIG_FEATURE_TAG;
+static const LETag mkmkFeatureTag = LE_MKMK_FEATURE_TAG;
+// These are in the order in which the features need to be applied
+// for correct processing
+static const LETag featureOrder[] =
+{
+// Shaping features
+prefFeatureTag, blwfFeatureTag, abvfFeatureTag, pstfFeatureTag,
+presFeatureTag, blwsFeatureTag, abvsFeatureTag, pstsFeatureTag,
+cligFeatureTag,
+// Positioning features
+distFeatureTag, blwmFeatureTag, abvmFeatureTag, mkmkFeatureTag,
+emptyTag
+};
+static const LETag tagPref[] =
+{
+prefFeatureTag, presFeatureTag,
+cligFeatureTag,
+// Positioning features
+distFeatureTag,
+emptyTag
+};
+static const LETag tagAbvf[] =
+{
+abvfFeatureTag, abvsFeatureTag,
+cligFeatureTag,
+// Positioning features
+distFeatureTag, abvmFeatureTag, mkmkFeatureTag,
+emptyTag
+};
+static const LETag tagPstf[] =
+{
+blwfFeatureTag, blwsFeatureTag,
+prefFeatureTag, presFeatureTag,
+pstfFeatureTag, pstsFeatureTag,
+cligFeatureTag,
+// Positioning features
+distFeatureTag, blwmFeatureTag,
+emptyTag
+};
+static const LETag tagBlwf[] =
+{
+blwfFeatureTag, blwsFeatureTag,
+cligFeatureTag,
+// Positioning features
+distFeatureTag, blwmFeatureTag, mkmkFeatureTag,
+emptyTag
+};
+// TODO do we need all of them?
+static const LETag tagDefault[] =
+{
+// Shaping feature
+prefFeatureTag, blwfFeatureTag, /*abvfFeatureTag,*/ /*pstfFeatureTag, */
+presFeatureTag, blwsFeatureTag, /*abvsFeatureTag,*/ /*pstsFeatureTag,*/
+cligFeatureTag,
+// Positioning features
+distFeatureTag, abvmFeatureTag, blwmFeatureTag, mkmkFeatureTag,
+emptyTag
+};
+// The stateTable is used to calculate the end (the length) of a well
+// formed Khmer Syllable.
+//
+// Each horizontal line is ordered exactly the same way as the values in KhmerClassTable
+// CharClassValues in KhmerReordering.h This coincidence of values allows the
+// follow up of the table.
+//
+// Each line corresponds to a state, which does not necessarily need to be a type
+// of component... for example, state 2 is a base, with is always a first character
+// in the syllable, but the state could be produced a consonant of any type when
+// it is the first character that is analysed (in ground state).
+//
+// Differentiating 3 types of consonants is necessary in order to
+// forbid the use of certain combinations, such as having a second
+// coeng after a coeng RO,
+// The inexistent possibility of having a type 3 after another type 3 is permitted,
+// eliminating it would very much complicate the table, and it does not create typing
+// problems, as the case above.
+//
+// The table is quite complex, in order to limit the number of coeng consonants
+// to 2 (by means of the table).
+//
+// There a peculiarity, as far as Unicode is concerned:
+// - The consonant-shifter is considered in two possible different
+//   locations, the one considered in Unicode 3.0 and the one considered in
+//   Unicode 4.0. (there is a backwards compatibility problem in this standard).
+// xx    independent character, such as a number, punctuation sign or non-khmer char
+//
+// c1    Khmer consonant of type 1 or an independent vowel
+//       that is, a letter in which the subscript for is only under the
+//       base, not taking any space to the right or to the left
+//
+// c2    Khmer consonant of type 2, the coeng form takes space under
+//       and to the left of the base (only RO is of this type)
+//
+// c3    Khmer consonant of type 3. Its subscript form takes space under
+//       and to the right of the base.
+//
+// cs    Khmer consonant shifter
+//
+// rb    Khmer robat
+//
+// co    coeng character (u17D2)
+//
+// dv    dependent vowel (including split vowels, they are treated in the same way).
+//       even if dv is not defined above, the component that is really tested for is
+//       KhmerClassTable::CC_DEPENDENT_VOWEL, which is common to all dependent vowels
+//
+// zwj   Zero Width joiner
+//
+// zwnj  Zero width non joiner
+//
+// sa    above sign
+//
+// sp    post sign
+//
+// there are lines with equal content but for an easier understanding
+// (and maybe change in the future) we did not join them
+//
+static const le_int8 khmerStateTable[][KhmerClassTable::CC_COUNT] =
+{
+//   xx  c1  c2  c3 zwnj cs  rb  co  dv  sa  sp zwj
+{ 1,  2,  2,  2,  1,  1,  1,  6,  1,  1,  1,  2}, //  0 - ground state
+{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  1 - exit state (or sign to the right of the syllable)
+{-1, -1, -1, -1,  3,  4,  5,  6, 16, 17,  1, -1}, //  2 - Base consonant
+{-1, -1, -1, -1, -1,  4, -1, -1, 16, -1, -1, -1}, //  3 - First ZWNJ before a register shifter
+//      It can only be followed by a shifter or a vowel
+{-1, -1, -1, -1, 15, -1, -1,  6, 16, 17,  1, 14}, //  4 - First register shifter
+{-1, -1, -1, -1, -1, -1, -1, -1, 20, -1,  1, -1}, //  5 - Robat
+{-1,  7,  8,  9, -1, -1, -1, -1, -1, -1, -1, -1}, //  6 - First Coeng
+{-1, -1, -1, -1, 12, 13, -1, 10, 16, 17,  1, 14}, //  7 - First consonant of type 1 after coeng
+{-1, -1, -1, -1, 12, 13, -1, -1, 16, 17,  1, 14}, //  8 - First consonant of type 2 after coeng
+{-1, -1, -1, -1, 12, 13, -1, 10, 16, 17,  1, 14}, //  9 - First consonant or type 3 after ceong
+{-1, 11, 11, 11, -1, -1, -1, -1, -1, -1, -1, -1}, // 10 - Second Coeng (no register shifter before)
+{-1, -1, -1, -1, 15, -1, -1, -1, 16, 17,  1, 14}, // 11 - Second coeng consonant (or ind. vowel) no register shifter before
+{-1, -1,  1, -1, -1, 13, -1, -1, 16, -1, -1, -1}, // 12 - Second ZWNJ before a register shifter
+{-1, -1, -1, -1, 15, -1, -1, -1, 16, 17,  1, 14}, // 13 - Second register shifter
+{-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 14 - ZWJ before vowel
+{-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 15 - ZWNJ before vowel
+{-1, -1, -1, -1, -1, -1, -1, -1, -1, 17,  1, 18}, // 16 - dependent vowel
+{-1, -1,  1, -1, -1, -1, -1, -1, -1, -1,  1, 18}, // 17 - sign above
+{-1, -1, -1, -1, -1, -1, -1, 19, -1, -1, -1, -1}, // 18 - ZWJ after vowel
+{-1,  1, -1,  1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19 - Third coeng
+{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1, -1}, // 20 - dependent vowel after a Robat
+};
+const LETag *KhmerReordering::getFeatureOrder()
+{
+return featureOrder;
+}
+// Given an input string of characters and a location in which to start looking
+// calculate, using the state table, which one is the last character of the syllable
+// that starts in the starting position.
+le_int32 KhmerReordering::findSyllable(const KhmerClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount)
+{
+le_int32 cursor = prev;
+le_int8 state = 0;
+while (cursor < charCount) {
+KhmerClassTable::CharClass charClass = (classTable->getCharClass(chars[cursor]) & KhmerClassTable::CF_CLASS_MASK);
+state = khmerStateTable[state][charClass];
+if (state < 0) {
+break;
+}
+cursor += 1;
+}
+return cursor;
+}
+// This is the real reordering function as applied to the Khmer language
+le_int32 KhmerReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 /*scriptCode*/,
+LEUnicode *outChars, LEGlyphStorage &glyphStorage)
+{
+const KhmerClassTable *classTable = KhmerClassTable::getKhmerClassTable();
+ReorderingOutput output(outChars, glyphStorage);
+KhmerClassTable::CharClass charClass;
+le_int32 i, prev = 0, coengRo;
+// This loop only exits when we reach the end of a run, which may contain
+// several syllables.
+while (prev < charCount) {
+le_int32 syllable = findSyllable(classTable, chars, prev, charCount);
+// write a pre vowel or the pre part of a split vowel first
+// and look out for coeng + ro. RO is the only vowel of type 2, and
+// therefore the only one that requires saving space before the base.
+coengRo = -1;  // There is no Coeng Ro, if found this value will change
+for (i = prev; i < syllable; i += 1) {
+charClass = classTable->getCharClass(chars[i]);
+// if a split vowel, write the pre part. In Khmer the pre part
+// is the same for all split vowels, same glyph as pre vowel C_VOWEL_E
+if (charClass & KhmerClassTable::CF_SPLIT_VOWEL) {
+output.writeChar(C_VOWEL_E, i, &tagPref[0]);
+break; // there can be only one vowel
+}
+// if a vowel with pos before write it out
+if (charClass & KhmerClassTable::CF_POS_BEFORE) {
+output.writeChar(chars[i], i, &tagPref[0]);
+break; // there can be only one vowel
+}
+// look for coeng + ro and remember position
+// works because coeng + ro is always in front of a vowel (if there is a vowel)
+// and because CC_CONSONANT2 is enough to identify it, as it is the only consonant
+// with this flag
+if ( (charClass & KhmerClassTable::CF_COENG) && (i + 1 < syllable) &&
+( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == KhmerClassTable::CC_CONSONANT2) )
+{
+coengRo = i;
+}
+}
+// write coeng + ro if found
+if (coengRo > -1) {
+output.writeChar(C_COENG, coengRo, &tagPref[0]);
+output.writeChar(C_RO, coengRo + 1, &tagPref[0]);
+}
+// shall we add a dotted circle?
+// If in the position in which the base should be (first char in the string) there is
+// a character that has the Dotted circle flag (a character that cannot be a base)
+// then write a dotted circle
+if (classTable->getCharClass(chars[prev]) & KhmerClassTable::CF_DOTTED_CIRCLE) {
+output.writeChar(C_DOTTED_CIRCLE, prev, &tagDefault[0]);
+}
+// copy what is left to the output, skipping before vowels and coeng Ro if they are present
+for (i = prev; i < syllable; i += 1) {
+charClass = classTable->getCharClass(chars[i]);
+// skip a before vowel, it was already processed
+if (charClass & KhmerClassTable::CF_POS_BEFORE) {
+continue;
+}
+// skip coeng + ro, it was already processed
+if (i == coengRo) {
+i += 1;
+continue;
+}
+switch (charClass & KhmerClassTable::CF_POS_MASK) {
+case KhmerClassTable::CF_POS_ABOVE :
+output.writeChar(chars[i], i, &tagAbvf[0]);
+break;
+case KhmerClassTable::CF_POS_AFTER :
+output.writeChar(chars[i], i, &tagPstf[0]);
+break;
+case KhmerClassTable::CF_POS_BELOW :
+output.writeChar(chars[i], i, &tagBlwf[0]);
+break;
+default:
+// assign the correct flags to a coeng consonant
+// Consonants of type 3 are taged as Post forms and those type 1 as below forms
+if ( (charClass & KhmerClassTable::CF_COENG) && i + 1 < syllable ) {
+if ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK)
+== KhmerClassTable::CC_CONSONANT3) {
+output.writeChar(chars[i], i, &tagPstf[0]);
+i += 1;
+output.writeChar(chars[i], i, &tagPstf[0]);
+}
+else {
+output.writeChar(chars[i], i, &tagBlwf[0]);
+i += 1;
+output.writeChar(chars[i], i, &tagBlwf[0]);
+}
+break;
+}
+// if a shifter is followed by an above vowel change the shifter to below form,
+// an above vowel can have two possible positions i + 1 or i + 3
+// (position i+1 corresponds to unicode 3, position i+3 to Unicode 4)
+// and there is an extra rule for C_VOWEL_AA + C_SIGN_NIKAHIT also for two
+// different positions, right after the shifter or after a vowel (Unicode 4)
+if ( (charClass & KhmerClassTable::CF_SHIFTER) && (i + 1 < syllable) ) {
+if ((classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_ABOVE_VOWEL)
+|| (i + 2 < syllable
+&& ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)
+&& ( (classTable->getCharClass(chars[i + 2]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT))
+|| (i + 3 < syllable && (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_ABOVE_VOWEL))
+|| (i + 4 < syllable
+&& ( (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)
+&& ( (classTable->getCharClass(chars[i + 4]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT) ) )
+{
+output.writeChar(chars[i], i, &tagBlwf[0]);
+break;
+}
+}
+// default - any other characters
+output.writeChar(chars[i], i, &tagDefault[0]);
+break;
+} // switch
+} // for
+prev = syllable; // move the pointer to the start of next syllable
+}
+return output.getOutputIndex();
+}
+U_NAMESPACE_END