/* * (C) Copyright IBM Corp. and others 1998 - 2013 - All Rights Reserved * */ #include "LETypes.h" #include "LayoutTables.h" #include "MorphTables.h" #include "SubtableProcessor2.h" #include "IndicRearrangementProcessor2.h" #include "ContextualGlyphSubstProc2.h" #include "LigatureSubstProc2.h" #include "NonContextualGlyphSubstProc2.h" #include "ContextualGlyphInsertionProc2.h" #include "LEGlyphStorage.h" #include "LESwaps.h" U_NAMESPACE_BEGIN void MorphTableHeader2::process(const LEReferenceTo<MorphTableHeader2> &base, LEGlyphStorage &glyphStorage, le_int32 typoFlags, LEErrorCode &success) const { if(LE_FAILURE(success)) return; le_uint32 chainCount = SWAPL(this->nChains); LEReferenceTo<ChainHeader2> chainHeader(base, success, &chains[0]); /* chainHeader and subtableHeader are implemented as a moving pointer rather than an array dereference * to (slightly) reduce code churn. However, must be careful to preincrement them the 2nd time through. * We don't want to increment them at the end of the loop, as that would attempt to dereference * out of range memory. */ le_uint32 chain; for (chain = 0; LE_SUCCESS(success) && (chain < chainCount); chain++) { if (chain>0) { le_uint32 chainLength = SWAPL(chainHeader->chainLength); chainHeader.addOffset(chainLength, success); // Don't increment the first time } FeatureFlags flag = SWAPL(chainHeader->defaultFlags); le_uint32 nFeatureEntries = SWAPL(chainHeader->nFeatureEntries); le_uint32 nSubtables = SWAPL(chainHeader->nSubtables); LEReferenceTo<MorphSubtableHeader2> subtableHeader(chainHeader, success, (const MorphSubtableHeader2 *)&chainHeader->featureTable[nFeatureEntries]); le_uint32 subtable; if(LE_FAILURE(success)) break; // malformed table if (typoFlags != 0) { le_uint32 featureEntry; LEReferenceToArrayOf<FeatureTableEntry> featureTableRef(chainHeader, success, &chainHeader->featureTable[0], nFeatureEntries); if(LE_FAILURE(success)) break; // Feature subtables for (featureEntry = 0; featureEntry < nFeatureEntries; featureEntry++) { const FeatureTableEntry &featureTableEntry = featureTableRef(featureEntry, success); le_int16 featureType = SWAPW(featureTableEntry.featureType); le_int16 featureSetting = SWAPW(featureTableEntry.featureSetting); le_uint32 enableFlags = SWAPL(featureTableEntry.enableFlags); le_uint32 disableFlags = SWAPL(featureTableEntry.disableFlags); switch (featureType) { case ligaturesType: if ((typoFlags & LE_Ligatures_FEATURE_ENUM ) && (featureSetting ^ 0x1)){ flag &= disableFlags; flag |= enableFlags; } else { if (((typoFlags & LE_RLIG_FEATURE_FLAG) && featureSetting == requiredLigaturesOnSelector) || ((typoFlags & LE_CLIG_FEATURE_FLAG) && featureSetting == contextualLigaturesOnSelector) || ((typoFlags & LE_HLIG_FEATURE_FLAG) && featureSetting == historicalLigaturesOnSelector) || ((typoFlags & LE_LIGA_FEATURE_FLAG) && featureSetting == commonLigaturesOnSelector)) { flag &= disableFlags; flag |= enableFlags; } } break; case letterCaseType: if ((typoFlags & LE_SMCP_FEATURE_FLAG) && featureSetting == smallCapsSelector) { flag &= disableFlags; flag |= enableFlags; } break; case verticalSubstitutionType: break; case linguisticRearrangementType: break; case numberSpacingType: break; case smartSwashType: if ((typoFlags & LE_SWSH_FEATURE_FLAG) && (featureSetting ^ 0x1)){ flag &= disableFlags; flag |= enableFlags; } break; case diacriticsType: break; case verticalPositionType: break; case fractionsType: if (((typoFlags & LE_FRAC_FEATURE_FLAG) && featureSetting == diagonalFractionsSelector) || ((typoFlags & LE_AFRC_FEATURE_FLAG) && featureSetting == verticalFractionsSelector)) { flag &= disableFlags; flag |= enableFlags; } else { flag &= disableFlags; } break; case typographicExtrasType: if ((typoFlags & LE_ZERO_FEATURE_FLAG) && featureSetting == slashedZeroOnSelector) { flag &= disableFlags; flag |= enableFlags; } break; case mathematicalExtrasType: break; case ornamentSetsType: break; case characterAlternativesType: break; case designComplexityType: if (((typoFlags & LE_SS01_FEATURE_FLAG) && featureSetting == designLevel1Selector) || ((typoFlags & LE_SS02_FEATURE_FLAG) && featureSetting == designLevel2Selector) || ((typoFlags & LE_SS03_FEATURE_FLAG) && featureSetting == designLevel3Selector) || ((typoFlags & LE_SS04_FEATURE_FLAG) && featureSetting == designLevel4Selector) || ((typoFlags & LE_SS05_FEATURE_FLAG) && featureSetting == designLevel5Selector) || ((typoFlags & LE_SS06_FEATURE_FLAG) && featureSetting == designLevel6Selector) || ((typoFlags & LE_SS07_FEATURE_FLAG) && featureSetting == designLevel7Selector)) { flag &= disableFlags; flag |= enableFlags; } break; case styleOptionsType: break; case characterShapeType: break; case numberCaseType: break; case textSpacingType: break; case transliterationType: break; case annotationType: if ((typoFlags & LE_NALT_FEATURE_FLAG) && featureSetting == circleAnnotationSelector) { flag &= disableFlags; flag |= enableFlags; } break; case kanaSpacingType: break; case ideographicSpacingType: break; case rubyKanaType: if ((typoFlags & LE_RUBY_FEATURE_FLAG) && featureSetting == rubyKanaOnSelector) { flag &= disableFlags; flag |= enableFlags; } break; case cjkRomanSpacingType: break; default: break; } } } for (subtable = 0; LE_SUCCESS(success) && subtable < nSubtables; subtable++) { if(subtable>0) { le_uint32 length = SWAPL(subtableHeader->length); subtableHeader.addOffset(length, success); // Don't addOffset for the last entry. } le_uint32 coverage = SWAPL(subtableHeader->coverage); FeatureFlags subtableFeatures = SWAPL(subtableHeader->subtableFeatures); // should check coverage more carefully... if (((coverage & scfIgnoreVt2) || !(coverage & scfVertical2)) && (subtableFeatures & flag) != 0) { subtableHeader->process(subtableHeader, glyphStorage, success); } } } } void MorphSubtableHeader2::process(const LEReferenceTo<MorphSubtableHeader2> &base, LEGlyphStorage &glyphStorage, LEErrorCode &success) const { SubtableProcessor2 *processor = NULL; switch (SWAPL(coverage) & scfTypeMask2) { case mstIndicRearrangement: processor = new IndicRearrangementProcessor2(base, success); break; case mstContextualGlyphSubstitution: processor = new ContextualGlyphSubstitutionProcessor2(base, success); break; case mstLigatureSubstitution: processor = new LigatureSubstitutionProcessor2(base, success); break; case mstReservedUnused: break; case mstNonContextualGlyphSubstitution: processor = NonContextualGlyphSubstitutionProcessor2::createInstance(base, success); break; case mstContextualGlyphInsertion: processor = new ContextualGlyphInsertionProcessor2(base, success); break; default: return; break; /*NOTREACHED*/ } if (processor != NULL) { processor->process(glyphStorage, success); delete processor; } else { if(LE_SUCCESS(success)) { success = LE_MEMORY_ALLOCATION_ERROR; // because ptr is null and we didn't break out. } } } U_NAMESPACE_END