X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/b75a7d8f3b4adbae880cab104ce2c6a50eee4db2..ef6cf650f4a75c3f97de06b51fa104f2069b9ea2:/icuSources/layout/IndicReordering.cpp?ds=inline diff --git a/icuSources/layout/IndicReordering.cpp b/icuSources/layout/IndicReordering.cpp index c0a77f36..1ebc94a6 100644 --- a/icuSources/layout/IndicReordering.cpp +++ b/icuSources/layout/IndicReordering.cpp @@ -1,9 +1,6 @@ /* - * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved - * - * $Source: /cvs/root/ICU/icuSources/layout/IndicReordering.cpp,v $ - * $Date: 2003/07/03 18:13:45 $ - * $Revision: 1.1.1.2 $ +/ * + * (C) Copyright IBM Corp. 1998-2015 - All Rights Reserved * */ @@ -11,85 +8,402 @@ #include "OpenTypeTables.h" #include "OpenTypeUtilities.h" #include "IndicReordering.h" +#include "LEGlyphStorage.h" #include "MPreFixups.h" U_NAMESPACE_BEGIN -class ReorderingOutput : public UMemory { +#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 fOutIndex; - + le_int32 fSyllableCount; + le_int32 fOutIndex; LEUnicode *fOutChars; - le_int32 *fCharIndices; - const LETag **fCharTags; - - LEUnicode fMpre; - LEUnicode fMbelow; - LEUnicode fMabove; - LEUnicode fMpost; - LEUnicode fLengthMark; - le_int32 fMatraIndex; - const LETag *fMatraTags; - le_int32 fMPreOutIndex; - MPreFixups *fMPreFixups; + LEGlyphStorage &fGlyphStorage; + + LEUnicode fMpre; + le_int32 fMpreIndex; + + LEUnicode fMbelow; + le_int32 fMbelowIndex; + + LEUnicode fMabove; + le_int32 fMaboveIndex; + + LEUnicode fMpost; + le_int32 fMpostIndex; - void saveMatra(LEUnicode matra, IndicClassTable::CharClass matraClass) + 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::isMpre(matraClass)) { - fMpre = matra; - } else if (IndicClassTable::isMbelow(matraClass)) { - fMbelow = matra; - } else if (IndicClassTable::isMabove(matraClass)) { - fMabove = matra; - } else if (IndicClassTable::isMpost(matraClass)) { - fMpost = matra; - } else if (IndicClassTable::isLengthMark(matraClass)) { + 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: - ReorderingOutput(LEUnicode *outChars, le_int32 *charIndices, const LETag **charTags, MPreFixups *mpreFixups) - : fOutIndex(0), fOutChars(outChars), fCharIndices(charIndices), fCharTags(charTags), - fMpre(0), fMbelow(0), fMabove(0), fMpost(0), fLengthMark(0), - fMatraIndex(0), fMatraTags(NULL), fMPreOutIndex(-1), fMPreFixups(mpreFixups) + 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... } - ~ReorderingOutput() + ~IndicReorderingOutput() { // nothing to do here... } - void noteMatra(const IndicClassTable *classTable, LEUnicode matra, le_uint32 matraIndex, const LETag *matraTags) + void reset() { - IndicClassTable::CharClass matraClass = classTable->getCharClass(matra); + fSyllableCount += 1; - fMpre = fMbelow = fMabove = fMpost = fLengthMark = 0; + fMpre = fMbelow = fMabove = fMpost = fLengthMark = fAlLakuna = 0; fMPreOutIndex = -1; - fMatraIndex = matraIndex; - fMatraTags = matraTags; + + 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 ; j < SM_MAX_PIECES && *(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) { + for (i = 0; i < SM_MAX_PIECES && (*splitMatra)[i] != 0; i += 1) { LEUnicode piece = (*splitMatra)[i]; IndicClassTable::CharClass pieceClass = classTable->getCharClass(piece); - saveMatra(piece, pieceClass); + saveMatra(piece, matraIndex, pieceClass); } } else { - saveMatra(matra, matraClass); + 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) { @@ -97,49 +411,92 @@ public: } } + // 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, fMatraIndex, fMatraTags); + writeChar(fMpre, fMpreIndex, fMatraFeatures); } } void writeMbelow() { if (fMbelow != 0) { - writeChar(fMbelow, fMatraIndex, fMatraTags); + writeChar(fMbelow, fMbelowIndex, fMatraFeatures); } } void writeMabove() { if (fMabove != 0) { - writeChar(fMabove, fMatraIndex, fMatraTags); + writeChar(fMabove, fMaboveIndex, fMatraFeatures); } } void writeMpost() { if (fMpost != 0) { - writeChar(fMpost, fMatraIndex, fMatraTags); + writeChar(fMpost, fMpostIndex, fMatraFeatures); } } void writeLengthMark() { if (fLengthMark != 0) { - writeChar(fLengthMark, fMatraIndex, fMatraTags); + writeChar(fLengthMark, fLengthMarkIndex, fMatraFeatures); } } - - void writeChar(LEUnicode ch, le_uint32 charIndex, const LETag *charTags) + + void writeVMabove() { - fOutChars[fOutIndex] = ch; - fCharIndices[fOutIndex] = charIndex; - fCharTags[fOutIndex] = charTags; + 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. - fOutIndex += 1; + if (fPreBaseConsonant == 0x0d31) { // RRA + fPreBaseConsonant = 0x0d30; // RA + } + + if (fPreBaseConsonant != 0) { + writeChar(fPreBaseConsonant, fPBCIndex, fPBCFeatures); + writeChar(fPreBaseVirama,fPBCIndex-1,fPBCFeatures); + } } le_int32 getOutputIndex() @@ -148,80 +505,112 @@ public: } }; -enum -{ - C_DOTTED_CIRCLE = 0x25CC + + +// 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} }; -const LETag emptyTag = 0x00000000; // '' - -const LETag nuktFeatureTag = LE_NUKT_FEATURE_TAG; -const LETag akhnFeatureTag = LE_AKHN_FEATURE_TAG; -const LETag rphfFeatureTag = LE_RPHF_FEATURE_TAG; -const LETag blwfFeatureTag = LE_BLWF_FEATURE_TAG; -const LETag halfFeatureTag = LE_HALF_FEATURE_TAG; -const LETag pstfFeatureTag = LE_PSTF_FEATURE_TAG; -const LETag vatuFeatureTag = LE_VATU_FEATURE_TAG; -const LETag presFeatureTag = LE_PRES_FEATURE_TAG; -const LETag blwsFeatureTag = LE_BLWS_FEATURE_TAG; -const LETag abvsFeatureTag = LE_ABVS_FEATURE_TAG; -const LETag pstsFeatureTag = LE_PSTS_FEATURE_TAG; -const LETag halnFeatureTag = LE_HALN_FEATURE_TAG; - -const LETag blwmFeatureTag = LE_BLWM_FEATURE_TAG; -const LETag abvmFeatureTag = LE_ABVM_FEATURE_TAG; -const LETag distFeatureTag = LE_DIST_FEATURE_TAG; - -// These are in the order in which the features need to be applied -// for correct processing -const LETag featureOrder[] = -{ - nuktFeatureTag, akhnFeatureTag, rphfFeatureTag, blwfFeatureTag, halfFeatureTag, pstfFeatureTag, - vatuFeatureTag, presFeatureTag, blwsFeatureTag, abvsFeatureTag, pstsFeatureTag, halnFeatureTag, - blwmFeatureTag, abvmFeatureTag, distFeatureTag, emptyTag +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} }; -// The order of these is determined so that the tag array of each glyph can start -// at an offset into this array -// FIXME: do we want a seperate tag array for each kind of character?? -// FIXME: are there cases where this ordering causes glyphs to get tags -// that they shouldn't? -const LETag tagArray[] = +static const le_int32 v2FeatureMapCount = LE_ARRAY_SIZE(v2FeatureMap); + +static const le_int8 stateTable[][CC_COUNT] = { - rphfFeatureTag, blwfFeatureTag, halfFeatureTag, pstfFeatureTag, nuktFeatureTag, akhnFeatureTag, - vatuFeatureTag, presFeatureTag, blwsFeatureTag, abvsFeatureTag, pstsFeatureTag, halnFeatureTag, - blwmFeatureTag, abvmFeatureTag, distFeatureTag, emptyTag +// 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 le_int8 stateTable[][IndicClassTable::CC_COUNT] = + +const FeatureMap *IndicReordering::getFeatureMap(le_int32 &count) { -// xx ma mp iv ct cn nu dv vr zw - { 1, 1, 1, 5, 3, 2, 1, 1, 1, 1}, - {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, - {-1, 6, 1, -1, -1, -1, -1, 5, 4, -1}, - {-1, 6, 1, -1, -1, -1, 2, 5, 4, -1}, - {-1, -1, -1, -1, 3, 2, -1, -1, -1, 8}, - {-1, 6, 1, -1, -1, -1, -1, -1, -1, -1}, - {-1, 7, 1, -1, -1, -1, -1, -1, -1, -1}, - {-1, -1, 1, -1, -1, -1, -1, -1, -1, -1}, - {-1, -1, -1, -1, 3, 2, -1, -1, -1, -1} + count = featureCount; -}; + return featureMap; +} -const LETag *IndicReordering::getFeatureOrder() +const FeatureMap *IndicReordering::getv2FeatureMap(le_int32 &count) { - return featureOrder; + 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 & IndicClassTable::CF_CLASS_MASK]; + state = stateTable[state][charClass & CF_CLASS_MASK]; if (state < 0) { break; @@ -234,75 +623,140 @@ le_int32 IndicReordering::findSyllable(const IndicClassTable *classTable, const } le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 scriptCode, - LEUnicode *outChars, le_int32 *charIndices, const LETag **charTags, - MPreFixups **outMPreFixups) + 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 & IndicClassTable::SF_MPRE_FIXUP) { + if (classTable==NULL) { + success = LE_INTERNAL_ERROR; + return 0; + } + + if (classTable->scriptFlags & SF_MPRE_FIXUP) { mpreFixups = new MPreFixups(charCount); + if (mpreFixups == NULL) { + success = LE_MEMORY_ALLOCATION_ERROR; + return 0; + } } - ReorderingOutput output(outChars, charIndices, charTags, mpreFixups); + 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, vmabove, vmpost = syllable; + le_int32 matra, markStart = syllable; - while (vmpost > prev && classTable->isVMpost(chars[vmpost - 1])) { - vmpost -= 1; + 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; - vmabove = vmpost; - while (vmabove > prev && classTable->isVMabove(chars[vmabove - 1])) { - vmabove -= 1; + while (output.noteMatra(classTable, chars[matra], matra, tagArray1, !lastInWord) && matra != prev) { + matra -= 1; } - matra = vmabove - 1; - output.noteMatra(classTable, chars[matra], matra, &tagArray[1]); + lastInWord = TRUE; - switch (classTable->getCharClass(chars[prev]) & IndicClassTable::CF_CLASS_MASK) { - case IndicClassTable::CC_RESERVED: - case IndicClassTable::CC_INDEPENDENT_VOWEL: - case IndicClassTable::CC_ZERO_WIDTH_MARK: + 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, &tagArray[1]); + output.writeChar(chars[i], i, tagArray1); } break; - case IndicClassTable::CC_MODIFYING_MARK_ABOVE: - case IndicClassTable::CC_MODIFYING_MARK_POST: - case IndicClassTable::CC_NUKTA: - case IndicClassTable::CC_VIRAMA: - output.writeChar(C_DOTTED_CIRCLE, prev, &tagArray[1]); - output.writeChar(chars[prev], prev, &tagArray[1]); + case CC_AL_LAKUNA: + case CC_NUKTA: + output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); + output.writeChar(chars[prev], prev, tagArray1); break; - case IndicClassTable::CC_DEPENDENT_VOWEL: + 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, &tagArray[1]); + + output.writeChar(C_DOTTED_CIRCLE, prev, tagArray1); + output.writeMbelow(); + output.writeSMbelow(); output.writeMabove(); - output.writeMpost(); + + 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 IndicClassTable::CC_CONSONANT: - case IndicClassTable::CC_CONSONANT_WITH_NUKTA: + case CC_INDEPENDENT_VOWEL_2: + case CC_INDEPENDENT_VOWEL_3: + case CC_CONSONANT: + case CC_CONSONANT_WITH_NUKTA: { - le_uint32 length = vmabove - prev; - le_int32 lastConsonant = vmabove - 1; + 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])) { + 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 & IndicClassTable::SF_EYELASH_RA) != 0 && + if ((classTable->scriptFlags & SF_EYELASH_RA) != 0 && chars[baseLimit] == C_SIGN_ZWJ) { if (length > 3) { baseLimit += 1; @@ -316,32 +770,60 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le 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 & IndicClassTable::SF_POST_BASE_LIMIT_MASK; - le_bool seenVattu = false; - le_bool seenBelowBaseForm = false; + 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) { - IndicClassTable::CharClass charClass = classTable->getCharClass(chars[baseConsonant]); + 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])) || - !IndicClassTable::hasPostOrBelowBaseForm(charClass)) { + !(hasBelowBaseForm || hasPostBaseForm || hasPreBaseForm)) { break; } - seenVattu = IndicClassTable::isVattu(charClass); + // 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; - if (IndicClassTable::hasPostBaseForm(charClass)) { + // consonants with nuktas never have below- or post-base forms + if (hasPostBaseForm) { if (seenBelowBaseForm) { break; } postBase = baseConsonant; - } else if (IndicClassTable::hasBelowBaseForm(charClass)) { - seenBelowBaseForm = true; + } else if (hasBelowBaseForm) { + seenBelowBaseForm = TRUE; } postBaseLimit -= 1; @@ -356,43 +838,50 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le // Write eyelash RA // NOTE: baseLimit == prev + 3 iff eyelash RA present... if (baseLimit == prev + 3) { - output.writeChar(chars[prev], prev, &tagArray[2]); - output.writeChar(chars[prev + 1], prev + 1, &tagArray[2]); - output.writeChar(chars[prev + 2], prev + 2, &tagArray[2]); + 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 - le_bool supressVattu = true; + output.writePreBaseConsonant(); + + le_bool supressVattu = TRUE; for (i = baseLimit; i < baseConsonant; i += 1) { LEUnicode ch = chars[i]; - const LETag *tag = &tagArray[1]; - IndicClassTable::CharClass charClass = classTable->getCharClass(ch); + // 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) && supressVattu) { - tag = &tagArray[4]; + if (IndicClassTable::isVattu(charClass) && !hasNukta && supressVattu) { + features = tagArray4; } - supressVattu = IndicClassTable::isVattu(charClass); + supressVattu = IndicClassTable::isVattu(charClass) && !hasNukta; } else if (IndicClassTable::isVirama(charClass) && chars[i + 1] == C_SIGN_ZWNJ) { - tag = &tagArray[4]; + features = tagArray4; } - output.writeChar(ch, i, tag); + output.writeChar(ch, i, features); } le_int32 bcSpan = baseConsonant + 1; - if (bcSpan < vmabove && classTable->isNukta(chars[bcSpan])) { + if (bcSpan < markStart && classTable->isNukta(chars[bcSpan])) { bcSpan += 1; } - if (baseConsonant == lastConsonant && bcSpan < vmabove && classTable->isVirama(chars[bcSpan])) { + if (baseConsonant == lastConsonant && bcSpan < markStart && + (classTable->isVirama(chars[bcSpan]) || classTable->isAlLakuna(chars[bcSpan]))) { bcSpan += 1; - if (bcSpan < vmabove && chars[bcSpan] == C_SIGN_ZWNJ) { + if (bcSpan < markStart && chars[bcSpan] == C_SIGN_ZWNJ) { bcSpan += 1; } } @@ -402,87 +891,83 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le // write base consonant for (i = baseConsonant; i < bcSpan; i += 1) { - output.writeChar(chars[i], i, &tagArray[4]); + output.writeChar(chars[i], i, tagArray4); } - if ((classTable->scriptFlags & IndicClassTable::SF_MATRAS_AFTER_BASE) != 0) { + 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) { + if (baseConsonant != lastConsonant && !seenPreBaseForm) { for (i = bcSpan + 1; i < postBase; i += 1) { - output.writeChar(chars[i], i, &tagArray[1]); + output.writeChar(chars[i], i, tagArray1); } if (postBase > lastConsonant) { // write halant that was after base consonant - output.writeChar(chars[bcSpan], bcSpan, &tagArray[1]); + output.writeChar(chars[bcSpan], bcSpan, tagArray1); } } - // write Mbelow, Mabove - if ((classTable->scriptFlags & IndicClassTable::SF_MATRAS_AFTER_BASE) == 0) { + // write Mbelow, SMbelow, Mabove + if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) { output.writeMbelow(); + output.writeSMbelow(); output.writeMabove(); } - if ((classTable->scriptFlags & IndicClassTable::SF_REPH_AFTER_BELOW) != 0) { + if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) != 0) { if (baseLimit == prev + 2) { - output.writeChar(chars[prev], prev, &tagArray[0]); - output.writeChar(chars[prev + 1], prev + 1, &tagArray[0]); + output.writeChar(chars[prev], prev, tagArray0); + output.writeChar(chars[prev + 1], prev + 1, tagArray0); } - // write VMabove - for (i = vmabove; i < vmpost; i += 1) { - output.writeChar(chars[i], i, &tagArray[1]); - } + 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) { + if (baseConsonant != lastConsonant && !seenPreBaseForm) { if (postBase <= lastConsonant) { for (i = postBase; i <= lastConsonant; i += 1) { - output.writeChar(chars[i], i, &tagArray[3]); + output.writeChar(chars[i], i, tagArray3); } // write halant that was after base consonant - output.writeChar(chars[bcSpan], bcSpan, &tagArray[1]); + 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, &tagArray[4]); + output.writeChar(chars[matra], matra, tagArray4); } } // write Mpost - if ((classTable->scriptFlags & IndicClassTable::SF_MATRAS_AFTER_BASE) == 0) { + if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) { output.writeMpost(); } output.writeLengthMark(); + output.writeAlLakuna(); // write reph - if ((classTable->scriptFlags & IndicClassTable::SF_REPH_AFTER_BELOW) == 0) { + if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) { if (baseLimit == prev + 2) { - output.writeChar(chars[prev], prev, &tagArray[0]); - output.writeChar(chars[prev + 1], prev + 1, &tagArray[0]); + output.writeChar(chars[prev], prev, tagArray0); + output.writeChar(chars[prev + 1], prev + 1, tagArray0); } - // write VMabove - for (i = vmabove; i < vmpost; i += 1) { - output.writeChar(chars[i], i, &tagArray[1]); - } + output.writeVMabove(); + output.writeSMabove(); } - // write VMpost - for (i = vmpost; i < syllable; i += 1) { - output.writeChar(chars[i], i, &tagArray[1]); - } + output.writeVMpost(); break; } @@ -499,13 +984,255 @@ le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le return output.getOutputIndex(); } -void IndicReordering::adjustMPres(MPreFixups *mpreFixups, LEGlyphID *glyphs, le_int32 *charIndices) +void IndicReordering::adjustMPres(MPreFixups *mpreFixups, LEGlyphStorage &glyphStorage, LEErrorCode& success) { if (mpreFixups != NULL) { - mpreFixups->apply(glyphs, charIndices); + 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); + if (classTable == NULL) { + return 0; + } + + 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 workChars[2]; + LEGlyphStorage workGlyphs; + + IndicReorderingOutput workOutput(workChars, workGlyphs, NULL); + + //le_int32 offset = 0; + +#if 0 +// TODO: Should this section of code have actually been doing something? + // First find the relevant virama for the script we are dealing with + LEUnicode virama; + for ( currentChar = classTable->firstChar ; currentChar <= classTable->lastChar ; currentChar++ ) { + if ( classTable->isVirama(currentChar)) { + virama = currentChar; + break; + } + } +#endif + + for ( currentChar = classTable->firstChar ; currentChar <= classTable->lastChar ; currentChar++ ) { + if ( classTable->isConsonant(currentChar)) { + workOutput.reset(); + } + } + + +} + U_NAMESPACE_END