224 lines
9.8 KiB
C++
224 lines
9.8 KiB
C++
/*
|
|
* (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
|