MorphTables2.cpp 11.3 KB
Newer Older
P
prr 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

/*
 * (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

P
prr 已提交
45 46
void MorphTableHeader2::process(const LEReferenceTo<MorphTableHeader2> &base, LEGlyphStorage &glyphStorage,
                                le_int32 typoFlags, LEErrorCode &success) const
P
prr 已提交
47
{
P
prr 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61
  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);
62 63 64 65
          if (chainLength & 0x03) { // incorrect alignment for 32 bit tables
              success = LE_MEMORY_ALLOCATION_ERROR; // as good a choice as any
              return;
          }
P
prr 已提交
66 67
          chainHeader.addOffset(chainLength, success); // Don't increment the first time
        }
P
prr 已提交
68 69 70
        FeatureFlags flag = SWAPL(chainHeader->defaultFlags);
        le_uint32 nFeatureEntries = SWAPL(chainHeader->nFeatureEntries);
        le_uint32 nSubtables = SWAPL(chainHeader->nSubtables);
P
prr 已提交
71 72
        LEReferenceTo<MorphSubtableHeader2> subtableHeader(chainHeader,
              success, (const MorphSubtableHeader2 *)&chainHeader->featureTable[nFeatureEntries]);
P
prr 已提交
73
        le_uint32 subtable;
P
prr 已提交
74
        if(LE_FAILURE(success)) break; // malformed table
P
prr 已提交
75 76 77

        if (typoFlags != 0) {
           le_uint32 featureEntry;
P
prr 已提交
78 79
           LEReferenceToArrayOf<FeatureTableEntry> featureTableRef(chainHeader, success, &chainHeader->featureTable[0], nFeatureEntries);
           if(LE_FAILURE(success)) break;
P
prr 已提交
80 81
            // Feature subtables
            for (featureEntry = 0; featureEntry < nFeatureEntries; featureEntry++) {
P
prr 已提交
82
                const FeatureTableEntry &featureTableEntry = featureTableRef(featureEntry, success);
P
prr 已提交
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
                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;
                }
            }
        }

P
prr 已提交
192 193 194
        for (subtable = 0;  LE_SUCCESS(success) && subtable < nSubtables; subtable++) {
            if(subtable>0)  {
              le_uint32 length = SWAPL(subtableHeader->length);
195 196 197 198
              if (length & 0x03) { // incorrect alignment for 32 bit tables
                  success = LE_MEMORY_ALLOCATION_ERROR; // as good a choice as any
                  return;
              }
P
prr 已提交
199
              subtableHeader.addOffset(length, success); // Don't addOffset for the last entry.
P
prr 已提交
200
              if (LE_FAILURE(success)) break;
P
prr 已提交
201
            }
P
prr 已提交
202 203 204 205
            le_uint32 coverage = SWAPL(subtableHeader->coverage);
            FeatureFlags subtableFeatures = SWAPL(subtableHeader->subtableFeatures);
            // should check coverage more carefully...
            if (((coverage & scfIgnoreVt2) || !(coverage & scfVertical2)) && (subtableFeatures & flag) != 0) {
P
prr 已提交
206
              subtableHeader->process(subtableHeader, glyphStorage, success);
P
prr 已提交
207 208 209 210 211
            }
        }
    }
}

P
prr 已提交
212
void MorphSubtableHeader2::process(const LEReferenceTo<MorphSubtableHeader2> &base, LEGlyphStorage &glyphStorage, LEErrorCode &success) const
P
prr 已提交
213 214 215
{
    SubtableProcessor2 *processor = NULL;

P
prr 已提交
216 217
    if (LE_FAILURE(success)) return;

P
prr 已提交
218 219 220
    switch (SWAPL(coverage) & scfTypeMask2)
    {
    case mstIndicRearrangement:
P
prr 已提交
221
        processor = new IndicRearrangementProcessor2(base, success);
P
prr 已提交
222 223 224
        break;

    case mstContextualGlyphSubstitution:
P
prr 已提交
225
        processor = new ContextualGlyphSubstitutionProcessor2(base, success);
P
prr 已提交
226 227 228
        break;

    case mstLigatureSubstitution:
P
prr 已提交
229
        processor = new LigatureSubstitutionProcessor2(base, success);
P
prr 已提交
230 231 232 233 234 235
        break;

    case mstReservedUnused:
        break;

    case mstNonContextualGlyphSubstitution:
P
prr 已提交
236
        processor = NonContextualGlyphSubstitutionProcessor2::createInstance(base, success);
P
prr 已提交
237 238 239 240
        break;


    case mstContextualGlyphInsertion:
P
prr 已提交
241
        processor = new ContextualGlyphInsertionProcessor2(base, success);
P
prr 已提交
242 243 244
        break;

    default:
P
prr 已提交
245 246
        return;
        break; /*NOTREACHED*/
P
prr 已提交
247 248 249
    }

    if (processor != NULL) {
P
prr 已提交
250
      processor->process(glyphStorage, success);
P
prr 已提交
251
        delete processor;
P
prr 已提交
252 253 254 255
    } else {
      if(LE_SUCCESS(success)) {
        success = LE_MEMORY_ALLOCATION_ERROR; // because ptr is null and we didn't break out.
      }
P
prr 已提交
256 257 258 259
    }
}

U_NAMESPACE_END