tor-browser

math.cc (18398B)

---

// Copyright (c) 2014-2017 The OTS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// We use an underscore to avoid confusion with the standard math.h library.
#include "math_.h"

#include <limits>
#include <vector>

#include "layout.h"
#include "maxp.h"

// MATH - The MATH Table
// http://www.microsoft.com/typography/otspec/math.htm

namespace {

// The size of MATH header.
// Version
// MathConstants
// MathGlyphInfo
// MathVariants
const unsigned kMathHeaderSize = 4 + 3 * 2;

// The size of the MathGlyphInfo header.
// MathItalicsCorrectionInfo
// MathTopAccentAttachment
// ExtendedShapeCoverage
// MathKernInfo
const unsigned kMathGlyphInfoHeaderSize = 4 * 2;

// The size of the MathValueRecord.
// Value
// DeviceTable
const unsigned kMathValueRecordSize = 2 * 2;

// The size of the GlyphPartRecord.
// glyph
// StartConnectorLength
// EndConnectorLength
// FullAdvance
// PartFlags
const unsigned kGlyphPartRecordSize = 5 * 2;

}  // namespace

namespace ots {

// Shared Table: MathValueRecord

bool OpenTypeMATH::ParseMathValueRecord(ots::Buffer* subtable,
                                       const uint8_t *data,
                                       const size_t length) {
 // Check the Value field.
 if (!subtable->Skip(2)) {
   return OTS_FAILURE();
 }

 // Check the offset to device table.
 uint16_t offset = 0;
 if (!subtable->ReadU16(&offset)) {
   return OTS_FAILURE();
 }
 if (offset) {
   if (offset >= length) {
     return OTS_FAILURE();
   }
   if (!ots::ParseDeviceTable(GetFont(), data + offset, length - offset)) {
     return OTS_FAILURE();
   }
 }

 return true;
}

bool OpenTypeMATH::ParseMathConstantsTable(const uint8_t *data,
                                          size_t length) {
 ots::Buffer subtable(data, length);

 // Part 1: int16 or uint16 constants.
 //  ScriptPercentScaleDown
 //  ScriptScriptPercentScaleDown
 //  DelimitedSubFormulaMinHeight
 //  DisplayOperatorMinHeight
 if (!subtable.Skip(4 * 2)) {
   return OTS_FAILURE();
 }

 // Part 2: MathValueRecord constants.
 // MathLeading
 // AxisHeight
 // AccentBaseHeight
 // FlattenedAccentBaseHeight
 // SubscriptShiftDown
 // SubscriptTopMax
 // SubscriptBaselineDropMin
 // SuperscriptShiftUp
 // SuperscriptShiftUpCramped
 // SuperscriptBottomMin
 //
 // SuperscriptBaselineDropMax
 // SubSuperscriptGapMin
 // SuperscriptBottomMaxWithSubscript
 // SpaceAfterScript
 // UpperLimitGapMin
 // UpperLimitBaselineRiseMin
 // LowerLimitGapMin
 // LowerLimitBaselineDropMin
 // StackTopShiftUp
 // StackTopDisplayStyleShiftUp
 //
 // StackBottomShiftDown
 // StackBottomDisplayStyleShiftDown
 // StackGapMin
 // StackDisplayStyleGapMin
 // StretchStackTopShiftUp
 // StretchStackBottomShiftDown
 // StretchStackGapAboveMin
 // StretchStackGapBelowMin
 // FractionNumeratorShiftUp
 // FractionNumeratorDisplayStyleShiftUp
 //
 // FractionDenominatorShiftDown
 // FractionDenominatorDisplayStyleShiftDown
 // FractionNumeratorGapMin
 // FractionNumDisplayStyleGapMin
 // FractionRuleThickness
 // FractionDenominatorGapMin
 // FractionDenomDisplayStyleGapMin
 // SkewedFractionHorizontalGap
 // SkewedFractionVerticalGap
 // OverbarVerticalGap
 //
 // OverbarRuleThickness
 // OverbarExtraAscender
 // UnderbarVerticalGap
 // UnderbarRuleThickness
 // UnderbarExtraDescender
 // RadicalVerticalGap
 // RadicalDisplayStyleVerticalGap
 // RadicalRuleThickness
 // RadicalExtraAscender
 // RadicalKernBeforeDegree
 //
 // RadicalKernAfterDegree
 for (unsigned i = 0; i < static_cast<unsigned>(51); ++i) {
   if (!ParseMathValueRecord(&subtable, data, length)) {
     return OTS_FAILURE();
   }
 }

 // Part 3: uint16 constant
 // RadicalDegreeBottomRaisePercent
 if (!subtable.Skip(2)) {
   return OTS_FAILURE();
 }

 return true;
}

bool OpenTypeMATH::ParseMathValueRecordSequenceForGlyphs(ots::Buffer* subtable,
                                                        const uint8_t *data,
                                                        const size_t length,
                                                        const uint16_t num_glyphs) {
 // Check the header.
 uint16_t offset_coverage = 0;
 uint16_t sequence_count = 0;
 if (!subtable->ReadU16(&offset_coverage) ||
     !subtable->ReadU16(&sequence_count)) {
   return OTS_FAILURE();
 }

 const unsigned sequence_end = static_cast<unsigned>(2 * 2) +
     sequence_count * kMathValueRecordSize;
 if (sequence_end > std::numeric_limits<uint16_t>::max()) {
   return OTS_FAILURE();
 }

 // Check coverage table.
 if (offset_coverage < sequence_end || offset_coverage >= length) {
   return OTS_FAILURE();
 }
 if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage,
                              length - offset_coverage,
                              num_glyphs, sequence_count)) {
   return OTS_FAILURE();
 }

 // Check sequence.
 for (unsigned i = 0; i < sequence_count; ++i) {
   if (!ParseMathValueRecord(subtable, data, length)) {
     return OTS_FAILURE();
   }
 }

 return true;
}

bool OpenTypeMATH::ParseMathItalicsCorrectionInfoTable(const uint8_t *data,
                                                      size_t length,
                                                      const uint16_t num_glyphs) {
 ots::Buffer subtable(data, length);
 return ParseMathValueRecordSequenceForGlyphs(&subtable, data, length,
                                              num_glyphs);
}

bool OpenTypeMATH::ParseMathTopAccentAttachmentTable(const uint8_t *data,
                                                    size_t length,
                                                    const uint16_t num_glyphs) {
 ots::Buffer subtable(data, length);
 return ParseMathValueRecordSequenceForGlyphs(&subtable, data, length,
                                              num_glyphs);
}

bool OpenTypeMATH::ParseMathKernTable(const uint8_t *data, size_t length) {
 ots::Buffer subtable(data, length);

 // Check the Height count.
 uint16_t height_count = 0;
 if (!subtable.ReadU16(&height_count)) {
   return OTS_FAILURE();
 }

 // Check the Correction Heights.
 for (unsigned i = 0; i < height_count; ++i) {
   if (!ParseMathValueRecord(&subtable, data, length)) {
     return OTS_FAILURE();
   }
 }

 // Check the Kern Values.
 for (unsigned i = 0; i <= height_count; ++i) {
   if (!ParseMathValueRecord(&subtable, data, length)) {
     return OTS_FAILURE();
   }
 }

 return true;
}

bool OpenTypeMATH::ParseMathKernInfoTable(const uint8_t *data,
                                         size_t length,
                                         const uint16_t num_glyphs) {
 ots::Buffer subtable(data, length);

 // Check the header.
 uint16_t offset_coverage = 0;
 uint16_t sequence_count = 0;
 if (!subtable.ReadU16(&offset_coverage) ||
     !subtable.ReadU16(&sequence_count)) {
   return OTS_FAILURE();
 }

 const unsigned sequence_end = static_cast<unsigned>(2 * 2) +
   sequence_count * 4 * 2;
 if (sequence_end > std::numeric_limits<uint16_t>::max()) {
   return OTS_FAILURE();
 }

 // Check coverage table.
 if (offset_coverage < sequence_end || offset_coverage >= length) {
   return OTS_FAILURE();
 }
 if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, length - offset_coverage,
                              num_glyphs, sequence_count)) {
   return OTS_FAILURE();
 }

 // Check sequence of MathKernInfoRecord
 for (unsigned i = 0; i < sequence_count; ++i) {
   // Check TopRight, TopLeft, BottomRight and BottomLeft Math Kern.
   for (unsigned j = 0; j < 4; ++j) {
     uint16_t offset_math_kern = 0;
     if (!subtable.ReadU16(&offset_math_kern)) {
       return OTS_FAILURE();
     }
     if (offset_math_kern) {
       if (offset_math_kern < sequence_end || offset_math_kern >= length ||
           !ParseMathKernTable(data + offset_math_kern,
                               length - offset_math_kern)) {
         return OTS_FAILURE();
       }
     }
   }
 }

 return true;
}

bool OpenTypeMATH::ParseMathGlyphInfoTable(const uint8_t *data,
                                          size_t length,
                                          const uint16_t num_glyphs) {
 ots::Buffer subtable(data, length);

 // Check Header.
 uint16_t offset_math_italics_correction_info = 0;
 uint16_t offset_math_top_accent_attachment = 0;
 uint16_t offset_extended_shaped_coverage = 0;
 uint16_t offset_math_kern_info = 0;
 if (!subtable.ReadU16(&offset_math_italics_correction_info) ||
     !subtable.ReadU16(&offset_math_top_accent_attachment) ||
     !subtable.ReadU16(&offset_extended_shaped_coverage) ||
     !subtable.ReadU16(&offset_math_kern_info)) {
   return OTS_FAILURE();
 }

 // Check subtables.
 // The specification does not say whether the offsets for
 // MathItalicsCorrectionInfo, MathTopAccentAttachment and MathKernInfo may
 // be NULL, but that's the case in some fonts (e.g STIX) so we accept that.
 if (offset_math_italics_correction_info) {
   if (offset_math_italics_correction_info >= length ||
       offset_math_italics_correction_info < kMathGlyphInfoHeaderSize ||
       !ParseMathItalicsCorrectionInfoTable(
           data + offset_math_italics_correction_info,
           length - offset_math_italics_correction_info,
           num_glyphs)) {
     return OTS_FAILURE();
   }
 }
 if (offset_math_top_accent_attachment) {
   if (offset_math_top_accent_attachment >= length ||
       offset_math_top_accent_attachment < kMathGlyphInfoHeaderSize ||
       !ParseMathTopAccentAttachmentTable(data +
                                          offset_math_top_accent_attachment,
                                          length -
                                          offset_math_top_accent_attachment,
                                          num_glyphs)) {
     return OTS_FAILURE();
   }
 }
 if (offset_extended_shaped_coverage) {
   if (offset_extended_shaped_coverage >= length ||
       offset_extended_shaped_coverage < kMathGlyphInfoHeaderSize ||
       !ots::ParseCoverageTable(GetFont(), data + offset_extended_shaped_coverage,
                                length - offset_extended_shaped_coverage,
                                num_glyphs)) {
     return OTS_FAILURE();
   }
 }
 if (offset_math_kern_info) {
   if (offset_math_kern_info >= length ||
       offset_math_kern_info < kMathGlyphInfoHeaderSize ||
       !ParseMathKernInfoTable(data + offset_math_kern_info,
                               length - offset_math_kern_info, num_glyphs)) {
     return OTS_FAILURE();
   }
 }

 return true;
}

bool OpenTypeMATH::ParseGlyphAssemblyTable(const uint8_t *data,
                                          size_t length,
                                          const uint16_t num_glyphs) {
 ots::Buffer subtable(data, length);

 // Check the header.
 uint16_t part_count = 0;
 if (!ParseMathValueRecord(&subtable, data, length) ||
     !subtable.ReadU16(&part_count)) {
   return OTS_FAILURE();
 }

 const unsigned sequence_end = kMathValueRecordSize +
   static_cast<unsigned>(2) + part_count * kGlyphPartRecordSize;
 if (sequence_end > std::numeric_limits<uint16_t>::max()) {
   return OTS_FAILURE();
 }

 // Check the sequence of GlyphPartRecord.
 for (unsigned i = 0; i < part_count; ++i) {
   uint16_t glyph = 0;
   uint16_t part_flags = 0;
   if (!subtable.ReadU16(&glyph) ||
       !subtable.Skip(2 * 3) ||
       !subtable.ReadU16(&part_flags)) {
     return OTS_FAILURE();
   }
   if (glyph >= num_glyphs) {
     return Error("bad glyph ID: %u", glyph);
   }
   if (part_flags & ~0x00000001) {
     return Error("unknown part flag: %u", part_flags);
   }
 }

 return true;
}

bool OpenTypeMATH::ParseMathGlyphConstructionTable(const uint8_t *data,
                                                  size_t length,
                                                  const uint16_t num_glyphs) {
 ots::Buffer subtable(data, length);

 // Check the header.
 uint16_t offset_glyph_assembly = 0;
 uint16_t variant_count = 0;
 if (!subtable.ReadU16(&offset_glyph_assembly) ||
     !subtable.ReadU16(&variant_count)) {
   return OTS_FAILURE();
 }

 const unsigned sequence_end = static_cast<unsigned>(2 * 2) +
   variant_count * 2 * 2;
 if (sequence_end > std::numeric_limits<uint16_t>::max()) {
   return OTS_FAILURE();
 }

 // Check the GlyphAssembly offset.
 if (offset_glyph_assembly) {
   if (offset_glyph_assembly >= length ||
       offset_glyph_assembly < sequence_end) {
     return OTS_FAILURE();
   }
   if (!ParseGlyphAssemblyTable(data + offset_glyph_assembly,
                                length - offset_glyph_assembly, num_glyphs)) {
     return OTS_FAILURE();
   }
 }

 // Check the sequence of MathGlyphVariantRecord.
 for (unsigned i = 0; i < variant_count; ++i) {
   uint16_t glyph = 0;
   if (!subtable.ReadU16(&glyph) ||
       !subtable.Skip(2)) {
     return OTS_FAILURE();
   }
   if (glyph >= num_glyphs) {
     return Error("bad glyph ID: %u", glyph);
   }
 }

 return true;
}

bool OpenTypeMATH::ParseMathGlyphConstructionSequence(ots::Buffer* subtable,
                                                     const uint8_t *data,
                                                     size_t length,
                                                     const uint16_t num_glyphs,
                                                     uint16_t offset_coverage,
                                                     uint16_t glyph_count,
                                                     const unsigned sequence_end) {
 // Zero glyph count, nothing to parse.
 if (!glyph_count) {
   return true;
 }

 // Check coverage table.
 if (offset_coverage < sequence_end || offset_coverage >= length) {
   return OTS_FAILURE();
 }
 if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage,
                              length - offset_coverage,
                              num_glyphs, glyph_count)) {
   return OTS_FAILURE();
 }

 // Check sequence of MathGlyphConstruction.
 for (unsigned i = 0; i < glyph_count; ++i) {
     uint16_t offset_glyph_construction = 0;
     if (!subtable->ReadU16(&offset_glyph_construction)) {
       return OTS_FAILURE();
     }
     if (offset_glyph_construction < sequence_end ||
         offset_glyph_construction >= length ||
         !ParseMathGlyphConstructionTable(data + offset_glyph_construction,
                                          length - offset_glyph_construction,
                                          num_glyphs)) {
       return OTS_FAILURE();
     }
 }

 return true;
}

bool OpenTypeMATH::ParseMathVariantsTable(const uint8_t *data,
                                         size_t length,
                                         const uint16_t num_glyphs) {
 ots::Buffer subtable(data, length);

 // Check the header.
 uint16_t offset_vert_glyph_coverage = 0;
 uint16_t offset_horiz_glyph_coverage = 0;
 uint16_t vert_glyph_count = 0;
 uint16_t horiz_glyph_count = 0;
 if (!subtable.Skip(2) ||  // MinConnectorOverlap
     !subtable.ReadU16(&offset_vert_glyph_coverage) ||
     !subtable.ReadU16(&offset_horiz_glyph_coverage) ||
     !subtable.ReadU16(&vert_glyph_count) ||
     !subtable.ReadU16(&horiz_glyph_count)) {
   return OTS_FAILURE();
 }

 const unsigned sequence_end = 5 * 2 + vert_glyph_count * 2 +
   horiz_glyph_count * 2;
 if (sequence_end > std::numeric_limits<uint16_t>::max()) {
   return OTS_FAILURE();
 }

 if (!ParseMathGlyphConstructionSequence(&subtable, data, length, num_glyphs,
                                         offset_vert_glyph_coverage,
                                         vert_glyph_count,
                                         sequence_end) ||
     !ParseMathGlyphConstructionSequence(&subtable, data, length, num_glyphs,
                                         offset_horiz_glyph_coverage,
                                         horiz_glyph_count,
                                         sequence_end)) {
   return OTS_FAILURE();
 }

 return true;
}

bool OpenTypeMATH::Parse(const uint8_t *data, size_t length) {
 // Grab the number of glyphs in the font from the maxp table to check
 // GlyphIDs in MATH table.
 OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
     GetFont()->GetTypedTable(OTS_TAG_MAXP));
 if (!maxp) {
   return Error("Required maxp table missing");
 }
 const uint16_t num_glyphs = maxp->num_glyphs;

 Buffer table(data, length);

 uint32_t version = 0;
 if (!table.ReadU32(&version)) {
   return OTS_FAILURE();
 }
 if (version != 0x00010000) {
   return Drop("bad MATH version");
 }

 uint16_t offset_math_constants = 0;
 uint16_t offset_math_glyph_info = 0;
 uint16_t offset_math_variants = 0;
 if (!table.ReadU16(&offset_math_constants) ||
     !table.ReadU16(&offset_math_glyph_info) ||
     !table.ReadU16(&offset_math_variants)) {
   return OTS_FAILURE();
 }

 if (offset_math_constants >= length ||
     offset_math_constants < kMathHeaderSize ||
     offset_math_glyph_info >= length ||
     offset_math_glyph_info < kMathHeaderSize ||
     offset_math_variants >= length ||
     offset_math_variants < kMathHeaderSize) {
   return Drop("bad offset in MATH header");
 }

 if (!ParseMathConstantsTable(data + offset_math_constants,
                              length - offset_math_constants)) {
   return Drop("failed to parse MathConstants table");
 }
 if (!ParseMathGlyphInfoTable(data + offset_math_glyph_info,
                              length - offset_math_glyph_info, num_glyphs)) {
   return Drop("failed to parse MathGlyphInfo table");
 }
 if (!ParseMathVariantsTable(data + offset_math_variants,
                             length - offset_math_variants, num_glyphs)) {
   return Drop("failed to parse MathVariants table");
 }

 this->m_data = data;
 this->m_length = length;
 return true;
}

bool OpenTypeMATH::Serialize(OTSStream *out) {
 if (!out->Write(this->m_data, this->m_length)) {
   return OTS_FAILURE();
 }

 return true;
}

bool OpenTypeMATH::ShouldSerialize() {
 return Table::ShouldSerialize() && this->m_data != NULL;
}

}  // namespace ots