| /* |
| / * |
| * (C) Copyright IBM Corp. 1998-2009 - All Rights Reserved |
| * |
| */ |
| |
| #include "LETypes.h" |
| #include "OpenTypeTables.h" |
| #include "OpenTypeUtilities.h" |
| #include "IndicReordering.h" |
| #include "LEGlyphStorage.h" |
| #include "MPreFixups.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| #define loclFeatureTag LE_LOCL_FEATURE_TAG |
| #define initFeatureTag LE_INIT_FEATURE_TAG |
| #define nuktFeatureTag LE_NUKT_FEATURE_TAG |
| #define akhnFeatureTag LE_AKHN_FEATURE_TAG |
| #define rphfFeatureTag LE_RPHF_FEATURE_TAG |
| #define rkrfFeatureTag LE_RKRF_FEATURE_TAG |
| #define blwfFeatureTag LE_BLWF_FEATURE_TAG |
| #define halfFeatureTag LE_HALF_FEATURE_TAG |
| #define pstfFeatureTag LE_PSTF_FEATURE_TAG |
| #define vatuFeatureTag LE_VATU_FEATURE_TAG |
| #define presFeatureTag LE_PRES_FEATURE_TAG |
| #define blwsFeatureTag LE_BLWS_FEATURE_TAG |
| #define abvsFeatureTag LE_ABVS_FEATURE_TAG |
| #define pstsFeatureTag LE_PSTS_FEATURE_TAG |
| #define halnFeatureTag LE_HALN_FEATURE_TAG |
| #define cjctFeatureTag LE_CJCT_FEATURE_TAG |
| #define blwmFeatureTag LE_BLWM_FEATURE_TAG |
| #define abvmFeatureTag LE_ABVM_FEATURE_TAG |
| #define distFeatureTag LE_DIST_FEATURE_TAG |
| #define caltFeatureTag LE_CALT_FEATURE_TAG |
| #define kernFeatureTag LE_KERN_FEATURE_TAG |
| |
| #define loclFeatureMask 0x80000000UL |
| #define rphfFeatureMask 0x40000000UL |
| #define blwfFeatureMask 0x20000000UL |
| #define halfFeatureMask 0x10000000UL |
| #define pstfFeatureMask 0x08000000UL |
| #define nuktFeatureMask 0x04000000UL |
| #define akhnFeatureMask 0x02000000UL |
| #define vatuFeatureMask 0x01000000UL |
| #define presFeatureMask 0x00800000UL |
| #define blwsFeatureMask 0x00400000UL |
| #define abvsFeatureMask 0x00200000UL |
| #define pstsFeatureMask 0x00100000UL |
| #define halnFeatureMask 0x00080000UL |
| #define blwmFeatureMask 0x00040000UL |
| #define abvmFeatureMask 0x00020000UL |
| #define distFeatureMask 0x00010000UL |
| #define initFeatureMask 0x00008000UL |
| #define cjctFeatureMask 0x00004000UL |
| #define rkrfFeatureMask 0x00002000UL |
| #define caltFeatureMask 0x00001000UL |
| #define kernFeatureMask 0x00000800UL |
| |
| // Syllable structure bits |
| #define baseConsonantMask 0x00000400UL |
| #define consonantMask 0x00000200UL |
| #define halfConsonantMask 0x00000100UL |
| #define rephConsonantMask 0x00000080UL |
| #define matraMask 0x00000040UL |
| #define vowelModifierMask 0x00000020UL |
| #define markPositionMask 0x00000018UL |
| |
| #define postBasePosition 0x00000000UL |
| #define preBasePosition 0x00000008UL |
| #define aboveBasePosition 0x00000010UL |
| #define belowBasePosition 0x00000018UL |
| |
| #define repositionedGlyphMask 0x00000002UL |
| |
| #define basicShapingFormsMask ( loclFeatureMask | nuktFeatureMask | akhnFeatureMask | rkrfFeatureMask | blwfFeatureMask | halfFeatureMask | vatuFeatureMask | cjctFeatureMask ) |
| #define positioningFormsMask ( kernFeatureMask | distFeatureMask | abvmFeatureMask | blwmFeatureMask ) |
| #define presentationFormsMask ( presFeatureMask | abvsFeatureMask | blwsFeatureMask | pstsFeatureMask | halnFeatureMask | caltFeatureMask ) |
| |
| |
| #define C_MALAYALAM_VOWEL_SIGN_U 0x0D41 |
| #define C_DOTTED_CIRCLE 0x25CC |
| #define NO_GLYPH 0xFFFF |
| |
| // Some level of debate as to the proper value for MAX_CONSONANTS_PER_SYLLABLE. Ticket 5588 states that 4 |
| // is the magic number according to ISCII, but 5 seems to be the more consistent with XP. |
| #define MAX_CONSONANTS_PER_SYLLABLE 5 |
| |
| #define INDIC_BLOCK_SIZE 0x7F |
| |
| class IndicReorderingOutput : public UMemory { |
| private: |
| le_int32 fSyllableCount; |
| le_int32 fOutIndex; |
| LEUnicode *fOutChars; |
| |
| LEGlyphStorage &fGlyphStorage; |
| |
| LEUnicode fMpre; |
| le_int32 fMpreIndex; |
| |
| LEUnicode fMbelow; |
| le_int32 fMbelowIndex; |
| |
| LEUnicode fMabove; |
| le_int32 fMaboveIndex; |
| |
| LEUnicode fMpost; |
| le_int32 fMpostIndex; |
| |
| LEUnicode fLengthMark; |
| le_int32 fLengthMarkIndex; |
| |
| LEUnicode fAlLakuna; |
| le_int32 fAlLakunaIndex; |
| |
| FeatureMask fMatraFeatures; |
| |
| le_int32 fMPreOutIndex; |
| MPreFixups *fMPreFixups; |
| |
| LEUnicode fVMabove; |
| LEUnicode fVMpost; |
| le_int32 fVMIndex; |
| FeatureMask fVMFeatures; |
| |
| LEUnicode fSMabove; |
| LEUnicode fSMbelow; |
| le_int32 fSMIndex; |
| FeatureMask fSMFeatures; |
| |
| LEUnicode fPreBaseConsonant; |
| LEUnicode fPreBaseVirama; |
| le_int32 fPBCIndex; |
| FeatureMask fPBCFeatures; |
| |
| void saveMatra(LEUnicode matra, le_int32 matraIndex, IndicClassTable::CharClass matraClass) |
| { |
| // FIXME: check if already set, or if not a matra... |
| if (IndicClassTable::isLengthMark(matraClass)) { |
| fLengthMark = matra; |
| fLengthMarkIndex = matraIndex; |
| } else if (IndicClassTable::isAlLakuna(matraClass)) { |
| fAlLakuna = matra; |
| fAlLakunaIndex = matraIndex; |
| } else { |
| switch (matraClass & CF_POS_MASK) { |
| case CF_POS_BEFORE: |
| fMpre = matra; |
| fMpreIndex = matraIndex; |
| break; |
| |
| case CF_POS_BELOW: |
| fMbelow = matra; |
| fMbelowIndex = matraIndex; |
| break; |
| |
| case CF_POS_ABOVE: |
| fMabove = matra; |
| fMaboveIndex = matraIndex; |
| break; |
| |
| case CF_POS_AFTER: |
| fMpost = matra; |
| fMpostIndex = matraIndex; |
| break; |
| |
| default: |
| // can't get here... |
| break; |
| } |
| } |
| } |
| |
| public: |
| IndicReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage, MPreFixups *mpreFixups) |
| : fSyllableCount(0), fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage), |
| fMpre(0), fMpreIndex(0), fMbelow(0), fMbelowIndex(0), fMabove(0), fMaboveIndex(0), |
| fMpost(0), fMpostIndex(0), fLengthMark(0), fLengthMarkIndex(0), fAlLakuna(0), fAlLakunaIndex(0), |
| fMatraFeatures(0), fMPreOutIndex(-1), fMPreFixups(mpreFixups), |
| fVMabove(0), fVMpost(0), fVMIndex(0), fVMFeatures(0), |
| fSMabove(0), fSMbelow(0), fSMIndex(0), fSMFeatures(0), |
| fPreBaseConsonant(0), fPreBaseVirama(0), fPBCIndex(0), fPBCFeatures(0) |
| { |
| // nothing else to do... |
| } |
| |
| ~IndicReorderingOutput() |
| { |
| // nothing to do here... |
| } |
| |
| void reset() |
| { |
| fSyllableCount += 1; |
| |
| fMpre = fMbelow = fMabove = fMpost = fLengthMark = fAlLakuna = 0; |
| fMPreOutIndex = -1; |
| |
| fVMabove = fVMpost = 0; |
| fSMabove = fSMbelow = 0; |
| |
| fPreBaseConsonant = fPreBaseVirama = 0; |
| } |
| |
| void writeChar(LEUnicode ch, le_uint32 charIndex, FeatureMask charFeatures) |
| { |
| LEErrorCode success = LE_NO_ERROR; |
| |
| fOutChars[fOutIndex] = ch; |
| |
| fGlyphStorage.setCharIndex(fOutIndex, charIndex, success); |
| fGlyphStorage.setAuxData(fOutIndex, charFeatures | (fSyllableCount & LE_GLYPH_GROUP_MASK), success); |
| |
| fOutIndex += 1; |
| } |
| |
| void setFeatures ( le_uint32 charIndex, FeatureMask charFeatures) |
| { |
| LEErrorCode success = LE_NO_ERROR; |
| |
| fGlyphStorage.setAuxData( charIndex, charFeatures, success ); |
| |
| } |
| |
| FeatureMask getFeatures ( le_uint32 charIndex ) |
| { |
| LEErrorCode success = LE_NO_ERROR; |
| return fGlyphStorage.getAuxData(charIndex,success); |
| } |
| |
| void decomposeReorderMatras ( const IndicClassTable *classTable, le_int32 beginSyllable, le_int32 nextSyllable, le_int32 inv_count ) { |
| le_int32 i; |
| LEErrorCode success = LE_NO_ERROR; |
| |
| for ( i = beginSyllable ; i < nextSyllable ; i++ ) { |
| if ( classTable->isMatra(fOutChars[i+inv_count])) { |
| IndicClassTable::CharClass matraClass = classTable->getCharClass(fOutChars[i+inv_count]); |
| if ( classTable->isSplitMatra(matraClass)) { |
| le_int32 saveIndex = fGlyphStorage.getCharIndex(i+inv_count,success); |
| le_uint32 saveAuxData = fGlyphStorage.getAuxData(i+inv_count,success); |
| const SplitMatra *splitMatra = classTable->getSplitMatra(matraClass); |
| int j; |
| for (j = 0 ; *(splitMatra)[j] != 0 ; j++) { |
| LEUnicode piece = (*splitMatra)[j]; |
| if ( j == 0 ) { |
| fOutChars[i+inv_count] = piece; |
| matraClass = classTable->getCharClass(piece); |
| } else { |
| insertCharacter(piece,i+1+inv_count,saveIndex,saveAuxData); |
| nextSyllable++; |
| } |
| } |
| } |
| |
| if ((matraClass & CF_POS_MASK) == CF_POS_BEFORE) { |
| moveCharacter(i+inv_count,beginSyllable+inv_count); |
| } |
| } |
| } |
| } |
| |
| void moveCharacter( le_int32 fromPosition, le_int32 toPosition ) { |
| le_int32 i,saveIndex; |
| le_uint32 saveAuxData; |
| LEUnicode saveChar = fOutChars[fromPosition]; |
| LEErrorCode success = LE_NO_ERROR; |
| LEErrorCode success2 = LE_NO_ERROR; |
| saveIndex = fGlyphStorage.getCharIndex(fromPosition,success); |
| saveAuxData = fGlyphStorage.getAuxData(fromPosition,success); |
| |
| if ( fromPosition > toPosition ) { |
| for ( i = fromPosition ; i > toPosition ; i-- ) { |
| fOutChars[i] = fOutChars[i-1]; |
| fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i-1,success2),success); |
| fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i-1,success2), success); |
| |
| } |
| } else { |
| for ( i = fromPosition ; i < toPosition ; i++ ) { |
| fOutChars[i] = fOutChars[i+1]; |
| fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i+1,success2),success); |
| fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i+1,success2), success); |
| } |
| |
| } |
| fOutChars[toPosition] = saveChar; |
| fGlyphStorage.setCharIndex(toPosition,saveIndex,success); |
| fGlyphStorage.setAuxData(toPosition,saveAuxData,success); |
| |
| } |
| void insertCharacter( LEUnicode ch, le_int32 toPosition, le_int32 charIndex, le_uint32 auxData ) { |
| LEErrorCode success = LE_NO_ERROR; |
| le_int32 i; |
| fOutIndex += 1; |
| |
| for ( i = fOutIndex ; i > toPosition ; i--) { |
| fOutChars[i] = fOutChars[i-1]; |
| fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i-1,success),success); |
| fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i-1,success), success); |
| } |
| |
| fOutChars[toPosition] = ch; |
| fGlyphStorage.setCharIndex(toPosition,charIndex,success); |
| fGlyphStorage.setAuxData(toPosition,auxData,success); |
| |
| } |
| void removeCharacter( le_int32 fromPosition ) { |
| LEErrorCode success = LE_NO_ERROR; |
| le_int32 i; |
| fOutIndex -= 1; |
| |
| for ( i = fromPosition ; i < fOutIndex ; i--) { |
| fOutChars[i] = fOutChars[i+1]; |
| fGlyphStorage.setCharIndex(i,fGlyphStorage.getCharIndex(i+1,success),success); |
| fGlyphStorage.setAuxData(i,fGlyphStorage.getAuxData(i+1,success), success); |
| } |
| } |
| |
| le_bool noteMatra(const IndicClassTable *classTable, LEUnicode matra, le_uint32 matraIndex, FeatureMask matraFeatures, le_bool wordStart) |
| { |
| IndicClassTable::CharClass matraClass = classTable->getCharClass(matra); |
| |
| fMatraFeatures = matraFeatures; |
| |
| if (wordStart) { |
| fMatraFeatures |= initFeatureMask; |
| } |
| |
| if (IndicClassTable::isMatra(matraClass)) { |
| if (IndicClassTable::isSplitMatra(matraClass)) { |
| const SplitMatra *splitMatra = classTable->getSplitMatra(matraClass); |
| int i; |
| |
| for (i = 0; i < 3 && (*splitMatra)[i] != 0; i += 1) { |
| LEUnicode piece = (*splitMatra)[i]; |
| IndicClassTable::CharClass pieceClass = classTable->getCharClass(piece); |
| |
| saveMatra(piece, matraIndex, pieceClass); |
| } |
| } else { |
| saveMatra(matra, matraIndex, matraClass); |
| } |
| |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| void noteVowelModifier(const IndicClassTable *classTable, LEUnicode vowelModifier, le_uint32 vowelModifierIndex, FeatureMask vowelModifierFeatures) |
| { |
| IndicClassTable::CharClass vmClass = classTable->getCharClass(vowelModifier); |
| |
| fVMIndex = vowelModifierIndex; |
| fVMFeatures = vowelModifierFeatures; |
| |
| if (IndicClassTable::isVowelModifier(vmClass)) { |
| switch (vmClass & CF_POS_MASK) { |
| case CF_POS_ABOVE: |
| fVMabove = vowelModifier; |
| break; |
| |
| case CF_POS_AFTER: |
| fVMpost = vowelModifier; |
| break; |
| |
| default: |
| // FIXME: this is an error... |
| break; |
| } |
| } |
| } |
| |
| void noteStressMark(const IndicClassTable *classTable, LEUnicode stressMark, le_uint32 stressMarkIndex, FeatureMask stressMarkFeatures) |
| { |
| IndicClassTable::CharClass smClass = classTable->getCharClass(stressMark); |
| |
| fSMIndex = stressMarkIndex; |
| fSMFeatures = stressMarkFeatures; |
| |
| if (IndicClassTable::isStressMark(smClass)) { |
| switch (smClass & CF_POS_MASK) { |
| case CF_POS_ABOVE: |
| fSMabove = stressMark; |
| break; |
| |
| case CF_POS_BELOW: |
| fSMbelow = stressMark; |
| break; |
| |
| default: |
| // FIXME: this is an error... |
| break; |
| } |
| } |
| } |
| |
| void notePreBaseConsonant(le_uint32 index,LEUnicode PBConsonant, LEUnicode PBVirama, FeatureMask features) |
| { |
| fPBCIndex = index; |
| fPreBaseConsonant = PBConsonant; |
| fPreBaseVirama = PBVirama; |
| fPBCFeatures = features; |
| } |
| |
| void noteBaseConsonant() |
| { |
| if (fMPreFixups != NULL && fMPreOutIndex >= 0) { |
| fMPreFixups->add(fOutIndex, fMPreOutIndex); |
| } |
| } |
| |
| // Handles Al-Lakuna in Sinhala split vowels. |
| void writeAlLakuna() |
| { |
| if (fAlLakuna != 0) { |
| writeChar(fAlLakuna, fAlLakunaIndex, fMatraFeatures); |
| } |
| } |
| |
| void writeMpre() |
| { |
| if (fMpre != 0) { |
| fMPreOutIndex = fOutIndex; |
| writeChar(fMpre, fMpreIndex, fMatraFeatures); |
| } |
| } |
| |
| void writeMbelow() |
| { |
| if (fMbelow != 0) { |
| writeChar(fMbelow, fMbelowIndex, fMatraFeatures); |
| } |
| } |
| |
| void writeMabove() |
| { |
| if (fMabove != 0) { |
| writeChar(fMabove, fMaboveIndex, fMatraFeatures); |
| } |
| } |
| |
| void writeMpost() |
| { |
| if (fMpost != 0) { |
| writeChar(fMpost, fMpostIndex, fMatraFeatures); |
| } |
| } |
| |
| void writeLengthMark() |
| { |
| if (fLengthMark != 0) { |
| writeChar(fLengthMark, fLengthMarkIndex, fMatraFeatures); |
| } |
| } |
| |
| void writeVMabove() |
| { |
| if (fVMabove != 0) { |
| writeChar(fVMabove, fVMIndex, fVMFeatures); |
| } |
| } |
| |
| void writeVMpost() |
| { |
| if (fVMpost != 0) { |
| writeChar(fVMpost, fVMIndex, fVMFeatures); |
| } |
| } |
| |
| void writeSMabove() |
| { |
| if (fSMabove != 0) { |
| writeChar(fSMabove, fSMIndex, fSMFeatures); |
| } |
| } |
| |
| void writeSMbelow() |
| { |
| if (fSMbelow != 0) { |
| writeChar(fSMbelow, fSMIndex, fSMFeatures); |
| } |
| } |
| |
| void writePreBaseConsonant() |
| { |
| // The TDIL spec says that consonant + virama + RRA should produce a rakar in Malayalam. However, |
| // it seems that almost none of the fonts for Malayalam are set up to handle this. |
| // So, we're going to force the issue here by using the rakar as defined with RA in most fonts. |
| |
| if (fPreBaseConsonant == 0x0d31) { // RRA |
| fPreBaseConsonant = 0x0d30; // RA |
| } |
| |
| if (fPreBaseConsonant != 0) { |
| writeChar(fPreBaseConsonant, fPBCIndex, fPBCFeatures); |
| writeChar(fPreBaseVirama,fPBCIndex-1,fPBCFeatures); |
| } |
| } |
| |
| le_int32 getOutputIndex() |
| { |
| return fOutIndex; |
| } |
| }; |
| |
| |
| |
| // TODO: Find better names for these! |
| #define tagArray4 (loclFeatureMask | nuktFeatureMask | akhnFeatureMask | vatuFeatureMask | presFeatureMask | blwsFeatureMask | abvsFeatureMask | pstsFeatureMask | halnFeatureMask | blwmFeatureMask | abvmFeatureMask | distFeatureMask) |
| #define tagArray3 (pstfFeatureMask | tagArray4) |
| #define tagArray2 (halfFeatureMask | tagArray3) |
| #define tagArray1 (blwfFeatureMask | tagArray2) |
| #define tagArray0 (rphfFeatureMask | tagArray1) |
| |
| static const FeatureMap featureMap[] = { |
| {loclFeatureTag, loclFeatureMask}, |
| {initFeatureTag, initFeatureMask}, |
| {nuktFeatureTag, nuktFeatureMask}, |
| {akhnFeatureTag, akhnFeatureMask}, |
| {rphfFeatureTag, rphfFeatureMask}, |
| {blwfFeatureTag, blwfFeatureMask}, |
| {halfFeatureTag, halfFeatureMask}, |
| {pstfFeatureTag, pstfFeatureMask}, |
| {vatuFeatureTag, vatuFeatureMask}, |
| {presFeatureTag, presFeatureMask}, |
| {blwsFeatureTag, blwsFeatureMask}, |
| {abvsFeatureTag, abvsFeatureMask}, |
| {pstsFeatureTag, pstsFeatureMask}, |
| {halnFeatureTag, halnFeatureMask}, |
| {blwmFeatureTag, blwmFeatureMask}, |
| {abvmFeatureTag, abvmFeatureMask}, |
| {distFeatureTag, distFeatureMask} |
| }; |
| |
| static const le_int32 featureCount = LE_ARRAY_SIZE(featureMap); |
| |
| static const FeatureMap v2FeatureMap[] = { |
| {loclFeatureTag, loclFeatureMask}, |
| {nuktFeatureTag, nuktFeatureMask}, |
| {akhnFeatureTag, akhnFeatureMask}, |
| {rphfFeatureTag, rphfFeatureMask}, |
| {rkrfFeatureTag, rkrfFeatureMask}, |
| {blwfFeatureTag, blwfFeatureMask}, |
| {halfFeatureTag, halfFeatureMask}, |
| {vatuFeatureTag, vatuFeatureMask}, |
| {cjctFeatureTag, cjctFeatureMask}, |
| {presFeatureTag, presFeatureMask}, |
| {abvsFeatureTag, abvsFeatureMask}, |
| {blwsFeatureTag, blwsFeatureMask}, |
| {pstsFeatureTag, pstsFeatureMask}, |
| {halnFeatureTag, halnFeatureMask}, |
| {caltFeatureTag, caltFeatureMask}, |
| {kernFeatureTag, kernFeatureMask}, |
| {distFeatureTag, distFeatureMask}, |
| {abvmFeatureTag, abvmFeatureMask}, |
| {blwmFeatureTag, blwmFeatureMask} |
| }; |
| |
| static const le_int32 v2FeatureMapCount = LE_ARRAY_SIZE(v2FeatureMap); |
| |
| static const le_int8 stateTable[][CC_COUNT] = |
| { |
| // xx vm sm iv i2 i3 ct cn nu dv s1 s2 s3 vr zw al |
| { 1, 6, 1, 5, 8, 11, 3, 2, 1, 5, 9, 5, 5, 1, 1, 1}, // 0 - ground state |
| {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 1 - exit state |
| {-1, 6, 1, -1, -1, -1, -1, -1, -1, 5, 9, 5, 5, 4, 12, -1}, // 2 - consonant with nukta |
| {-1, 6, 1, -1, -1, -1, -1, -1, 2, 5, 9, 5, 5, 4, 12, 13}, // 3 - consonant |
| {-1, -1, -1, -1, -1, -1, 3, 2, -1, -1, -1, -1, -1, -1, 7, -1}, // 4 - consonant virama |
| {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 5 - dependent vowels |
| {-1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 6 - vowel mark |
| {-1, -1, -1, -1, -1, -1, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1}, // 7 - consonant virama ZWJ, consonant ZWJ virama |
| {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, -1, -1}, // 8 - independent vowels that can take a virama |
| {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 5, -1, -1, -1}, // 9 - first part of split vowel |
| {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1}, // 10 - second part of split vowel |
| {-1, 6, 1, -1, -1, -1, -1, -1, -1, 5, 9, 5, 5, 4, -1, -1}, // 11 - independent vowels that can take an iv |
| {-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?) |
| {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 7, -1} // 13 - consonant al-lakuna ZWJ consonant |
| }; |
| |
| |
| const FeatureMap *IndicReordering::getFeatureMap(le_int32 &count) |
| { |
| count = featureCount; |
| |
| return featureMap; |
| } |
| |
| const FeatureMap *IndicReordering::getv2FeatureMap(le_int32 &count) |
| { |
| count = v2FeatureMapCount; |
| |
| return v2FeatureMap; |
| } |
| |
| le_int32 IndicReordering::findSyllable(const IndicClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount) |
| { |
| le_int32 cursor = prev; |
| le_int8 state = 0; |
| le_int8 consonant_count = 0; |
| |
| while (cursor < charCount) { |
| IndicClassTable::CharClass charClass = classTable->getCharClass(chars[cursor]); |
| |
| if ( IndicClassTable::isConsonant(charClass) ) { |
| consonant_count++; |
| if ( consonant_count > MAX_CONSONANTS_PER_SYLLABLE ) { |
| break; |
| } |
| } |
| |
| state = stateTable[state][charClass & CF_CLASS_MASK]; |
| |
| if (state < 0) { |
| break; |
| } |
| |
| cursor += 1; |
| } |
| |
| return cursor; |
| } |
| |
| le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 scriptCode, |
| LEUnicode *outChars, LEGlyphStorage &glyphStorage, |
| MPreFixups **outMPreFixups, LEErrorCode& success) |
| { |
| if (LE_FAILURE(success)) { |
| return 0; |
| } |
| |
| MPreFixups *mpreFixups = NULL; |
| const IndicClassTable *classTable = IndicClassTable::getScriptClassTable(scriptCode); |
| |
| if (classTable->scriptFlags & SF_MPRE_FIXUP) { |
| mpreFixups = new MPreFixups(charCount); |
| if (mpreFixups == NULL) { |
| success = LE_MEMORY_ALLOCATION_ERROR; |
| return 0; |
| } |
| } |
| |
| IndicReorderingOutput output(outChars, glyphStorage, mpreFixups); |
| le_int32 i, prev = 0; |
| le_bool lastInWord = FALSE; |
| |
| while (prev < charCount) { |
| le_int32 syllable = findSyllable(classTable, chars, prev, charCount); |
| le_int32 matra, markStart = syllable; |
| |
| output.reset(); |
| |
| if (classTable->isStressMark(chars[markStart - 1])) { |
| markStart -= 1; |
| output.noteStressMark(classTable, chars[markStart], markStart, tagArray1); |
| } |
| |
| if (markStart != prev && classTable->isVowelModifier(chars[markStart - 1])) { |
| markStart -= 1; |
| output.noteVowelModifier(classTable, chars[markStart], markStart, tagArray1); |
| } |
| |
| matra = markStart - 1; |
| |
| while (output.noteMatra(classTable, chars[matra], matra, tagArray1, !lastInWord) && matra != prev) { |
| matra -= 1; |
| } |
| |
| lastInWord = TRUE; |
| |
| switch (classTable->getCharClass(chars[prev]) & CF_CLASS_MASK) { |
| case CC_RESERVED: |
| lastInWord = FALSE; |
| /* fall through */ |
| |
| case CC_INDEPENDENT_VOWEL: |
| case CC_ZERO_WIDTH_MARK: |
| for (i = prev; i < syllable; i += 1) { |
| output.writeChar(chars[i], i, tagArray1); |
| } |
| |
| break; |
| |
| case CC_AL_LAKUNA: |
| case CC_NUKTA: |
| output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); |
| output.writeChar(chars[prev], prev, tagArray1); |
| break; |
| |
| case CC_VIRAMA: |
| // A lone virama is illegal unless it follows a |
| // MALAYALAM_VOWEL_SIGN_U. Such a usage is called |
| // "samvruthokaram". |
| if (chars[prev - 1] != C_MALAYALAM_VOWEL_SIGN_U) { |
| output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); |
| } |
| |
| output.writeChar(chars[prev], prev, tagArray1); |
| break; |
| |
| case CC_DEPENDENT_VOWEL: |
| case CC_SPLIT_VOWEL_PIECE_1: |
| case CC_SPLIT_VOWEL_PIECE_2: |
| case CC_SPLIT_VOWEL_PIECE_3: |
| case CC_VOWEL_MODIFIER: |
| case CC_STRESS_MARK: |
| output.writeMpre(); |
| |
| output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); |
| |
| output.writeMbelow(); |
| output.writeSMbelow(); |
| output.writeMabove(); |
| |
| if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) != 0) { |
| output.writeMpost(); |
| } |
| |
| if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) != 0) { |
| output.writeVMabove(); |
| output.writeSMabove(); // FIXME: there are no SM's in these scripts... |
| } |
| |
| if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) { |
| output.writeMpost(); |
| } |
| |
| output.writeLengthMark(); |
| output.writeAlLakuna(); |
| |
| if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) { |
| output.writeVMabove(); |
| output.writeSMabove(); |
| } |
| |
| output.writeVMpost(); |
| break; |
| |
| case CC_INDEPENDENT_VOWEL_2: |
| case CC_INDEPENDENT_VOWEL_3: |
| case CC_CONSONANT: |
| case CC_CONSONANT_WITH_NUKTA: |
| { |
| le_uint32 length = markStart - prev; |
| le_int32 lastConsonant = markStart - 1; |
| le_int32 baseLimit = prev; |
| |
| // Check for REPH at front of syllable |
| if (length > 2 && classTable->isReph(chars[prev]) && classTable->isVirama(chars[prev + 1]) && chars[prev + 2] != C_SIGN_ZWNJ) { |
| baseLimit += 2; |
| |
| // Check for eyelash RA, if the script supports it |
| if ((classTable->scriptFlags & SF_EYELASH_RA) != 0 && |
| chars[baseLimit] == C_SIGN_ZWJ) { |
| if (length > 3) { |
| baseLimit += 1; |
| } else { |
| baseLimit -= 2; |
| } |
| } |
| } |
| |
| while (lastConsonant > baseLimit && !classTable->isConsonant(chars[lastConsonant])) { |
| lastConsonant -= 1; |
| } |
| |
| |
| IndicClassTable::CharClass charClass = CC_RESERVED; |
| IndicClassTable::CharClass nextClass = CC_RESERVED; |
| le_int32 baseConsonant = lastConsonant; |
| le_int32 postBase = lastConsonant + 1; |
| le_int32 postBaseLimit = classTable->scriptFlags & SF_POST_BASE_LIMIT_MASK; |
| le_bool seenVattu = FALSE; |
| le_bool seenBelowBaseForm = FALSE; |
| le_bool seenPreBaseForm = FALSE; |
| le_bool hasNukta = FALSE; |
| le_bool hasBelowBaseForm = FALSE; |
| le_bool hasPostBaseForm = FALSE; |
| le_bool hasPreBaseForm = FALSE; |
| |
| if (postBase < markStart && classTable->isNukta(chars[postBase])) { |
| charClass = CC_NUKTA; |
| postBase += 1; |
| } |
| |
| while (baseConsonant > baseLimit) { |
| nextClass = charClass; |
| hasNukta = IndicClassTable::isNukta(nextClass); |
| charClass = classTable->getCharClass(chars[baseConsonant]); |
| |
| hasBelowBaseForm = IndicClassTable::hasBelowBaseForm(charClass) && !hasNukta; |
| hasPostBaseForm = IndicClassTable::hasPostBaseForm(charClass) && !hasNukta; |
| hasPreBaseForm = IndicClassTable::hasPreBaseForm(charClass) && !hasNukta; |
| |
| if (IndicClassTable::isConsonant(charClass)) { |
| if (postBaseLimit == 0 || seenVattu || |
| (baseConsonant > baseLimit && !classTable->isVirama(chars[baseConsonant - 1])) || |
| !(hasBelowBaseForm || hasPostBaseForm || hasPreBaseForm)) { |
| break; |
| } |
| |
| // Note any pre-base consonants |
| if ( baseConsonant == lastConsonant && lastConsonant > 0 && |
| hasPreBaseForm && classTable->isVirama(chars[baseConsonant - 1])) { |
| output.notePreBaseConsonant(lastConsonant,chars[lastConsonant],chars[lastConsonant-1],tagArray2); |
| seenPreBaseForm = TRUE; |
| |
| } |
| // consonants with nuktas are never vattus |
| seenVattu = IndicClassTable::isVattu(charClass) && !hasNukta; |
| |
| // consonants with nuktas never have below- or post-base forms |
| if (hasPostBaseForm) { |
| if (seenBelowBaseForm) { |
| break; |
| } |
| |
| postBase = baseConsonant; |
| } else if (hasBelowBaseForm) { |
| seenBelowBaseForm = TRUE; |
| } |
| |
| postBaseLimit -= 1; |
| } |
| |
| baseConsonant -= 1; |
| } |
| |
| // Write Mpre |
| output.writeMpre(); |
| |
| // Write eyelash RA |
| // NOTE: baseLimit == prev + 3 iff eyelash RA present... |
| if (baseLimit == prev + 3) { |
| output.writeChar(chars[prev], prev, tagArray2); |
| output.writeChar(chars[prev + 1], prev + 1, tagArray2); |
| output.writeChar(chars[prev + 2], prev + 2, tagArray2); |
| } |
| |
| // write any pre-base consonants |
| output.writePreBaseConsonant(); |
| |
| le_bool supressVattu = TRUE; |
| |
| for (i = baseLimit; i < baseConsonant; i += 1) { |
| LEUnicode ch = chars[i]; |
| // Don't put 'pstf' or 'blwf' on anything before the base consonant. |
| FeatureMask features = tagArray1 & ~( pstfFeatureMask | blwfFeatureMask ); |
| |
| charClass = classTable->getCharClass(ch); |
| nextClass = classTable->getCharClass(chars[i + 1]); |
| hasNukta = IndicClassTable::isNukta(nextClass); |
| |
| if (IndicClassTable::isConsonant(charClass)) { |
| if (IndicClassTable::isVattu(charClass) && !hasNukta && supressVattu) { |
| features = tagArray4; |
| } |
| |
| supressVattu = IndicClassTable::isVattu(charClass) && !hasNukta; |
| } else if (IndicClassTable::isVirama(charClass) && chars[i + 1] == C_SIGN_ZWNJ) |
| { |
| features = tagArray4; |
| } |
| |
| output.writeChar(ch, i, features); |
| } |
| |
| le_int32 bcSpan = baseConsonant + 1; |
| |
| if (bcSpan < markStart && classTable->isNukta(chars[bcSpan])) { |
| bcSpan += 1; |
| } |
| |
| if (baseConsonant == lastConsonant && bcSpan < markStart && |
| (classTable->isVirama(chars[bcSpan]) || classTable->isAlLakuna(chars[bcSpan]))) { |
| bcSpan += 1; |
| |
| if (bcSpan < markStart && chars[bcSpan] == C_SIGN_ZWNJ) { |
| bcSpan += 1; |
| } |
| } |
| |
| // note the base consonant for post-GSUB fixups |
| output.noteBaseConsonant(); |
| |
| // write base consonant |
| for (i = baseConsonant; i < bcSpan; i += 1) { |
| output.writeChar(chars[i], i, tagArray4); |
| } |
| |
| if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) != 0) { |
| output.writeMbelow(); |
| output.writeSMbelow(); // FIXME: there are no SMs in these scripts... |
| output.writeMabove(); |
| output.writeMpost(); |
| } |
| |
| // write below-base consonants |
| if (baseConsonant != lastConsonant && !seenPreBaseForm) { |
| for (i = bcSpan + 1; i < postBase; i += 1) { |
| output.writeChar(chars[i], i, tagArray1); |
| } |
| |
| if (postBase > lastConsonant) { |
| // write halant that was after base consonant |
| output.writeChar(chars[bcSpan], bcSpan, tagArray1); |
| } |
| } |
| |
| // write Mbelow, SMbelow, Mabove |
| if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) { |
| output.writeMbelow(); |
| output.writeSMbelow(); |
| output.writeMabove(); |
| } |
| |
| if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) != 0) { |
| if (baseLimit == prev + 2) { |
| output.writeChar(chars[prev], prev, tagArray0); |
| output.writeChar(chars[prev + 1], prev + 1, tagArray0); |
| } |
| |
| output.writeVMabove(); |
| output.writeSMabove(); // FIXME: there are no SM's in these scripts... |
| } |
| |
| // write post-base consonants |
| // FIXME: does this put the right tags on post-base consonants? |
| if (baseConsonant != lastConsonant && !seenPreBaseForm) { |
| if (postBase <= lastConsonant) { |
| for (i = postBase; i <= lastConsonant; i += 1) { |
| output.writeChar(chars[i], i, tagArray3); |
| } |
| |
| // write halant that was after base consonant |
| output.writeChar(chars[bcSpan], bcSpan, tagArray1); |
| } |
| |
| // write the training halant, if there is one |
| if (lastConsonant < matra && classTable->isVirama(chars[matra])) { |
| output.writeChar(chars[matra], matra, tagArray4); |
| } |
| } |
| |
| // write Mpost |
| if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) { |
| output.writeMpost(); |
| } |
| |
| output.writeLengthMark(); |
| output.writeAlLakuna(); |
| |
| // write reph |
| if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) { |
| if (baseLimit == prev + 2) { |
| output.writeChar(chars[prev], prev, tagArray0); |
| output.writeChar(chars[prev + 1], prev + 1, tagArray0); |
| } |
| |
| output.writeVMabove(); |
| output.writeSMabove(); |
| } |
| |
| output.writeVMpost(); |
| |
| break; |
| } |
| |
| default: |
| break; |
| } |
| |
| prev = syllable; |
| } |
| |
| *outMPreFixups = mpreFixups; |
| |
| return output.getOutputIndex(); |
| } |
| |
| void IndicReordering::adjustMPres(MPreFixups *mpreFixups, LEGlyphStorage &glyphStorage, LEErrorCode& success) |
| { |
| if (mpreFixups != NULL) { |
| mpreFixups->apply(glyphStorage, success); |
| |
| delete mpreFixups; |
| } |
| } |
| |
| void IndicReordering::applyPresentationForms(LEGlyphStorage &glyphStorage, le_int32 count) |
| { |
| LEErrorCode success = LE_NO_ERROR; |
| |
| // This sets us up for 2nd pass of glyph substitution as well as setting the feature masks for the |
| // GPOS table lookups |
| |
| for ( le_int32 i = 0 ; i < count ; i++ ) { |
| glyphStorage.setAuxData(i, ( presentationFormsMask | positioningFormsMask ), success); |
| } |
| |
| } |
| void IndicReordering::finalReordering(LEGlyphStorage &glyphStorage, le_int32 count) |
| { |
| LEErrorCode success = LE_NO_ERROR; |
| |
| // Reposition REPH as appropriate |
| |
| for ( le_int32 i = 0 ; i < count ; i++ ) { |
| |
| le_int32 tmpAuxData = glyphStorage.getAuxData(i,success); |
| LEGlyphID tmpGlyph = glyphStorage.getGlyphID(i,success); |
| |
| if ( ( tmpGlyph != NO_GLYPH ) && (tmpAuxData & rephConsonantMask) && !(tmpAuxData & repositionedGlyphMask)) { |
| |
| le_bool targetPositionFound = false; |
| le_int32 targetPosition = i+1; |
| le_int32 baseConsonantData; |
| |
| while (!targetPositionFound) { |
| tmpGlyph = glyphStorage.getGlyphID(targetPosition,success); |
| tmpAuxData = glyphStorage.getAuxData(targetPosition,success); |
| |
| if ( tmpAuxData & baseConsonantMask ) { |
| baseConsonantData = tmpAuxData; |
| targetPositionFound = true; |
| } else { |
| targetPosition++; |
| } |
| } |
| |
| // Make sure we are not putting the reph into an empty hole |
| |
| le_bool targetPositionHasGlyph = false; |
| while (!targetPositionHasGlyph) { |
| tmpGlyph = glyphStorage.getGlyphID(targetPosition,success); |
| if ( tmpGlyph != NO_GLYPH ) { |
| targetPositionHasGlyph = true; |
| } else { |
| targetPosition--; |
| } |
| } |
| |
| // Make sure that REPH is positioned after any above base or post base matras |
| // |
| le_bool checkMatraDone = false; |
| le_int32 checkMatraPosition = targetPosition+1; |
| while ( !checkMatraDone ) { |
| tmpAuxData = glyphStorage.getAuxData(checkMatraPosition,success); |
| if ( checkMatraPosition >= count || ( (tmpAuxData ^ baseConsonantData) & LE_GLYPH_GROUP_MASK)) { |
| checkMatraDone = true; |
| continue; |
| } |
| if ( (tmpAuxData & matraMask) && |
| (((tmpAuxData & markPositionMask) == aboveBasePosition) || |
| ((tmpAuxData & markPositionMask) == postBasePosition))) { |
| targetPosition = checkMatraPosition; |
| } |
| checkMatraPosition++; |
| } |
| |
| glyphStorage.moveGlyph(i,targetPosition,repositionedGlyphMask); |
| } |
| } |
| } |
| |
| |
| le_int32 IndicReordering::v2process(const LEUnicode *chars, le_int32 charCount, le_int32 scriptCode, |
| LEUnicode *outChars, LEGlyphStorage &glyphStorage) |
| { |
| const IndicClassTable *classTable = IndicClassTable::getScriptClassTable(scriptCode); |
| |
| DynamicProperties dynProps[INDIC_BLOCK_SIZE]; |
| IndicReordering::getDynamicProperties(dynProps,classTable); |
| |
| IndicReorderingOutput output(outChars, glyphStorage, NULL); |
| le_int32 i, firstConsonant, baseConsonant, secondConsonant, inv_count = 0, beginSyllable = 0; |
| //le_bool lastInWord = FALSE; |
| |
| while (beginSyllable < charCount) { |
| le_int32 nextSyllable = findSyllable(classTable, chars, beginSyllable, charCount); |
| |
| output.reset(); |
| |
| // Find the First Consonant |
| for ( firstConsonant = beginSyllable ; firstConsonant < nextSyllable ; firstConsonant++ ) { |
| if ( classTable->isConsonant(chars[firstConsonant]) ) { |
| break; |
| } |
| } |
| |
| // Find the base consonant |
| |
| baseConsonant = nextSyllable - 1; |
| secondConsonant = firstConsonant; |
| |
| // TODO: Use Dynamic Properties for hasBelowBaseForm and hasPostBaseForm() |
| |
| while ( baseConsonant > firstConsonant ) { |
| if ( classTable->isConsonant(chars[baseConsonant]) && |
| !classTable->hasBelowBaseForm(chars[baseConsonant]) && |
| !classTable->hasPostBaseForm(chars[baseConsonant]) ) { |
| break; |
| } |
| else { |
| if ( classTable->isConsonant(chars[baseConsonant]) ) { |
| secondConsonant = baseConsonant; |
| } |
| baseConsonant--; |
| } |
| } |
| |
| // If the syllable starts with Ra + Halant ( in a script that has Reph ) and has more than one |
| // consonant, Ra is excluced from candidates for base consonants |
| |
| if ( classTable->isReph(chars[beginSyllable]) && |
| beginSyllable+1 < nextSyllable && classTable->isVirama(chars[beginSyllable+1]) && |
| secondConsonant != firstConsonant) { |
| baseConsonant = secondConsonant; |
| } |
| |
| // Populate the output |
| for ( i = beginSyllable ; i < nextSyllable ; i++ ) { |
| |
| // Handle invalid combinartions |
| |
| if ( classTable->isVirama(chars[beginSyllable]) || |
| classTable->isMatra(chars[beginSyllable]) || |
| classTable->isVowelModifier(chars[beginSyllable]) || |
| classTable->isNukta(chars[beginSyllable]) ) { |
| output.writeChar(C_DOTTED_CIRCLE,beginSyllable,basicShapingFormsMask); |
| inv_count++; |
| } |
| output.writeChar(chars[i],i, basicShapingFormsMask); |
| |
| } |
| |
| // Adjust features and set syllable structure bits |
| |
| for ( i = beginSyllable ; i < nextSyllable ; i++ ) { |
| |
| FeatureMask outMask = output.getFeatures(i+inv_count); |
| FeatureMask saveMask = outMask; |
| |
| // Since reph can only validly occur at the beginning of a syllable |
| // We only apply it to the first 2 characters in the syllable, to keep it from |
| // conflicting with other features ( i.e. rkrf ) |
| |
| // TODO : Use the dynamic property for determining isREPH |
| if ( i == beginSyllable && i < baseConsonant && classTable->isReph(chars[i]) && |
| i+1 < nextSyllable && classTable->isVirama(chars[i+1])) { |
| outMask |= rphfFeatureMask; |
| outMask |= rephConsonantMask; |
| output.setFeatures(i+1+inv_count,outMask); |
| |
| } |
| |
| if ( i == baseConsonant ) { |
| outMask |= baseConsonantMask; |
| } |
| |
| if ( classTable->isMatra(chars[i])) { |
| outMask |= matraMask; |
| if ( classTable->hasAboveBaseForm(chars[i])) { |
| outMask |= aboveBasePosition; |
| } else if ( classTable->hasBelowBaseForm(chars[i])) { |
| outMask |= belowBasePosition; |
| } |
| } |
| |
| // Don't apply half form to virama that stands alone at the end of a syllable |
| // to prevent half forms from forming when syllable ends with virama |
| |
| if ( classTable->isVirama(chars[i]) && (i+1 == nextSyllable) ) { |
| outMask ^= halfFeatureMask; |
| if ( classTable->isConsonant(chars[i-1]) ) { |
| FeatureMask tmp = output.getFeatures(i-1+inv_count); |
| tmp ^= halfFeatureMask; |
| output.setFeatures(i-1+inv_count,tmp); |
| } |
| } |
| |
| if ( outMask != saveMask ) { |
| output.setFeatures(i+inv_count,outMask); |
| } |
| } |
| |
| output.decomposeReorderMatras(classTable,beginSyllable,nextSyllable,inv_count); |
| |
| beginSyllable = nextSyllable; |
| } |
| |
| |
| return output.getOutputIndex(); |
| } |
| |
| |
| void IndicReordering::getDynamicProperties( DynamicProperties *, const IndicClassTable *classTable ) { |
| |
| |
| LEUnicode currentChar; |
| LEUnicode virama; |
| LEUnicode workChars[2]; |
| LEGlyphStorage workGlyphs; |
| |
| IndicReorderingOutput workOutput(workChars, workGlyphs, NULL); |
| |
| //le_int32 offset = 0; |
| |
| // First find the relevant virama for the script we are dealing with |
| |
| for ( currentChar = classTable->firstChar ; currentChar <= classTable->lastChar ; currentChar++ ) { |
| if ( classTable->isVirama(currentChar)) { |
| virama = currentChar; |
| break; |
| } |
| } |
| |
| for ( currentChar = classTable->firstChar ; currentChar <= classTable->lastChar ; currentChar++ ) { |
| if ( classTable->isConsonant(currentChar)) { |
| workOutput.reset(); |
| } |
| } |
| |
| |
| } |
| |
| U_NAMESPACE_END |
