1/* 2/ * 3 * (C) Copyright IBM Corp. 1998-2013 - All Rights Reserved 4 * 5 */ 6 7#include "LETypes.h" 8#include "OpenTypeTables.h" 9#include "OpenTypeUtilities.h" 10#include "IndicReordering.h" 11#include "LEGlyphStorage.h" 12#include "MPreFixups.h" 13 14U_NAMESPACE_BEGIN 15 16#define loclFeatureTag LE_LOCL_FEATURE_TAG 17#define initFeatureTag LE_INIT_FEATURE_TAG 18#define nuktFeatureTag LE_NUKT_FEATURE_TAG 19#define akhnFeatureTag LE_AKHN_FEATURE_TAG 20#define rphfFeatureTag LE_RPHF_FEATURE_TAG 21#define rkrfFeatureTag LE_RKRF_FEATURE_TAG 22#define blwfFeatureTag LE_BLWF_FEATURE_TAG 23#define halfFeatureTag LE_HALF_FEATURE_TAG 24#define pstfFeatureTag LE_PSTF_FEATURE_TAG 25#define vatuFeatureTag LE_VATU_FEATURE_TAG 26#define presFeatureTag LE_PRES_FEATURE_TAG 27#define blwsFeatureTag LE_BLWS_FEATURE_TAG 28#define abvsFeatureTag LE_ABVS_FEATURE_TAG 29#define pstsFeatureTag LE_PSTS_FEATURE_TAG 30#define halnFeatureTag LE_HALN_FEATURE_TAG 31#define cjctFeatureTag LE_CJCT_FEATURE_TAG 32#define blwmFeatureTag LE_BLWM_FEATURE_TAG 33#define abvmFeatureTag LE_ABVM_FEATURE_TAG 34#define distFeatureTag LE_DIST_FEATURE_TAG 35#define caltFeatureTag LE_CALT_FEATURE_TAG 36#define kernFeatureTag LE_KERN_FEATURE_TAG 37 38#define loclFeatureMask 0x80000000UL 39#define rphfFeatureMask 0x40000000UL 40#define blwfFeatureMask 0x20000000UL 41#define halfFeatureMask 0x10000000UL 42#define pstfFeatureMask 0x08000000UL 43#define nuktFeatureMask 0x04000000UL 44#define akhnFeatureMask 0x02000000UL 45#define vatuFeatureMask 0x01000000UL 46#define presFeatureMask 0x00800000UL 47#define blwsFeatureMask 0x00400000UL 48#define abvsFeatureMask 0x00200000UL 49#define pstsFeatureMask 0x00100000UL 50#define halnFeatureMask 0x00080000UL 51#define blwmFeatureMask 0x00040000UL 52#define abvmFeatureMask 0x00020000UL 53#define distFeatureMask 0x00010000UL 54#define initFeatureMask 0x00008000UL 55#define cjctFeatureMask 0x00004000UL 56#define rkrfFeatureMask 0x00002000UL 57#define caltFeatureMask 0x00001000UL 58#define kernFeatureMask 0x00000800UL 59 60// Syllable structure bits 61#define baseConsonantMask 0x00000400UL 62#define consonantMask 0x00000200UL 63#define halfConsonantMask 0x00000100UL 64#define rephConsonantMask 0x00000080UL 65#define matraMask 0x00000040UL 66#define vowelModifierMask 0x00000020UL 67#define markPositionMask 0x00000018UL 68 69#define postBasePosition 0x00000000UL 70#define preBasePosition 0x00000008UL 71#define aboveBasePosition 0x00000010UL 72#define belowBasePosition 0x00000018UL 73 74#define repositionedGlyphMask 0x00000002UL 75 76#define basicShapingFormsMask ( loclFeatureMask | nuktFeatureMask | akhnFeatureMask | rkrfFeatureMask | blwfFeatureMask | halfFeatureMask | vatuFeatureMask | cjctFeatureMask ) 77#define positioningFormsMask ( kernFeatureMask | distFeatureMask | abvmFeatureMask | blwmFeatureMask ) 78#define presentationFormsMask ( presFeatureMask | abvsFeatureMask | blwsFeatureMask | pstsFeatureMask | halnFeatureMask | caltFeatureMask ) 79 80 81#define C_MALAYALAM_VOWEL_SIGN_U 0x0D41 82#define C_DOTTED_CIRCLE 0x25CC 83#define NO_GLYPH 0xFFFF 84 85// Some level of debate as to the proper value for MAX_CONSONANTS_PER_SYLLABLE. Ticket 5588 states that 4 86// is the magic number according to ISCII, but 5 seems to be the more consistent with XP. 87#define MAX_CONSONANTS_PER_SYLLABLE 5 88 89#define INDIC_BLOCK_SIZE 0x7F 90 91class IndicReorderingOutput : public UMemory { 92private: 93 le_int32 fSyllableCount; 94 le_int32 fOutIndex; 95 LEUnicode *fOutChars; 96 97 LEGlyphStorage &fGlyphStorage; 98 99 LEUnicode fMpre; 100 le_int32 fMpreIndex; 101 102 LEUnicode fMbelow; 103 le_int32 fMbelowIndex; 104 105 LEUnicode fMabove; 106 le_int32 fMaboveIndex; 107 108 LEUnicode fMpost; 109 le_int32 fMpostIndex; 110 111 LEUnicode fLengthMark; 112 le_int32 fLengthMarkIndex; 113 114 LEUnicode fAlLakuna; 115 le_int32 fAlLakunaIndex; 116 117 FeatureMask fMatraFeatures; 118 119 le_int32 fMPreOutIndex; 120 MPreFixups *fMPreFixups; 121 122 LEUnicode fVMabove; 123 LEUnicode fVMpost; 124 le_int32 fVMIndex; 125 FeatureMask fVMFeatures; 126 127 LEUnicode fSMabove; 128 LEUnicode fSMbelow; 129 le_int32 fSMIndex; 130 FeatureMask fSMFeatures; 131 132 LEUnicode fPreBaseConsonant; 133 LEUnicode fPreBaseVirama; 134 le_int32 fPBCIndex; 135 FeatureMask fPBCFeatures; 136 137 void saveMatra(LEUnicode matra, le_int32 matraIndex, IndicClassTable::CharClass matraClass) 138 { 139 // FIXME: check if already set, or if not a matra... 140 if (IndicClassTable::isLengthMark(matraClass)) { 141 fLengthMark = matra; 142 fLengthMarkIndex = matraIndex; 143 } else if (IndicClassTable::isAlLakuna(matraClass)) { 144 fAlLakuna = matra; 145 fAlLakunaIndex = matraIndex; 146 } else { 147 switch (matraClass & CF_POS_MASK) { 148 case CF_POS_BEFORE: 149 fMpre = matra; 150 fMpreIndex = matraIndex; 151 break; 152 153 case CF_POS_BELOW: 154 fMbelow = matra; 155 fMbelowIndex = matraIndex; 156 break; 157 158 case CF_POS_ABOVE: 159 fMabove = matra; 160 fMaboveIndex = matraIndex; 161 break; 162 163 case CF_POS_AFTER: 164 fMpost = matra; 165 fMpostIndex = matraIndex; 166 break; 167 168 default: 169 // can't get here... 170 break; 171 } 172 } 173 } 174 175public: 176 IndicReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage, MPreFixups *mpreFixups) 177 : fSyllableCount(0), fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage), 178 fMpre(0), fMpreIndex(0), fMbelow(0), fMbelowIndex(0), fMabove(0), fMaboveIndex(0), 179 fMpost(0), fMpostIndex(0), fLengthMark(0), fLengthMarkIndex(0), fAlLakuna(0), fAlLakunaIndex(0), 180 fMatraFeatures(0), fMPreOutIndex(-1), fMPreFixups(mpreFixups), 181 fVMabove(0), fVMpost(0), fVMIndex(0), fVMFeatures(0), 182 fSMabove(0), fSMbelow(0), fSMIndex(0), fSMFeatures(0), 183 fPreBaseConsonant(0), fPreBaseVirama(0), fPBCIndex(0), fPBCFeatures(0) 184 { 185 // nothing else to do... 186 } 187 188 ~IndicReorderingOutput() 189 { 190 // nothing to do here... 191 } 192 193 void reset() 194 { 195 fSyllableCount += 1; 196 197 fMpre = fMbelow = fMabove = fMpost = fLengthMark = fAlLakuna = 0; 198 fMPreOutIndex = -1; 199 200 fVMabove = fVMpost = 0; 201 fSMabove = fSMbelow = 0; 202 203 fPreBaseConsonant = fPreBaseVirama = 0; 204 } 205 206 void writeChar(LEUnicode ch, le_uint32 charIndex, FeatureMask charFeatures) 207 { 208 LEErrorCode success = LE_NO_ERROR; 209 210 fOutChars[fOutIndex] = ch; 211 212 fGlyphStorage.setCharIndex(fOutIndex, charIndex, success); 213 fGlyphStorage.setAuxData(fOutIndex, charFeatures | (fSyllableCount & LE_GLYPH_GROUP_MASK), success); 214 215 fOutIndex += 1; 216 } 217 218 void setFeatures ( le_uint32 charIndex, FeatureMask charFeatures) 219 { 220 LEErrorCode success = LE_NO_ERROR; 221 222 fGlyphStorage.setAuxData( charIndex, charFeatures, success ); 223 224 } 225 226 FeatureMask getFeatures ( le_uint32 charIndex ) 227 { 228 LEErrorCode success = LE_NO_ERROR; 229 return fGlyphStorage.getAuxData(charIndex,success); 230 } 231 232 void decomposeReorderMatras ( const IndicClassTable *classTable, le_int32 beginSyllable, le_int32 nextSyllable, le_int32 inv_count ) { 233 le_int32 i; 234 LEErrorCode success = LE_NO_ERROR; 235 236 for ( i = beginSyllable ; i < nextSyllable ; i++ ) { 237 if ( classTable->isMatra(fOutChars[i+inv_count])) { 238 IndicClassTable::CharClass matraClass = classTable->getCharClass(fOutChars[i+inv_count]); 239 if ( classTable->isSplitMatra(matraClass)) { 240 le_int32 saveIndex = fGlyphStorage.getCharIndex(i+inv_count,success); 241 le_uint32 saveAuxData = fGlyphStorage.getAuxData(i+inv_count,success); 242 const SplitMatra *splitMatra = classTable->getSplitMatra(matraClass); 243 int j; 244 for (j = 0 ; j < SM_MAX_PIECES && *(splitMatra)[j] != 0 ; j++) { 245 LEUnicode piece = (*splitMatra)[j]; 246 if ( j == 0 ) { 247 fOutChars[i+inv_count] = piece; 248 matraClass = classTable->getCharClass(piece); 249 } else { 250 insertCharacter(piece,i+1+inv_count,saveIndex,saveAuxData); 251 nextSyllable++; 252 } 253 } 254 } 255 256 if ((matraClass & CF_POS_MASK) == CF_POS_BEFORE) { 257 moveCharacter(i+inv_count,beginSyllable+inv_count); 258 } 259 } 260 } 261 } 262 263 void moveCharacter( le_int32 fromPosition, le_int32 toPosition ) { 264 le_int32 i,saveIndex; 265 le_uint32 saveAuxData; 266 LEUnicode saveChar = fOutChars[fromPosition]; 267 LEErrorCode success = LE_NO_ERROR; 268 LEErrorCode success2 = LE_NO_ERROR; 269 saveIndex = fGlyphStorage.getCharIndex(fromPosition,success); 270 saveAuxData = fGlyphStorage.getAuxData(fromPosition,success); 271 272 if ( fromPosition > toPosition ) { 273 for ( i = fromPosition ; i > toPosition ; i-- ) { 274 fOutChars[i] = fOutChars[i-1]; 275 fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i-1,success2),success); 276 fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i-1,success2), success); 277 278 } 279 } else { 280 for ( i = fromPosition ; i < toPosition ; i++ ) { 281 fOutChars[i] = fOutChars[i+1]; 282 fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i+1,success2),success); 283 fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i+1,success2), success); 284 } 285 286 } 287 fOutChars[toPosition] = saveChar; 288 fGlyphStorage.setCharIndex(toPosition,saveIndex,success); 289 fGlyphStorage.setAuxData(toPosition,saveAuxData,success); 290 291 } 292 void insertCharacter( LEUnicode ch, le_int32 toPosition, le_int32 charIndex, le_uint32 auxData ) { 293 LEErrorCode success = LE_NO_ERROR; 294 le_int32 i; 295 fOutIndex += 1; 296 297 for ( i = fOutIndex ; i > toPosition ; i--) { 298 fOutChars[i] = fOutChars[i-1]; 299 fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i-1,success),success); 300 fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i-1,success), success); 301 } 302 303 fOutChars[toPosition] = ch; 304 fGlyphStorage.setCharIndex(toPosition,charIndex,success); 305 fGlyphStorage.setAuxData(toPosition,auxData,success); 306 307 } 308 void removeCharacter( le_int32 fromPosition ) { 309 LEErrorCode success = LE_NO_ERROR; 310 le_int32 i; 311 fOutIndex -= 1; 312 313 for ( i = fromPosition ; i < fOutIndex ; i--) { 314 fOutChars[i] = fOutChars[i+1]; 315 fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i+1,success),success); 316 fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i+1,success), success); 317 } 318 } 319 320 le_bool noteMatra(const IndicClassTable *classTable, LEUnicode matra, le_uint32 matraIndex, FeatureMask matraFeatures, le_bool wordStart) 321 { 322 IndicClassTable::CharClass matraClass = classTable->getCharClass(matra); 323 324 fMatraFeatures = matraFeatures; 325 326 if (wordStart) { 327 fMatraFeatures |= initFeatureMask; 328 } 329 330 if (IndicClassTable::isMatra(matraClass)) { 331 if (IndicClassTable::isSplitMatra(matraClass)) { 332 const SplitMatra *splitMatra = classTable->getSplitMatra(matraClass); 333 int i; 334 335 for (i = 0; i < SM_MAX_PIECES && (*splitMatra)[i] != 0; i += 1) { 336 LEUnicode piece = (*splitMatra)[i]; 337 IndicClassTable::CharClass pieceClass = classTable->getCharClass(piece); 338 339 saveMatra(piece, matraIndex, pieceClass); 340 } 341 } else { 342 saveMatra(matra, matraIndex, matraClass); 343 } 344 345 return TRUE; 346 } 347 348 return FALSE; 349 } 350 351 void noteVowelModifier(const IndicClassTable *classTable, LEUnicode vowelModifier, le_uint32 vowelModifierIndex, FeatureMask vowelModifierFeatures) 352 { 353 IndicClassTable::CharClass vmClass = classTable->getCharClass(vowelModifier); 354 355 fVMIndex = vowelModifierIndex; 356 fVMFeatures = vowelModifierFeatures; 357 358 if (IndicClassTable::isVowelModifier(vmClass)) { 359 switch (vmClass & CF_POS_MASK) { 360 case CF_POS_ABOVE: 361 fVMabove = vowelModifier; 362 break; 363 364 case CF_POS_AFTER: 365 fVMpost = vowelModifier; 366 break; 367 368 default: 369 // FIXME: this is an error... 370 break; 371 } 372 } 373 } 374 375 void noteStressMark(const IndicClassTable *classTable, LEUnicode stressMark, le_uint32 stressMarkIndex, FeatureMask stressMarkFeatures) 376 { 377 IndicClassTable::CharClass smClass = classTable->getCharClass(stressMark); 378 379 fSMIndex = stressMarkIndex; 380 fSMFeatures = stressMarkFeatures; 381 382 if (IndicClassTable::isStressMark(smClass)) { 383 switch (smClass & CF_POS_MASK) { 384 case CF_POS_ABOVE: 385 fSMabove = stressMark; 386 break; 387 388 case CF_POS_BELOW: 389 fSMbelow = stressMark; 390 break; 391 392 default: 393 // FIXME: this is an error... 394 break; 395 } 396 } 397 } 398 399 void notePreBaseConsonant(le_uint32 index,LEUnicode PBConsonant, LEUnicode PBVirama, FeatureMask features) 400 { 401 fPBCIndex = index; 402 fPreBaseConsonant = PBConsonant; 403 fPreBaseVirama = PBVirama; 404 fPBCFeatures = features; 405 } 406 407 void noteBaseConsonant() 408 { 409 if (fMPreFixups != NULL && fMPreOutIndex >= 0) { 410 fMPreFixups->add(fOutIndex, fMPreOutIndex); 411 } 412 } 413 414 // Handles Al-Lakuna in Sinhala split vowels. 415 void writeAlLakuna() 416 { 417 if (fAlLakuna != 0) { 418 writeChar(fAlLakuna, fAlLakunaIndex, fMatraFeatures); 419 } 420 } 421 422 void writeMpre() 423 { 424 if (fMpre != 0) { 425 fMPreOutIndex = fOutIndex; 426 writeChar(fMpre, fMpreIndex, fMatraFeatures); 427 } 428 } 429 430 void writeMbelow() 431 { 432 if (fMbelow != 0) { 433 writeChar(fMbelow, fMbelowIndex, fMatraFeatures); 434 } 435 } 436 437 void writeMabove() 438 { 439 if (fMabove != 0) { 440 writeChar(fMabove, fMaboveIndex, fMatraFeatures); 441 } 442 } 443 444 void writeMpost() 445 { 446 if (fMpost != 0) { 447 writeChar(fMpost, fMpostIndex, fMatraFeatures); 448 } 449 } 450 451 void writeLengthMark() 452 { 453 if (fLengthMark != 0) { 454 writeChar(fLengthMark, fLengthMarkIndex, fMatraFeatures); 455 } 456 } 457 458 void writeVMabove() 459 { 460 if (fVMabove != 0) { 461 writeChar(fVMabove, fVMIndex, fVMFeatures); 462 } 463 } 464 465 void writeVMpost() 466 { 467 if (fVMpost != 0) { 468 writeChar(fVMpost, fVMIndex, fVMFeatures); 469 } 470 } 471 472 void writeSMabove() 473 { 474 if (fSMabove != 0) { 475 writeChar(fSMabove, fSMIndex, fSMFeatures); 476 } 477 } 478 479 void writeSMbelow() 480 { 481 if (fSMbelow != 0) { 482 writeChar(fSMbelow, fSMIndex, fSMFeatures); 483 } 484 } 485 486 void writePreBaseConsonant() 487 { 488 // The TDIL spec says that consonant + virama + RRA should produce a rakar in Malayalam. However, 489 // it seems that almost none of the fonts for Malayalam are set up to handle this. 490 // So, we're going to force the issue here by using the rakar as defined with RA in most fonts. 491 492 if (fPreBaseConsonant == 0x0d31) { // RRA 493 fPreBaseConsonant = 0x0d30; // RA 494 } 495 496 if (fPreBaseConsonant != 0) { 497 writeChar(fPreBaseConsonant, fPBCIndex, fPBCFeatures); 498 writeChar(fPreBaseVirama,fPBCIndex-1,fPBCFeatures); 499 } 500 } 501 502 le_int32 getOutputIndex() 503 { 504 return fOutIndex; 505 } 506}; 507 508 509 510// TODO: Find better names for these! 511#define tagArray4 (loclFeatureMask | nuktFeatureMask | akhnFeatureMask | vatuFeatureMask | presFeatureMask | blwsFeatureMask | abvsFeatureMask | pstsFeatureMask | halnFeatureMask | blwmFeatureMask | abvmFeatureMask | distFeatureMask) 512#define tagArray3 (pstfFeatureMask | tagArray4) 513#define tagArray2 (halfFeatureMask | tagArray3) 514#define tagArray1 (blwfFeatureMask | tagArray2) 515#define tagArray0 (rphfFeatureMask | tagArray1) 516 517static const FeatureMap featureMap[] = { 518 {loclFeatureTag, loclFeatureMask}, 519 {initFeatureTag, initFeatureMask}, 520 {nuktFeatureTag, nuktFeatureMask}, 521 {akhnFeatureTag, akhnFeatureMask}, 522 {rphfFeatureTag, rphfFeatureMask}, 523 {blwfFeatureTag, blwfFeatureMask}, 524 {halfFeatureTag, halfFeatureMask}, 525 {pstfFeatureTag, pstfFeatureMask}, 526 {vatuFeatureTag, vatuFeatureMask}, 527 {presFeatureTag, presFeatureMask}, 528 {blwsFeatureTag, blwsFeatureMask}, 529 {abvsFeatureTag, abvsFeatureMask}, 530 {pstsFeatureTag, pstsFeatureMask}, 531 {halnFeatureTag, halnFeatureMask}, 532 {blwmFeatureTag, blwmFeatureMask}, 533 {abvmFeatureTag, abvmFeatureMask}, 534 {distFeatureTag, distFeatureMask} 535}; 536 537static const le_int32 featureCount = LE_ARRAY_SIZE(featureMap); 538 539static const FeatureMap v2FeatureMap[] = { 540 {loclFeatureTag, loclFeatureMask}, 541 {nuktFeatureTag, nuktFeatureMask}, 542 {akhnFeatureTag, akhnFeatureMask}, 543 {rphfFeatureTag, rphfFeatureMask}, 544 {rkrfFeatureTag, rkrfFeatureMask}, 545 {blwfFeatureTag, blwfFeatureMask}, 546 {halfFeatureTag, halfFeatureMask}, 547 {vatuFeatureTag, vatuFeatureMask}, 548 {cjctFeatureTag, cjctFeatureMask}, 549 {presFeatureTag, presFeatureMask}, 550 {abvsFeatureTag, abvsFeatureMask}, 551 {blwsFeatureTag, blwsFeatureMask}, 552 {pstsFeatureTag, pstsFeatureMask}, 553 {halnFeatureTag, halnFeatureMask}, 554 {caltFeatureTag, caltFeatureMask}, 555 {kernFeatureTag, kernFeatureMask}, 556 {distFeatureTag, distFeatureMask}, 557 {abvmFeatureTag, abvmFeatureMask}, 558 {blwmFeatureTag, blwmFeatureMask} 559}; 560 561static const le_int32 v2FeatureMapCount = LE_ARRAY_SIZE(v2FeatureMap); 562 563static const le_int8 stateTable[][CC_COUNT] = 564{ 565// xx vm sm iv i2 i3 ct cn nu dv s1 s2 s3 vr zw al 566 { 1, 6, 1, 5, 8, 11, 3, 2, 1, 5, 9, 5, 5, 1, 1, 1}, // 0 - ground state 567 {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 1 - exit state 568 {-1, 6, 1, -1, -1, -1, -1, -1, -1, 5, 9, 5, 5, 4, 12, -1}, // 2 - consonant with nukta 569 {-1, 6, 1, -1, -1, -1, -1, -1, 2, 5, 9, 5, 5, 4, 12, 13}, // 3 - consonant 570 {-1, -1, -1, -1, -1, -1, 3, 2, -1, -1, -1, -1, -1, -1, 7, -1}, // 4 - consonant virama 571 {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 5 - dependent vowels 572 {-1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 6 - vowel mark 573 {-1, -1, -1, -1, -1, -1, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1}, // 7 - consonant virama ZWJ, consonant ZWJ virama 574 {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, -1, -1}, // 8 - independent vowels that can take a virama 575 {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 5, -1, -1, -1}, // 9 - first part of split vowel 576 {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1}, // 10 - second part of split vowel 577 {-1, 6, 1, -1, -1, -1, -1, -1, -1, 5, 9, 5, 5, 4, -1, -1}, // 11 - independent vowels that can take an iv 578 {-1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7, -1, 7}, // 12 - consonant ZWJ (TODO: Take everything else that can be after a consonant?) 579 {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7, -1} // 13 - consonant al-lakuna ZWJ consonant 580}; 581 582 583const FeatureMap *IndicReordering::getFeatureMap(le_int32 &count) 584{ 585 count = featureCount; 586 587 return featureMap; 588} 589 590const FeatureMap *IndicReordering::getv2FeatureMap(le_int32 &count) 591{ 592 count = v2FeatureMapCount; 593 594 return v2FeatureMap; 595} 596 597le_int32 IndicReordering::findSyllable(const IndicClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount) 598{ 599 le_int32 cursor = prev; 600 le_int8 state = 0; 601 le_int8 consonant_count = 0; 602 603 while (cursor < charCount) { 604 IndicClassTable::CharClass charClass = classTable->getCharClass(chars[cursor]); 605 606 if ( IndicClassTable::isConsonant(charClass) ) { 607 consonant_count++; 608 if ( consonant_count > MAX_CONSONANTS_PER_SYLLABLE ) { 609 break; 610 } 611 } 612 613 state = stateTable[state][charClass & CF_CLASS_MASK]; 614 615 if (state < 0) { 616 break; 617 } 618 619 cursor += 1; 620 } 621 622 return cursor; 623} 624 625le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 scriptCode, 626 LEUnicode *outChars, LEGlyphStorage &glyphStorage, 627 MPreFixups **outMPreFixups, LEErrorCode& success) 628{ 629 if (LE_FAILURE(success)) { 630 return 0; 631 } 632 633 MPreFixups *mpreFixups = NULL; 634 const IndicClassTable *classTable = IndicClassTable::getScriptClassTable(scriptCode); 635 636 if(classTable==NULL) { 637 success = LE_MEMORY_ALLOCATION_ERROR; 638 return 0; 639 } 640 641 if (classTable->scriptFlags & SF_MPRE_FIXUP) { 642 mpreFixups = new MPreFixups(charCount); 643 if (mpreFixups == NULL) { 644 success = LE_MEMORY_ALLOCATION_ERROR; 645 return 0; 646 } 647 } 648 649 IndicReorderingOutput output(outChars, glyphStorage, mpreFixups); 650 le_int32 i, prev = 0; 651 le_bool lastInWord = FALSE; 652 653 while (prev < charCount) { 654 le_int32 syllable = findSyllable(classTable, chars, prev, charCount); 655 le_int32 matra, markStart = syllable; 656 657 output.reset(); 658 659 if (classTable->isStressMark(chars[markStart - 1])) { 660 markStart -= 1; 661 output.noteStressMark(classTable, chars[markStart], markStart, tagArray1); 662 } 663 664 if (markStart != prev && classTable->isVowelModifier(chars[markStart - 1])) { 665 markStart -= 1; 666 output.noteVowelModifier(classTable, chars[markStart], markStart, tagArray1); 667 } 668 669 matra = markStart - 1; 670 671 while (output.noteMatra(classTable, chars[matra], matra, tagArray1, !lastInWord) && matra != prev) { 672 matra -= 1; 673 } 674 675 lastInWord = TRUE; 676 677 switch (classTable->getCharClass(chars[prev]) & CF_CLASS_MASK) { 678 case CC_RESERVED: 679 lastInWord = FALSE; 680 /* fall through */ 681 682 case CC_INDEPENDENT_VOWEL: 683 case CC_ZERO_WIDTH_MARK: 684 for (i = prev; i < syllable; i += 1) { 685 output.writeChar(chars[i], i, tagArray1); 686 } 687 688 break; 689 690 case CC_AL_LAKUNA: 691 case CC_NUKTA: 692 output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); 693 output.writeChar(chars[prev], prev, tagArray1); 694 break; 695 696 case CC_VIRAMA: 697 // A lone virama is illegal unless it follows a 698 // MALAYALAM_VOWEL_SIGN_U. Such a usage is called 699 // "samvruthokaram". 700 if (chars[prev - 1] != C_MALAYALAM_VOWEL_SIGN_U) { 701 output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); 702 } 703 704 output.writeChar(chars[prev], prev, tagArray1); 705 break; 706 707 case CC_DEPENDENT_VOWEL: 708 case CC_SPLIT_VOWEL_PIECE_1: 709 case CC_SPLIT_VOWEL_PIECE_2: 710 case CC_SPLIT_VOWEL_PIECE_3: 711 case CC_VOWEL_MODIFIER: 712 case CC_STRESS_MARK: 713 output.writeMpre(); 714 715 output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); 716 717 output.writeMbelow(); 718 output.writeSMbelow(); 719 output.writeMabove(); 720 721 if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) != 0) { 722 output.writeMpost(); 723 } 724 725 if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) != 0) { 726 output.writeVMabove(); 727 output.writeSMabove(); // FIXME: there are no SM's in these scripts... 728 } 729 730 if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) { 731 output.writeMpost(); 732 } 733 734 output.writeLengthMark(); 735 output.writeAlLakuna(); 736 737 if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) { 738 output.writeVMabove(); 739 output.writeSMabove(); 740 } 741 742 output.writeVMpost(); 743 break; 744 745 case CC_INDEPENDENT_VOWEL_2: 746 case CC_INDEPENDENT_VOWEL_3: 747 case CC_CONSONANT: 748 case CC_CONSONANT_WITH_NUKTA: 749 { 750 le_uint32 length = markStart - prev; 751 le_int32 lastConsonant = markStart - 1; 752 le_int32 baseLimit = prev; 753 754 // Check for REPH at front of syllable 755 if (length > 2 && classTable->isReph(chars[prev]) && classTable->isVirama(chars[prev + 1]) && chars[prev + 2] != C_SIGN_ZWNJ) { 756 baseLimit += 2; 757 758 // Check for eyelash RA, if the script supports it 759 if ((classTable->scriptFlags & SF_EYELASH_RA) != 0 && 760 chars[baseLimit] == C_SIGN_ZWJ) { 761 if (length > 3) { 762 baseLimit += 1; 763 } else { 764 baseLimit -= 2; 765 } 766 } 767 } 768 769 while (lastConsonant > baseLimit && !classTable->isConsonant(chars[lastConsonant])) { 770 lastConsonant -= 1; 771 } 772 773 774 IndicClassTable::CharClass charClass = CC_RESERVED; 775 IndicClassTable::CharClass nextClass = CC_RESERVED; 776 le_int32 baseConsonant = lastConsonant; 777 le_int32 postBase = lastConsonant + 1; 778 le_int32 postBaseLimit = classTable->scriptFlags & SF_POST_BASE_LIMIT_MASK; 779 le_bool seenVattu = FALSE; 780 le_bool seenBelowBaseForm = FALSE; 781 le_bool seenPreBaseForm = FALSE; 782 le_bool hasNukta = FALSE; 783 le_bool hasBelowBaseForm = FALSE; 784 le_bool hasPostBaseForm = FALSE; 785 le_bool hasPreBaseForm = FALSE; 786 787 if (postBase < markStart && classTable->isNukta(chars[postBase])) { 788 charClass = CC_NUKTA; 789 postBase += 1; 790 } 791 792 while (baseConsonant > baseLimit) { 793 nextClass = charClass; 794 hasNukta = IndicClassTable::isNukta(nextClass); 795 charClass = classTable->getCharClass(chars[baseConsonant]); 796 797 hasBelowBaseForm = IndicClassTable::hasBelowBaseForm(charClass) && !hasNukta; 798 hasPostBaseForm = IndicClassTable::hasPostBaseForm(charClass) && !hasNukta; 799 hasPreBaseForm = IndicClassTable::hasPreBaseForm(charClass) && !hasNukta; 800 801 if (IndicClassTable::isConsonant(charClass)) { 802 if (postBaseLimit == 0 || seenVattu || 803 (baseConsonant > baseLimit && !classTable->isVirama(chars[baseConsonant - 1])) || 804 !(hasBelowBaseForm || hasPostBaseForm || hasPreBaseForm)) { 805 break; 806 } 807 808 // Note any pre-base consonants 809 if ( baseConsonant == lastConsonant && lastConsonant > 0 && 810 hasPreBaseForm && classTable->isVirama(chars[baseConsonant - 1])) { 811 output.notePreBaseConsonant(lastConsonant,chars[lastConsonant],chars[lastConsonant-1],tagArray2); 812 seenPreBaseForm = TRUE; 813 814 } 815 // consonants with nuktas are never vattus 816 seenVattu = IndicClassTable::isVattu(charClass) && !hasNukta; 817 818 // consonants with nuktas never have below- or post-base forms 819 if (hasPostBaseForm) { 820 if (seenBelowBaseForm) { 821 break; 822 } 823 824 postBase = baseConsonant; 825 } else if (hasBelowBaseForm) { 826 seenBelowBaseForm = TRUE; 827 } 828 829 postBaseLimit -= 1; 830 } 831 832 baseConsonant -= 1; 833 } 834 835 // Write Mpre 836 output.writeMpre(); 837 838 // Write eyelash RA 839 // NOTE: baseLimit == prev + 3 iff eyelash RA present... 840 if (baseLimit == prev + 3) { 841 output.writeChar(chars[prev], prev, tagArray2); 842 output.writeChar(chars[prev + 1], prev + 1, tagArray2); 843 output.writeChar(chars[prev + 2], prev + 2, tagArray2); 844 } 845 846 // write any pre-base consonants 847 output.writePreBaseConsonant(); 848 849 le_bool supressVattu = TRUE; 850 851 for (i = baseLimit; i < baseConsonant; i += 1) { 852 LEUnicode ch = chars[i]; 853 // Don't put 'pstf' or 'blwf' on anything before the base consonant. 854 FeatureMask features = tagArray1 & ~( pstfFeatureMask | blwfFeatureMask ); 855 856 charClass = classTable->getCharClass(ch); 857 nextClass = classTable->getCharClass(chars[i + 1]); 858 hasNukta = IndicClassTable::isNukta(nextClass); 859 860 if (IndicClassTable::isConsonant(charClass)) { 861 if (IndicClassTable::isVattu(charClass) && !hasNukta && supressVattu) { 862 features = tagArray4; 863 } 864 865 supressVattu = IndicClassTable::isVattu(charClass) && !hasNukta; 866 } else if (IndicClassTable::isVirama(charClass) && chars[i + 1] == C_SIGN_ZWNJ) 867 { 868 features = tagArray4; 869 } 870 871 output.writeChar(ch, i, features); 872 } 873 874 le_int32 bcSpan = baseConsonant + 1; 875 876 if (bcSpan < markStart && classTable->isNukta(chars[bcSpan])) { 877 bcSpan += 1; 878 } 879 880 if (baseConsonant == lastConsonant && bcSpan < markStart && 881 (classTable->isVirama(chars[bcSpan]) || classTable->isAlLakuna(chars[bcSpan]))) { 882 bcSpan += 1; 883 884 if (bcSpan < markStart && chars[bcSpan] == C_SIGN_ZWNJ) { 885 bcSpan += 1; 886 } 887 } 888 889 // note the base consonant for post-GSUB fixups 890 output.noteBaseConsonant(); 891 892 // write base consonant 893 for (i = baseConsonant; i < bcSpan; i += 1) { 894 output.writeChar(chars[i], i, tagArray4); 895 } 896 897 if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) != 0) { 898 output.writeMbelow(); 899 output.writeSMbelow(); // FIXME: there are no SMs in these scripts... 900 output.writeMabove(); 901 output.writeMpost(); 902 } 903 904 // write below-base consonants 905 if (baseConsonant != lastConsonant && !seenPreBaseForm) { 906 for (i = bcSpan + 1; i < postBase; i += 1) { 907 output.writeChar(chars[i], i, tagArray1); 908 } 909 910 if (postBase > lastConsonant) { 911 // write halant that was after base consonant 912 output.writeChar(chars[bcSpan], bcSpan, tagArray1); 913 } 914 } 915 916 // write Mbelow, SMbelow, Mabove 917 if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) { 918 output.writeMbelow(); 919 output.writeSMbelow(); 920 output.writeMabove(); 921 } 922 923 if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) != 0) { 924 if (baseLimit == prev + 2) { 925 output.writeChar(chars[prev], prev, tagArray0); 926 output.writeChar(chars[prev + 1], prev + 1, tagArray0); 927 } 928 929 output.writeVMabove(); 930 output.writeSMabove(); // FIXME: there are no SM's in these scripts... 931 } 932 933 // write post-base consonants 934 // FIXME: does this put the right tags on post-base consonants? 935 if (baseConsonant != lastConsonant && !seenPreBaseForm) { 936 if (postBase <= lastConsonant) { 937 for (i = postBase; i <= lastConsonant; i += 1) { 938 output.writeChar(chars[i], i, tagArray3); 939 } 940 941 // write halant that was after base consonant 942 output.writeChar(chars[bcSpan], bcSpan, tagArray1); 943 } 944 945 // write the training halant, if there is one 946 if (lastConsonant < matra && classTable->isVirama(chars[matra])) { 947 output.writeChar(chars[matra], matra, tagArray4); 948 } 949 } 950 951 // write Mpost 952 if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) { 953 output.writeMpost(); 954 } 955 956 output.writeLengthMark(); 957 output.writeAlLakuna(); 958 959 // write reph 960 if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) { 961 if (baseLimit == prev + 2) { 962 output.writeChar(chars[prev], prev, tagArray0); 963 output.writeChar(chars[prev + 1], prev + 1, tagArray0); 964 } 965 966 output.writeVMabove(); 967 output.writeSMabove(); 968 } 969 970 output.writeVMpost(); 971 972 break; 973 } 974 975 default: 976 break; 977 } 978 979 prev = syllable; 980 } 981 982 *outMPreFixups = mpreFixups; 983 984 return output.getOutputIndex(); 985} 986 987void IndicReordering::adjustMPres(MPreFixups *mpreFixups, LEGlyphStorage &glyphStorage, LEErrorCode& success) 988{ 989 if (mpreFixups != NULL) { 990 mpreFixups->apply(glyphStorage, success); 991 992 delete mpreFixups; 993 } 994} 995 996void IndicReordering::applyPresentationForms(LEGlyphStorage &glyphStorage, le_int32 count) 997{ 998 LEErrorCode success = LE_NO_ERROR; 999 1000// This sets us up for 2nd pass of glyph substitution as well as setting the feature masks for the 1001// GPOS table lookups 1002 1003 for ( le_int32 i = 0 ; i < count ; i++ ) { 1004 glyphStorage.setAuxData(i, ( presentationFormsMask | positioningFormsMask ), success); 1005 } 1006 1007} 1008void IndicReordering::finalReordering(LEGlyphStorage &glyphStorage, le_int32 count) 1009{ 1010 LEErrorCode success = LE_NO_ERROR; 1011 1012 // Reposition REPH as appropriate 1013 1014 for ( le_int32 i = 0 ; i < count ; i++ ) { 1015 1016 le_int32 tmpAuxData = glyphStorage.getAuxData(i,success); 1017 LEGlyphID tmpGlyph = glyphStorage.getGlyphID(i,success); 1018 1019 if ( ( tmpGlyph != NO_GLYPH ) && (tmpAuxData & rephConsonantMask) && !(tmpAuxData & repositionedGlyphMask)) { 1020 1021 le_bool targetPositionFound = false; 1022 le_int32 targetPosition = i+1; 1023 le_int32 baseConsonantData; 1024 1025 while (!targetPositionFound) { 1026 tmpGlyph = glyphStorage.getGlyphID(targetPosition,success); 1027 tmpAuxData = glyphStorage.getAuxData(targetPosition,success); 1028 1029 if ( tmpAuxData & baseConsonantMask ) { 1030 baseConsonantData = tmpAuxData; 1031 targetPositionFound = true; 1032 } else { 1033 targetPosition++; 1034 } 1035 } 1036 1037 // Make sure we are not putting the reph into an empty hole 1038 1039 le_bool targetPositionHasGlyph = false; 1040 while (!targetPositionHasGlyph) { 1041 tmpGlyph = glyphStorage.getGlyphID(targetPosition,success); 1042 if ( tmpGlyph != NO_GLYPH ) { 1043 targetPositionHasGlyph = true; 1044 } else { 1045 targetPosition--; 1046 } 1047 } 1048 1049 // Make sure that REPH is positioned after any above base or post base matras 1050 // 1051 le_bool checkMatraDone = false; 1052 le_int32 checkMatraPosition = targetPosition+1; 1053 while ( !checkMatraDone ) { 1054 tmpAuxData = glyphStorage.getAuxData(checkMatraPosition,success); 1055 if ( checkMatraPosition >= count || ( (tmpAuxData ^ baseConsonantData) & LE_GLYPH_GROUP_MASK)) { 1056 checkMatraDone = true; 1057 continue; 1058 } 1059 if ( (tmpAuxData & matraMask) && 1060 (((tmpAuxData & markPositionMask) == aboveBasePosition) || 1061 ((tmpAuxData & markPositionMask) == postBasePosition))) { 1062 targetPosition = checkMatraPosition; 1063 } 1064 checkMatraPosition++; 1065 } 1066 1067 glyphStorage.moveGlyph(i,targetPosition,repositionedGlyphMask); 1068 } 1069 } 1070} 1071 1072 1073le_int32 IndicReordering::v2process(const LEUnicode *chars, le_int32 charCount, le_int32 scriptCode, 1074 LEUnicode *outChars, LEGlyphStorage &glyphStorage) 1075{ 1076 const IndicClassTable *classTable = IndicClassTable::getScriptClassTable(scriptCode); 1077 1078 DynamicProperties dynProps[INDIC_BLOCK_SIZE]; 1079 IndicReordering::getDynamicProperties(dynProps,classTable); 1080 1081 IndicReorderingOutput output(outChars, glyphStorage, NULL); 1082 le_int32 i, firstConsonant, baseConsonant, secondConsonant, inv_count = 0, beginSyllable = 0; 1083 //le_bool lastInWord = FALSE; 1084 1085 while (beginSyllable < charCount) { 1086 le_int32 nextSyllable = findSyllable(classTable, chars, beginSyllable, charCount); 1087 1088 output.reset(); 1089 1090 // Find the First Consonant 1091 for ( firstConsonant = beginSyllable ; firstConsonant < nextSyllable ; firstConsonant++ ) { 1092 if ( classTable->isConsonant(chars[firstConsonant]) ) { 1093 break; 1094 } 1095 } 1096 1097 // Find the base consonant 1098 1099 baseConsonant = nextSyllable - 1; 1100 secondConsonant = firstConsonant; 1101 1102 // TODO: Use Dynamic Properties for hasBelowBaseForm and hasPostBaseForm() 1103 1104 while ( baseConsonant > firstConsonant ) { 1105 if ( classTable->isConsonant(chars[baseConsonant]) && 1106 !classTable->hasBelowBaseForm(chars[baseConsonant]) && 1107 !classTable->hasPostBaseForm(chars[baseConsonant]) ) { 1108 break; 1109 } 1110 else { 1111 if ( classTable->isConsonant(chars[baseConsonant]) ) { 1112 secondConsonant = baseConsonant; 1113 } 1114 baseConsonant--; 1115 } 1116 } 1117 1118 // If the syllable starts with Ra + Halant ( in a script that has Reph ) and has more than one 1119 // consonant, Ra is excluced from candidates for base consonants 1120 1121 if ( classTable->isReph(chars[beginSyllable]) && 1122 beginSyllable+1 < nextSyllable && classTable->isVirama(chars[beginSyllable+1]) && 1123 secondConsonant != firstConsonant) { 1124 baseConsonant = secondConsonant; 1125 } 1126 1127 // Populate the output 1128 for ( i = beginSyllable ; i < nextSyllable ; i++ ) { 1129 1130 // Handle invalid combinartions 1131 1132 if ( classTable->isVirama(chars[beginSyllable]) || 1133 classTable->isMatra(chars[beginSyllable]) || 1134 classTable->isVowelModifier(chars[beginSyllable]) || 1135 classTable->isNukta(chars[beginSyllable]) ) { 1136 output.writeChar(C_DOTTED_CIRCLE,beginSyllable,basicShapingFormsMask); 1137 inv_count++; 1138 } 1139 output.writeChar(chars[i],i, basicShapingFormsMask); 1140 1141 } 1142 1143 // Adjust features and set syllable structure bits 1144 1145 for ( i = beginSyllable ; i < nextSyllable ; i++ ) { 1146 1147 FeatureMask outMask = output.getFeatures(i+inv_count); 1148 FeatureMask saveMask = outMask; 1149 1150 // Since reph can only validly occur at the beginning of a syllable 1151 // We only apply it to the first 2 characters in the syllable, to keep it from 1152 // conflicting with other features ( i.e. rkrf ) 1153 1154 // TODO : Use the dynamic property for determining isREPH 1155 if ( i == beginSyllable && i < baseConsonant && classTable->isReph(chars[i]) && 1156 i+1 < nextSyllable && classTable->isVirama(chars[i+1])) { 1157 outMask |= rphfFeatureMask; 1158 outMask |= rephConsonantMask; 1159 output.setFeatures(i+1+inv_count,outMask); 1160 1161 } 1162 1163 if ( i == baseConsonant ) { 1164 outMask |= baseConsonantMask; 1165 } 1166 1167 if ( classTable->isMatra(chars[i])) { 1168 outMask |= matraMask; 1169 if ( classTable->hasAboveBaseForm(chars[i])) { 1170 outMask |= aboveBasePosition; 1171 } else if ( classTable->hasBelowBaseForm(chars[i])) { 1172 outMask |= belowBasePosition; 1173 } 1174 } 1175 1176 // Don't apply half form to virama that stands alone at the end of a syllable 1177 // to prevent half forms from forming when syllable ends with virama 1178 1179 if ( classTable->isVirama(chars[i]) && (i+1 == nextSyllable) ) { 1180 outMask ^= halfFeatureMask; 1181 if ( classTable->isConsonant(chars[i-1]) ) { 1182 FeatureMask tmp = output.getFeatures(i-1+inv_count); 1183 tmp ^= halfFeatureMask; 1184 output.setFeatures(i-1+inv_count,tmp); 1185 } 1186 } 1187 1188 if ( outMask != saveMask ) { 1189 output.setFeatures(i+inv_count,outMask); 1190 } 1191 } 1192 1193 output.decomposeReorderMatras(classTable,beginSyllable,nextSyllable,inv_count); 1194 1195 beginSyllable = nextSyllable; 1196 } 1197 1198 1199 return output.getOutputIndex(); 1200} 1201 1202 1203void IndicReordering::getDynamicProperties( DynamicProperties *, const IndicClassTable *classTable ) { 1204 1205 1206 LEUnicode currentChar; 1207 LEUnicode workChars[2]; 1208 LEGlyphStorage workGlyphs; 1209 1210 IndicReorderingOutput workOutput(workChars, workGlyphs, NULL); 1211 1212 //le_int32 offset = 0; 1213 1214#if 0 1215// TODO: Should this section of code have actually been doing something? 1216 // First find the relevant virama for the script we are dealing with 1217 LEUnicode virama; 1218 for ( currentChar = classTable->firstChar ; currentChar <= classTable->lastChar ; currentChar++ ) { 1219 if ( classTable->isVirama(currentChar)) { 1220 virama = currentChar; 1221 break; 1222 } 1223 } 1224#endif 1225 1226 for ( currentChar = classTable->firstChar ; currentChar <= classTable->lastChar ; currentChar++ ) { 1227 if ( classTable->isConsonant(currentChar)) { 1228 workOutput.reset(); 1229 } 1230 } 1231 1232 1233} 1234 1235U_NAMESPACE_END 1236