icuSources/layout/KhmerReordering.cpp

   1 /*
   2  *
   3  * (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved
   4  *
   5  * This file is a modification of the ICU file IndicReordering.cpp
   6  * by Jens Herden and Javier Sola for Khmer language
   7  *
   8  */
   9
  10 #include "LETypes.h"
  11 #include "OpenTypeTables.h"
  12 #include "KhmerReordering.h"
  13 #include "LEGlyphStorage.h"
  14
  15
  16 U_NAMESPACE_BEGIN
  17
  18 // Characters that get refered to by name...
  19 enum
  20 {
  21     C_SIGN_ZWNJ     = 0x200C,
  22     C_SIGN_ZWJ      = 0x200D,
  23     C_DOTTED_CIRCLE = 0x25CC,
  24     C_RO            = 0x179A,
  25     C_VOWEL_AA      = 0x17B6,
  26     C_SIGN_NIKAHIT  = 0x17C6,
  27     C_VOWEL_E       = 0x17C1,
  28     C_COENG         = 0x17D2
  29 };
  30
  31
  32 enum
  33 {
  34     // simple classes, they are used in the statetable (in this file) to control the length of a syllable
  35     // they are also used to know where a character should be placed (location in reference to the base character)
  36     // and also to know if a character, when independtly displayed, should be displayed with a dotted-circle to
  37     // indicate error in syllable construction
  38     _xx = KhmerClassTable::CC_RESERVED,
  39     _sa = KhmerClassTable::CC_SIGN_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_POS_ABOVE,
  40     _sp = KhmerClassTable::CC_SIGN_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE| KhmerClassTable::CF_POS_AFTER,
  41     _c1 = KhmerClassTable::CC_CONSONANT | KhmerClassTable::CF_CONSONANT,
  42     _c2 = KhmerClassTable::CC_CONSONANT2 | KhmerClassTable::CF_CONSONANT,
  43     _c3 = KhmerClassTable::CC_CONSONANT3 | KhmerClassTable::CF_CONSONANT,
  44     _rb = KhmerClassTable::CC_ROBAT | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE,
  45     _cs = KhmerClassTable::CC_CONSONANT_SHIFTER | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_SHIFTER,
  46     _dl = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BEFORE | KhmerClassTable::CF_DOTTED_CIRCLE,
  47     _db = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BELOW | KhmerClassTable::CF_DOTTED_CIRCLE,
  48     _da = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_ABOVE_VOWEL,
  49     _dr = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE,
  50     _co = KhmerClassTable::CC_COENG | KhmerClassTable::CF_COENG | KhmerClassTable::CF_DOTTED_CIRCLE,
  51
  52     // split vowel
  53     _va = _da | KhmerClassTable::CF_SPLIT_VOWEL,
  54     _vr = _dr | KhmerClassTable::CF_SPLIT_VOWEL
  55 };
  56
  57
  58 // Character class tables
  59 // _xx character does not combine into syllable, such as numbers, puntuation marks, non-Khmer signs...
  60 // _sa Sign placed above the base
  61 // _sp Sign placed after the base
  62 // _c1 Consonant of type 1 or independent vowel (independent vowels behave as type 1 consonants)
  63 // _c2 Consonant of type 2 (only RO)
  64 // _c3 Consonant of type 3
  65 // _rb Khmer sign robat u17CC. combining mark for subscript consonants
  66 // _cd Consonant-shifter
  67 // _dl Dependent vowel placed before the base (left of the base)
  68 // _db Dependent vowel placed below the base
  69 // _da Dependent vowel placed above the base
  70 // _dr Dependent vowel placed behind the base (right of the base)
  71 // _co Khmer combining mark COENG u17D2, combines with the consonant or independent vowel following
  72 //     it to create a subscript consonant or independent vowel
  73 // _va Khmer split vowel in wich the first part is before the base and the second one above the base
  74 // _vr Khmer split vowel in wich the first part is before the base and the second one behind (right of) the base
  75
  76 static const KhmerClassTable::CharClass khmerCharClasses[] =
  77 {
  78     _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, // 1780 - 178F
  79     _c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c2, _c1, _c1, _c1, _c3, _c3, // 1790 - 179F
  80     _c1, _c3, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, // 17A0 - 17AF
  81     _c1, _c1, _c1, _c1, _dr, _dr, _dr, _da, _da, _da, _da, _db, _db, _db, _va, _vr, // 17B0 - 17BF
  82     _vr, _dl, _dl, _dl, _vr, _vr, _sa, _sp, _sp, _cs, _cs, _sa, _rb, _sa, _sa, _sa, // 17C0 - 17CF
  83     _sa, _sa, _co, _sa, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _sa, _xx, _xx, // 17D0 - 17DF
  84 };
  85
  86
  87 //
  88 // Khmer Class Tables
  89 //
  90
  91 //
  92 // The range of characters defined in the above table is defined here. FOr Khmer 1780 to 17DF
  93 // Even if the Khmer range is bigger, all other characters are not combinable, and therefore treated
  94 // as _xx
  95 static const KhmerClassTable khmerClassTable = {0x1780, 0x17df, khmerCharClasses};
  96
  97
  98 // Below we define how a character in the input string is either in the khmerCharClasses table
  99 // (in which case we get its type back), a ZWJ or ZWNJ (two characters that may appear
 100 // within the syllable, but are not in the table) we also get their type back, or an unknown object
 101 // in which case we get _xx (CC_RESERVED) back
 102 KhmerClassTable::CharClass KhmerClassTable::getCharClass(LEUnicode ch) const
 103 {
 104
 105     if (ch == C_SIGN_ZWJ) {
 106         return CC_ZERO_WIDTH_J_MARK;
 107     }
 108
 109     if (ch == C_SIGN_ZWNJ) {
 110         return CC_ZERO_WIDTH_NJ_MARK;
 111     }
 112
 113     if (ch < firstChar || ch > lastChar) {
 114         return CC_RESERVED;
 115     }
 116
 117     return classTable[ch - firstChar];
 118 }
 119
 120 const KhmerClassTable *KhmerClassTable::getKhmerClassTable()
 121 {
 122     return &khmerClassTable;
 123 }
 124
 125
 126
 127 class KhmerReorderingOutput : public UMemory {
 128 private:
 129     le_int32 fSyllableCount;
 130     le_int32 fOutIndex;
 131     LEUnicode *fOutChars;
 132
 133     LEGlyphStorage &fGlyphStorage;
 134
 135
 136 public:
 137     KhmerReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage)
 138         : fSyllableCount(0), fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage)
 139     {
 140         // nothing else to do...
 141     }
 142
 143     ~KhmerReorderingOutput()
 144     {
 145         // nothing to do here...
 146     }
 147
 148     void reset()
 149     {
 150         fSyllableCount += 1;
 151     }
 152
 153     void writeChar(LEUnicode ch, le_uint32 charIndex, FeatureMask charFeatures)
 154     {
 155         LEErrorCode success = LE_NO_ERROR;
 156
 157         fOutChars[fOutIndex] = ch;
 158
 159         fGlyphStorage.setCharIndex(fOutIndex, charIndex, success);
 160         fGlyphStorage.setAuxData(fOutIndex, charFeatures | (fSyllableCount & LE_GLYPH_GROUP_MASK), success);
 161
 162         fOutIndex += 1;
 163     }
 164
 165     le_int32 getOutputIndex()
 166     {
 167         return fOutIndex;
 168     }
 169 };
 170
 171
 172 #define blwfFeatureTag LE_BLWF_FEATURE_TAG
 173 #define pstfFeatureTag LE_PSTF_FEATURE_TAG
 174 #define presFeatureTag LE_PRES_FEATURE_TAG
 175 #define blwsFeatureTag LE_BLWS_FEATURE_TAG
 176 #define abvsFeatureTag LE_ABVS_FEATURE_TAG
 177 #define pstsFeatureTag LE_PSTS_FEATURE_TAG
 178
 179 #define blwmFeatureTag LE_BLWM_FEATURE_TAG
 180 #define abvmFeatureTag LE_ABVM_FEATURE_TAG
 181 #define distFeatureTag LE_DIST_FEATURE_TAG
 182
 183 #define prefFeatureTag LE_PREF_FEATURE_TAG
 184 #define abvfFeatureTag LE_ABVF_FEATURE_TAG
 185 #define cligFeatureTag LE_CLIG_FEATURE_TAG
 186 #define mkmkFeatureTag LE_MKMK_FEATURE_TAG
 187
 188 #define prefFeatureMask 0x80000000UL
 189 #define blwfFeatureMask 0x40000000UL
 190 #define abvfFeatureMask 0x20000000UL
 191 #define pstfFeatureMask 0x10000000UL
 192 #define presFeatureMask 0x08000000UL
 193 #define blwsFeatureMask 0x04000000UL
 194 #define abvsFeatureMask 0x02000000UL
 195 #define pstsFeatureMask 0x01000000UL
 196 #define cligFeatureMask 0x00800000UL
 197 #define distFeatureMask 0x00400000UL
 198 #define blwmFeatureMask 0x00200000UL
 199 #define abvmFeatureMask 0x00100000UL
 200 #define mkmkFeatureMask 0x00080000UL
 201
 202 #define tagPref    (prefFeatureMask | presFeatureMask | cligFeatureMask | distFeatureMask)
 203 #define tagAbvf    (abvfFeatureMask | abvsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | mkmkFeatureMask)
 204 #define tagPstf    (blwfFeatureMask | blwsFeatureMask | prefFeatureMask | presFeatureMask | pstfFeatureMask | pstsFeatureMask | cligFeatureMask | distFeatureMask | blwmFeatureMask)
 205 #define tagBlwf    (blwfFeatureMask | blwsFeatureMask | cligFeatureMask | distFeatureMask | blwmFeatureMask | mkmkFeatureMask)
 206 #define tagDefault (prefFeatureMask | blwfFeatureMask | presFeatureMask | blwsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | blwmFeatureMask | mkmkFeatureMask)
 207
 208
 209
 210 // These are in the order in which the features need to be applied
 211 // for correct processing
 212 static const FeatureMap featureMap[] =
 213 {
 214     // Shaping features
 215     {prefFeatureTag, prefFeatureMask},
 216     {blwfFeatureTag, blwfFeatureMask},
 217     {abvfFeatureTag, abvfFeatureMask},
 218     {pstfFeatureTag, pstfFeatureMask},
 219     {presFeatureTag, presFeatureMask},
 220     {blwsFeatureTag, blwsFeatureMask},
 221     {abvsFeatureTag, abvsFeatureMask},
 222     {pstsFeatureTag, pstsFeatureMask},
 223     {cligFeatureTag, cligFeatureMask},
 224
 225     // Positioning features
 226     {distFeatureTag, distFeatureMask},
 227     {blwmFeatureTag, blwmFeatureMask},
 228     {abvmFeatureTag, abvmFeatureMask},
 229     {mkmkFeatureTag, mkmkFeatureMask},
 230 };
 231
 232 static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap);
 233
 234 // The stateTable is used to calculate the end (the length) of a well
 235 // formed Khmer Syllable.
 236 //
 237 // Each horizontal line is ordered exactly the same way as the values in KhmerClassTable
 238 // CharClassValues in KhmerReordering.h This coincidence of values allows the
 239 // follow up of the table.
 240 //
 241 // Each line corresponds to a state, which does not necessarily need to be a type
 242 // of component... for example, state 2 is a base, with is always a first character
 243 // in the syllable, but the state could be produced a consonant of any type when
 244 // it is the first character that is analysed (in ground state).
 245 //
 246 // Differentiating 3 types of consonants is necessary in order to
 247 // forbid the use of certain combinations, such as having a second
 248 // coeng after a coeng RO,
 249 // The inexistent possibility of having a type 3 after another type 3 is permitted,
 250 // eliminating it would very much complicate the table, and it does not create typing
 251 // problems, as the case above.
 252 //
 253 // The table is quite complex, in order to limit the number of coeng consonants
 254 // to 2 (by means of the table).
 255 //
 256 // There a peculiarity, as far as Unicode is concerned:
 257 // - The consonant-shifter is considered in two possible different
 258 //   locations, the one considered in Unicode 3.0 and the one considered in
 259 //   Unicode 4.0. (there is a backwards compatibility problem in this standard).
 260
 261
 262 // xx    independent character, such as a number, punctuation sign or non-khmer char
 263 //
 264 // c1    Khmer consonant of type 1 or an independent vowel
 265 //       that is, a letter in which the subscript for is only under the
 266 //       base, not taking any space to the right or to the left
 267 //
 268 // c2    Khmer consonant of type 2, the coeng form takes space under
 269 //       and to the left of the base (only RO is of this type)
 270 //
 271 // c3    Khmer consonant of type 3. Its subscript form takes space under
 272 //       and to the right of the base.
 273 //
 274 // cs    Khmer consonant shifter
 275 //
 276 // rb    Khmer robat
 277 //
 278 // co    coeng character (u17D2)
 279 //
 280 // dv    dependent vowel (including split vowels, they are treated in the same way).
 281 //       even if dv is not defined above, the component that is really tested for is
 282 //       KhmerClassTable::CC_DEPENDENT_VOWEL, which is common to all dependent vowels
 283 //
 284 // zwj   Zero Width joiner
 285 //
 286 // zwnj  Zero width non joiner
 287 //
 288 // sa    above sign
 289 //
 290 // sp    post sign
 291 //
 292 // there are lines with equal content but for an easier understanding
 293 // (and maybe change in the future) we did not join them
 294 //
 295 static const le_int8 khmerStateTable[][KhmerClassTable::CC_COUNT] =
 296 {
 297
 298 //   xx  c1  c2  c3 zwnj cs  rb  co  dv  sa  sp zwj
 299     { 1,  2,  2,  2,  1,  1,  1,  6,  1,  1,  1,  2}, //  0 - ground state
 300     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  1 - exit state (or sign to the right of the syllable)
 301     {-1, -1, -1, -1,  3,  4,  5,  6, 16, 17,  1, -1}, //  2 - Base consonant
 302     {-1, -1, -1, -1, -1,  4, -1, -1, 16, -1, -1, -1}, //  3 - First ZWNJ before a register shifter
 303                                                       //      It can only be followed by a shifter or a vowel
 304     {-1, -1, -1, -1, 15, -1, -1,  6, 16, 17,  1, 14}, //  4 - First register shifter
 305     {-1, -1, -1, -1, -1, -1, -1, -1, 20, -1,  1, -1}, //  5 - Robat
 306     {-1,  7,  8,  9, -1, -1, -1, -1, -1, -1, -1, -1}, //  6 - First Coeng
 307     {-1, -1, -1, -1, 12, 13, -1, 10, 16, 17,  1, 14}, //  7 - First consonant of type 1 after coeng
 308     {-1, -1, -1, -1, 12, 13, -1, -1, 16, 17,  1, 14}, //  8 - First consonant of type 2 after coeng
 309     {-1, -1, -1, -1, 12, 13, -1, 10, 16, 17,  1, 14}, //  9 - First consonant or type 3 after ceong
 310     {-1, 11, 11, 11, -1, -1, -1, -1, -1, -1, -1, -1}, // 10 - Second Coeng (no register shifter before)
 311     {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17,  1, 14}, // 11 - Second coeng consonant (or ind. vowel) no register shifter before
 312     {-1, -1, -1, -1, -1, 13, -1, -1, 16, -1, -1, -1}, // 12 - Second ZWNJ before a register shifter
 313     {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17,  1, 14}, // 13 - Second register shifter
 314     {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 14 - ZWJ before vowel
 315     {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 15 - ZWNJ before vowel
 316     {-1, -1, -1, -1, -1, -1, -1, -1, -1, 17,  1, 18}, // 16 - dependent vowel
 317     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1, 18}, // 17 - sign above
 318     {-1, -1, -1, -1, -1, -1, -1, 19, -1, -1, -1, -1}, // 18 - ZWJ after vowel
 319     {-1,  1, -1,  1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19 - Third coeng
 320     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1, -1}, // 20 - dependent vowel after a Robat
 321
 322 };
 323
 324
 325 const FeatureMap *KhmerReordering::getFeatureMap(le_int32 &count)
 326 {
 327     count = featureMapCount;
 328
 329     return featureMap;
 330 }
 331
 332
 333 // Given an input string of characters and a location in which to start looking
 334 // calculate, using the state table, which one is the last character of the syllable
 335 // that starts in the starting position.
 336 le_int32 KhmerReordering::findSyllable(const KhmerClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount)
 337 {
 338     le_int32 cursor = prev;
 339     le_int8 state = 0;
 340
 341     while (cursor < charCount) {
 342         KhmerClassTable::CharClass charClass = (classTable->getCharClass(chars[cursor]) & KhmerClassTable::CF_CLASS_MASK);
 343
 344         state = khmerStateTable[state][charClass];
 345
 346         if (state < 0) {
 347             break;
 348         }
 349
 350         cursor += 1;
 351     }
 352
 353     return cursor;
 354 }
 355
 356
 357 // This is the real reordering function as applied to the Khmer language
 358
 359 le_int32 KhmerReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 /*scriptCode*/,
 360                                   LEUnicode *outChars, LEGlyphStorage &glyphStorage)
 361 {
 362     const KhmerClassTable *classTable = KhmerClassTable::getKhmerClassTable();
 363
 364     KhmerReorderingOutput output(outChars, glyphStorage);
 365     KhmerClassTable::CharClass charClass;
 366     le_int32 i, prev = 0, coengRo;
 367
 368
 369     // This loop only exits when we reach the end of a run, which may contain
 370     // several syllables.
 371     while (prev < charCount) {
 372         le_int32 syllable = findSyllable(classTable, chars, prev, charCount);
 373
 374         output.reset();
 375
 376         // write a pre vowel or the pre part of a split vowel first
 377         // and look out for coeng + ro. RO is the only vowel of type 2, and
 378         // therefore the only one that requires saving space before the base.
 379         coengRo = -1;  // There is no Coeng Ro, if found this value will change
 380         for (i = prev; i < syllable; i += 1) {
 381             charClass = classTable->getCharClass(chars[i]);
 382
 383             // if a split vowel, write the pre part. In Khmer the pre part
 384             // is the same for all split vowels, same glyph as pre vowel C_VOWEL_E
 385             if (charClass & KhmerClassTable::CF_SPLIT_VOWEL) {
 386                 output.writeChar(C_VOWEL_E, i, tagPref);
 387                 break; // there can be only one vowel
 388             }
 389
 390             // if a vowel with pos before write it out
 391             if (charClass & KhmerClassTable::CF_POS_BEFORE) {
 392                 output.writeChar(chars[i], i, tagPref);
 393                 break; // there can be only one vowel
 394             }
 395
 396             // look for coeng + ro and remember position
 397             // works because coeng + ro is always in front of a vowel (if there is a vowel)
 398             // and because CC_CONSONANT2 is enough to identify it, as it is the only consonant
 399             // with this flag
 400             if ( (charClass & KhmerClassTable::CF_COENG) && (i + 1 < syllable) &&
 401                  ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == KhmerClassTable::CC_CONSONANT2) )
 402             {
 403                     coengRo = i;
 404             }
 405         }
 406
 407         // write coeng + ro if found
 408         if (coengRo > -1) {
 409             output.writeChar(C_COENG, coengRo, tagPref);
 410             output.writeChar(C_RO, coengRo + 1, tagPref);
 411         }
 412
 413         // shall we add a dotted circle?
 414         // If in the position in which the base should be (first char in the string) there is
 415         // a character that has the Dotted circle flag (a character that cannot be a base)
 416         // then write a dotted circle
 417         if (classTable->getCharClass(chars[prev]) & KhmerClassTable::CF_DOTTED_CIRCLE) {
 418             output.writeChar(C_DOTTED_CIRCLE, prev, tagDefault);
 419         }
 420
 421         // copy what is left to the output, skipping before vowels and coeng Ro if they are present
 422         for (i = prev; i < syllable; i += 1) {
 423             charClass = classTable->getCharClass(chars[i]);
 424
 425             // skip a before vowel, it was already processed
 426             if (charClass & KhmerClassTable::CF_POS_BEFORE) {
 427                 continue;
 428             }
 429
 430             // skip coeng + ro, it was already processed
 431             if (i == coengRo) {
 432                 i += 1;
 433                 continue;
 434             }
 435
 436             switch (charClass & KhmerClassTable::CF_POS_MASK) {
 437                 case KhmerClassTable::CF_POS_ABOVE :
 438                     output.writeChar(chars[i], i, tagAbvf);
 439                     break;
 440
 441                 case KhmerClassTable::CF_POS_AFTER :
 442                     output.writeChar(chars[i], i, tagPstf);
 443                     break;
 444
 445                 case KhmerClassTable::CF_POS_BELOW :
 446                     output.writeChar(chars[i], i, tagBlwf);
 447                     break;
 448
 449                 default:
 450                     // assign the correct flags to a coeng consonant
 451                     // Consonants of type 3 are taged as Post forms and those type 1 as below forms
 452                     if ( (charClass & KhmerClassTable::CF_COENG) && i + 1 < syllable ) {
 453                         if ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK)
 454                               == KhmerClassTable::CC_CONSONANT3) {
 455                             output.writeChar(chars[i], i, tagPstf);
 456                             i += 1;
 457                             output.writeChar(chars[i], i, tagPstf);
 458                         }
 459                         else {
 460                             output.writeChar(chars[i], i, tagBlwf);
 461                             i += 1;
 462                             output.writeChar(chars[i], i, tagBlwf);
 463                         }
 464                         break;
 465                     }
 466                     // if a shifter is followed by an above vowel change the shifter to below form,
 467                     // an above vowel can have two possible positions i + 1 or i + 3
 468                     // (position i+1 corresponds to unicode 3, position i+3 to Unicode 4)
 469                     // and there is an extra rule for C_VOWEL_AA + C_SIGN_NIKAHIT also for two
 470                     // different positions, right after the shifter or after a vowel (Unicode 4)
 471                     if ( (charClass & KhmerClassTable::CF_SHIFTER) && (i + 1 < syllable) ) {
 472                         if ((classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_ABOVE_VOWEL)
 473                             || (i + 2 < syllable
 474                                 && ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)
 475                                 && ( (classTable->getCharClass(chars[i + 2]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT))
 476                             || (i + 3 < syllable && (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_ABOVE_VOWEL))
 477                             || (i + 4 < syllable
 478                                 && ( (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)
 479                                 && ( (classTable->getCharClass(chars[i + 4]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT) ) )
 480                         {
 481                             output.writeChar(chars[i], i, tagBlwf);
 482                             break;
 483                         }
 484
 485                     }
 486                     // default - any other characters
 487                     output.writeChar(chars[i], i, tagDefault);
 488                     break;
 489             } // switch
 490         } // for
 491
 492         prev = syllable; // move the pointer to the start of next syllable
 493     }
 494
 495     return output.getOutputIndex();
 496 }
 497
 498
 499 U_NAMESPACE_END