X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/b75a7d8f3b4adbae880cab104ce2c6a50eee4db2..ef6cf650f4a75c3f97de06b51fa104f2069b9ea2:/icuSources/layout/LookupProcessor.cpp?ds=inline diff --git a/icuSources/layout/LookupProcessor.cpp b/icuSources/layout/LookupProcessor.cpp index 8dc4edc2..eb831cc5 100644 --- a/icuSources/layout/LookupProcessor.cpp +++ b/icuSources/layout/LookupProcessor.cpp @@ -1,7 +1,6 @@ /* - * %W% %E% * - * (C) Copyright IBM Corp. 1998-2003 - All Rights Reserved + * (C) Copyright IBM Corp. and others 1998-2015 - All Rights Reserved * */ @@ -9,36 +8,35 @@ #include "OpenTypeUtilities.h" #include "LEFontInstance.h" #include "OpenTypeTables.h" -#include "Features.h" +#include "ICUFeatures.h" #include "Lookups.h" #include "ScriptAndLanguage.h" #include "GlyphDefinitionTables.h" -#include "GlyphPositionAdjustments.h" +#include "GlyphIterator.h" #include "LookupProcessor.h" +#include "LEGlyphStorage.h" #include "LESwaps.h" U_NAMESPACE_BEGIN -const LETag LookupProcessor::notSelected = 0x00000000; -const LETag LookupProcessor::defaultFeature = 0xFFFFFFFF; - -const LETag emptyTag = 0x00000000; - - -le_uint32 LookupProcessor::applyLookupTable(const LookupTable *lookupTable, GlyphIterator *glyphIterator, - const LEFontInstance *fontInstance) const +le_uint32 LookupProcessor::applyLookupTable(const LEReferenceTo &lookupTable, GlyphIterator *glyphIterator, + const LEFontInstance *fontInstance, LEErrorCode& success) const { + if (LE_FAILURE(success)) { + return 0; + } + le_uint16 lookupType = SWAPW(lookupTable->lookupType); le_uint16 subtableCount = SWAPW(lookupTable->subTableCount); le_int32 startPosition = glyphIterator->getCurrStreamPosition(); le_uint32 delta; for (le_uint16 subtable = 0; subtable < subtableCount; subtable += 1) { - const LookupSubtable *lookupSubtable = lookupTable->getLookupSubtable(subtable); + LEReferenceTo lookupSubtable = lookupTable->getLookupSubtable(lookupTable, subtable, success); - delta = applySubtable(lookupSubtable, lookupType, glyphIterator, fontInstance); + delta = applySubtable(lookupSubtable, lookupType, glyphIterator, fontInstance, success); - if (delta > 0) { + if (delta > 0 && LE_FAILURE(success)) { return 1; } @@ -48,131 +46,222 @@ le_uint32 LookupProcessor::applyLookupTable(const LookupTable *lookupTable, Glyp return 1; } -void LookupProcessor::process(LEGlyphID *glyphs, GlyphPositionAdjustment *glyphPositionAdjustments, const LETag **glyphTags, le_int32 glyphCount, - le_bool rightToLeft, const GlyphDefinitionTableHeader *glyphDefinitionTableHeader, - const LEFontInstance *fontInstance) const +le_int32 LookupProcessor::process(LEGlyphStorage &glyphStorage, GlyphPositionAdjustments *glyphPositionAdjustments, + le_bool rightToLeft, const LEReferenceTo &glyphDefinitionTableHeader, + const LEFontInstance *fontInstance, LEErrorCode& success) const { + if (LE_FAILURE(success)) { + return 0; + } + + le_int32 glyphCount = glyphStorage.getGlyphCount(); + if (lookupSelectArray == NULL) { - return; + return glyphCount; } - for (le_uint16 order = 0; order < lookupOrderCount; order += 1) { + GlyphIterator glyphIterator(glyphStorage, glyphPositionAdjustments, + rightToLeft, 0, 0, glyphDefinitionTableHeader); + le_int32 newGlyphCount = glyphCount; + + for (le_uint16 order = 0; order < lookupOrderCount && LE_SUCCESS(success); order += 1) { le_uint16 lookup = lookupOrderArray[order]; - LETag selectTag = lookupSelectArray[lookup]; + FeatureMask selectMask = lookupSelectArray[lookup]; - if (selectTag != notSelected) { - const LookupTable *lookupTable = lookupListTable->getLookupTable(lookup); + if (selectMask != 0) { + const LEReferenceTo lookupTable = lookupListTable->getLookupTable(lookupListTable, lookup, success); + if (!lookupTable.isValid() ||LE_FAILURE(success) ) { + continue; + } le_uint16 lookupFlags = SWAPW(lookupTable->lookupFlags); - GlyphIterator glyphIterator(glyphs, glyphPositionAdjustments, glyphCount, - rightToLeft, lookupFlags, selectTag, glyphTags, - glyphDefinitionTableHeader); + + glyphIterator.reset(lookupFlags, selectMask); while (glyphIterator.findFeatureTag()) { - le_uint32 delta = 1; - - while (glyphIterator.next(delta)) { - delta = applyLookupTable(lookupTable, &glyphIterator, fontInstance); + applyLookupTable(lookupTable, &glyphIterator, fontInstance, success); + if (LE_FAILURE(success)) { + return 0; } } + + newGlyphCount = glyphIterator.applyInsertions(); } } + + return newGlyphCount; } le_uint32 LookupProcessor::applySingleLookup(le_uint16 lookupTableIndex, GlyphIterator *glyphIterator, - const LEFontInstance *fontInstance) const + const LEFontInstance *fontInstance, LEErrorCode& success) const { - const LookupTable *lookupTable = lookupListTable->getLookupTable(lookupTableIndex); + if (LE_FAILURE(success)) { + return 0; + } + + const LEReferenceTo lookupTable = lookupListTable->getLookupTable(lookupListTable, lookupTableIndex, success); + if (!lookupTable.isValid()) { + success = LE_INTERNAL_ERROR; + return 0; + } le_uint16 lookupFlags = SWAPW(lookupTable->lookupFlags); GlyphIterator tempIterator(*glyphIterator, lookupFlags); - le_uint32 delta = applyLookupTable(lookupTable, &tempIterator, fontInstance); + le_uint32 delta = applyLookupTable(lookupTable, &tempIterator, fontInstance, success); return delta; } -le_int32 LookupProcessor::selectLookups(const FeatureTable *featureTable, LETag featureTag, le_int32 order) +le_int32 LookupProcessor::selectLookups(const LEReferenceTo &featureTable, FeatureMask featureMask, le_int32 order, LEErrorCode &success) { - le_uint16 lookupCount = featureTable? SWAPW(featureTable->lookupCount) : 0; - - for (le_uint16 lookup = 0; lookup < lookupCount; lookup += 1) { - le_uint16 lookupListIndex = SWAPW(featureTable->lookupListIndexArray[lookup]); - - lookupSelectArray[lookupListIndex] = featureTag; - lookupOrderArray[order + lookup] = lookupListIndex; + le_uint16 lookupCount = featureTable.isValid()? SWAPW(featureTable->lookupCount) : 0; + le_uint32 store = (le_uint32)order; + + LEReferenceToArrayOf lookupListIndexArray(featureTable, success, featureTable->lookupListIndexArray, lookupCount); + + for (le_uint16 lookup = 0; LE_SUCCESS(success) && lookup < lookupCount; lookup += 1) { + le_uint16 lookupListIndex = SWAPW(lookupListIndexArray.getObject(lookup,success)); + if (lookupListIndex >= lookupSelectCount) { + continue; + } + if (store >= lookupOrderCount) { + continue; + } + + lookupSelectArray[lookupListIndex] |= featureMask; + lookupOrderArray[store++] = lookupListIndex; } - return lookupCount; + return store - order; } -LookupProcessor::LookupProcessor(const char *baseAddress, +LookupProcessor::LookupProcessor(const LETableReference &baseAddress, Offset scriptListOffset, Offset featureListOffset, Offset lookupListOffset, - LETag scriptTag, LETag languageTag, const LETag *featureOrder) - : lookupListTable(NULL), featureListTable(NULL), lookupSelectArray(NULL), - requiredFeatureTag(notSelected), lookupOrderArray(NULL), lookupOrderCount(0) + LETag scriptTag, LETag languageTag, const FeatureMap *featureMap, le_int32 featureMapCount, le_bool orderFeatures, + LEErrorCode& success) + : lookupListTable(), featureListTable(), lookupSelectArray(NULL), lookupSelectCount(0), + lookupOrderArray(NULL), lookupOrderCount(0), fReference(baseAddress) { - const ScriptListTable *scriptListTable = NULL; - const LangSysTable *langSysTable = NULL; + LEReferenceTo scriptListTable; + LEReferenceTo langSysTable; le_uint16 featureCount = 0; le_uint16 lookupListCount = 0; le_uint16 requiredFeatureIndex; + if (LE_FAILURE(success)) { + return; + } + if (scriptListOffset != 0) { - scriptListTable = (const ScriptListTable *) (baseAddress + scriptListOffset); - langSysTable = scriptListTable->findLanguage(scriptTag, languageTag); + scriptListTable = LEReferenceTo(baseAddress, success, scriptListOffset); + langSysTable = scriptListTable->findLanguage(scriptListTable, scriptTag, languageTag, success); - if (langSysTable != 0) { - featureCount = SWAPW(langSysTable->featureCount); - } + if (langSysTable.isValid() && LE_SUCCESS(success)) { + featureCount = SWAPW(langSysTable->featureCount); + } } if (featureListOffset != 0) { - featureListTable = (const FeatureListTable *) (baseAddress + featureListOffset); + featureListTable = LEReferenceTo(baseAddress, success, featureListOffset); } if (lookupListOffset != 0) { - lookupListTable = (const LookupListTable *) (baseAddress + lookupListOffset); + lookupListTable = LEReferenceTo(baseAddress,success, lookupListOffset); + if(LE_SUCCESS(success) && lookupListTable.isValid()) { lookupListCount = SWAPW(lookupListTable->lookupCount); + } } - if (langSysTable == NULL || featureListTable == NULL || lookupListTable == NULL || + if (langSysTable.isEmpty() || featureListTable.isEmpty() || lookupListTable.isEmpty() || featureCount == 0 || lookupListCount == 0) { return; } - requiredFeatureIndex = SWAPW(langSysTable->reqFeatureIndex); + if(langSysTable.isValid()) { + requiredFeatureIndex = SWAPW(langSysTable->reqFeatureIndex); + } - lookupSelectArray = LE_NEW_ARRAY(LETag, lookupListCount); + lookupSelectArray = LE_NEW_ARRAY(FeatureMask, lookupListCount); + if (lookupSelectArray == NULL) { + success = LE_MEMORY_ALLOCATION_ERROR; + return; + } for (int i = 0; i < lookupListCount; i += 1) { - lookupSelectArray[i] = notSelected; + lookupSelectArray[i] = 0; } + lookupSelectCount = lookupListCount; le_int32 count, order = 0; - const FeatureTable *featureTable = 0; + le_uint32 featureReferences = 0; + LEReferenceTo featureTable; LETag featureTag; - lookupOrderArray = LE_NEW_ARRAY(le_uint16, lookupListCount); + LEReferenceTo requiredFeatureTable; + LETag requiredFeatureTag = 0x00000000U; + + // Count the total number of lookups referenced by all features. This will + // be the maximum number of entries in the lookupOrderArray. We can't use + // lookupListCount because some lookups might be referenced by more than + // one feature. + if(featureListTable.isValid() && LE_SUCCESS(success)) { + LEReferenceToArrayOf featureIndexArray(langSysTable, success, langSysTable->featureIndexArray, featureCount); + + for (le_uint32 feature = 0; LE_SUCCESS(success)&&(feature < featureCount); feature += 1) { + le_uint16 featureIndex = SWAPW(featureIndexArray.getObject(feature, success)); + + featureTable = featureListTable->getFeatureTable(featureListTable, featureIndex, &featureTag, success); + if (!featureTable.isValid() || LE_FAILURE(success)) { + continue; + } + featureReferences += SWAPW(featureTable->lookupCount); + } + } + + if (!featureTable.isValid() || LE_FAILURE(success)) { + success = LE_INTERNAL_ERROR; + return; + } if (requiredFeatureIndex != 0xFFFF) { - featureTable = featureListTable->getFeatureTable(requiredFeatureIndex, &featureTag); - order += selectLookups(featureTable, defaultFeature, order); + requiredFeatureTable = featureListTable->getFeatureTable(featureListTable, requiredFeatureIndex, &requiredFeatureTag, success); + featureReferences += SWAPW(requiredFeatureTable->lookupCount); + } + + lookupOrderArray = LE_NEW_ARRAY(le_uint16, featureReferences); + if (lookupOrderArray == NULL) { + success = LE_MEMORY_ALLOCATION_ERROR; + return; } + lookupOrderCount = featureReferences; - if (featureOrder != NULL) { - if (order > 1) { - OpenTypeUtilities::sort(lookupOrderArray, order); + for (le_int32 f = 0; f < featureMapCount; f += 1) { + FeatureMap fm = featureMap[f]; + count = 0; + + // If this is the required feature, add its lookups + if (requiredFeatureTag == fm.tag) { + count += selectLookups(requiredFeatureTable, fm.mask, order, success); } - for (le_int32 tag = 0; featureOrder[tag] != emptyTag; tag += 1) { - featureTag = featureOrder[tag]; - count = 0; + if (orderFeatures) { + // If we added lookups from the required feature, sort them + if (count > 1) { + OpenTypeUtilities::sort(lookupOrderArray, order); + } for (le_uint16 feature = 0; feature < featureCount; feature += 1) { - le_uint16 featureIndex = SWAPW(langSysTable->featureIndexArray[feature]); + LEReferenceToArrayOf featureIndexArray(langSysTable, success, langSysTable->featureIndexArray, featureCount); + le_uint16 featureIndex = SWAPW(featureIndexArray.getObject(feature,success)); + + // don't add the required feature to the list more than once... + // TODO: Do we need this check? (Spec. says required feature won't be in feature list...) + if (featureIndex == requiredFeatureIndex) { + continue; + } - featureTable = featureListTable->getFeatureTable(featureIndex, &featureTag); + featureTable = featureListTable->getFeatureTable(featureListTable, featureIndex, &featureTag, success); - if (featureTag == featureOrder[tag]) { - count += selectLookups(featureTable, featureTag, order + count); + if (featureTag == fm.tag) { + count += selectLookups(featureTable, fm.mask, order + count, success); } } @@ -181,19 +270,52 @@ LookupProcessor::LookupProcessor(const char *baseAddress, } order += count; - } - } else { - for (le_uint16 feature = 0; feature < featureCount; feature += 1) { - le_uint16 featureIndex = SWAPW(langSysTable->featureIndexArray[feature]); + } else if(langSysTable.isValid()) { + LEReferenceToArrayOf featureIndexArray(langSysTable, success, langSysTable->featureIndexArray, featureCount); + for (le_uint16 feature = 0; LE_SUCCESS(success)&& (feature < featureCount); feature += 1) { + le_uint16 featureIndex = SWAPW(featureIndexArray.getObject(feature,success)); - featureTable = featureListTable->getFeatureTable(featureIndex, &featureTag); - count = selectLookups(featureTable, featureTag, order); - order += count; + // don't add the required feature to the list more than once... + // NOTE: This check is commented out because the spec. says that + // the required feature won't be in the feature list, and because + // any duplicate entries will be removed below. +#if 0 + if (featureIndex == requiredFeatureIndex) { + continue; + } +#endif + + featureTable = featureListTable->getFeatureTable(featureListTable, featureIndex, &featureTag, success); + + if (featureTag == fm.tag) { + order += selectLookups(featureTable, fm.mask, order, success); + } + } } + } + + if (!orderFeatures && (order > 1)) { + OpenTypeUtilities::sort(lookupOrderArray, order); + + // If there's no specified feature order, + // we will apply the lookups in the order + // that they're in the font. If a particular + // lookup may be referenced by more than one feature, + // it will apprear in the lookupOrderArray more than + // once, so remove any duplicate entries in the sorted array. + le_int32 out = 1; + + for (le_int32 in = 1; in < order; in += 1) { + if (lookupOrderArray[out - 1] != lookupOrderArray[in]) { + if (out != in) { + lookupOrderArray[out] = lookupOrderArray[in]; + } - if (order > 1) { - OpenTypeUtilities::sort(lookupOrderArray, order); + out += 1; + } } + + order = out; } lookupOrderCount = order; @@ -201,12 +323,14 @@ LookupProcessor::LookupProcessor(const char *baseAddress, LookupProcessor::LookupProcessor() { + lookupOrderArray = NULL; + lookupSelectArray = NULL; } LookupProcessor::~LookupProcessor() { LE_DELETE_ARRAY(lookupOrderArray); LE_DELETE_ARRAY(lookupSelectArray); -}; +} U_NAMESPACE_END