Source code
Revision control
Copy as Markdown
Other Tools
// Copyright (c) 2009-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.
#include "glyf.h"
#include <algorithm>
#include <limits>
#include "head.h"
#include "loca.h"
#include "maxp.h"
#include "name.h"
// glyf - Glyph Data
#define TABLE_NAME "glyf"
namespace ots {
bool OpenTypeGLYF::ParseFlagsForSimpleGlyph(Buffer &glyph,
uint32_t num_flags,
std::vector<uint8_t>& flags,
uint32_t *flag_index,
uint32_t *coordinates_length) {
uint8_t flag = 0;
if (!glyph.ReadU8(&flag)) {
return Error("Can't read flag");
}
uint32_t delta = 0;
if (flag & (1u << 1)) { // x-Short
++delta;
} else if (!(flag & (1u << 4))) {
delta += 2;
}
if (flag & (1u << 2)) { // y-Short
++delta;
} else if (!(flag & (1u << 5))) {
delta += 2;
}
/* MS and Apple specs say this bit is reserved and must be set to zero, but
* Apple spec then contradicts itself and says it should be set on the first
* contour flag for simple glyphs with overlapping contours:
* (“Overlapping contours” section) */
if (flag & (1u << 6) && *flag_index != 0) {
return Error("Bad glyph flag (%d), "
"bit 6 must be set to zero for flag %d", flag, *flag_index);
}
flags[*flag_index] = flag & ~(1u << 3);
if (flag & (1u << 3)) { // repeat
if (*flag_index + 1 >= num_flags) {
return Error("Count too high (%d + 1 >= %d)", *flag_index, num_flags);
}
uint8_t repeat = 0;
if (!glyph.ReadU8(&repeat)) {
return Error("Can't read repeat value");
}
if (repeat == 0) {
return Error("Zero repeat");
}
delta += (delta * repeat);
if (*flag_index + repeat >= num_flags) {
return Error("Count too high (%d >= %d)", *flag_index + repeat, num_flags);
}
while (repeat--) {
flags[++*flag_index] = flag & ~(1u << 3);
}
}
if (flag & (1u << 7)) { // reserved flag
return Error("Bad glyph flag (%d), reserved bit 7 must be set to zero", flag);
}
*coordinates_length += delta;
if (glyph.length() < *coordinates_length) {
return Error("Glyph coordinates length bigger than glyph length (%d > %d)",
*coordinates_length, glyph.length());
}
return true;
}
#define X_SHORT_VECTOR (1u << 1)
#define Y_SHORT_VECTOR (1u << 2)
#define X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR (1u << 4)
#define Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR (1u << 5)
bool OpenTypeGLYF::ParseSimpleGlyph(Buffer &glyph,
unsigned gid,
int16_t num_contours,
int16_t xmin,
int16_t ymin,
int16_t xmax,
int16_t ymax,
bool is_tricky_font) {
// read the end-points array
uint16_t num_flags = 0;
for (int i = 0; i < num_contours; ++i) {
uint16_t tmp_index = 0;
if (!glyph.ReadU16(&tmp_index)) {
return Error("Can't read contour index %d (glyph %u)", i, gid);
}
if (tmp_index == 0xffffu) {
return Error("Bad contour index %d (glyph %u)", i, gid);
}
// check if the indices are monotonically increasing
if (i && (tmp_index + 1 <= num_flags)) {
return Error("Decreasing contour index %d + 1 <= %d (glyph %u)", tmp_index, num_flags, gid);
}
num_flags = tmp_index + 1;
}
if (this->maxp->version_1 &&
num_flags > this->maxp->max_points) {
Warning("Number of contour points exceeds maxp maxPoints, adjusting limit (glyph %u)", gid);
this->maxp->max_points = num_flags;
}
uint16_t bytecode_length = 0;
if (!glyph.ReadU16(&bytecode_length)) {
return Error("Can't read bytecode length");
}
if (this->maxp->version_1 &&
this->maxp->max_size_glyf_instructions < bytecode_length) {
Warning("Bytecode length is bigger than maxp.maxSizeOfInstructions %d: %d (glyph %u)",
this->maxp->max_size_glyf_instructions, bytecode_length, gid);
this->maxp->max_size_glyf_instructions = bytecode_length;
}
if (!glyph.Skip(bytecode_length)) {
return Error("Can't read bytecode of length %d (glyph %u)", bytecode_length, gid);
}
uint32_t coordinates_length = 0;
std::vector<uint8_t> flags(num_flags);
for (uint32_t i = 0; i < num_flags; ++i) {
if (!ParseFlagsForSimpleGlyph(glyph, num_flags, flags, &i, &coordinates_length)) {
return Error("Failed to parse glyph flags %d (glyph %u)", i, gid);
}
}
bool adjusted_bbox = false;
int16_t x = 0, y = 0;
// Read and check x-coords
for (uint32_t i = 0; i < num_flags; ++i) {
uint8_t flag = flags[i];
if (flag & X_SHORT_VECTOR) {
uint8_t dx;
if (!glyph.ReadU8(&dx)) {
return Error("Glyph too short %d (glyph %u)", glyph.length(), gid);
}
if (flag & X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR) {
x += dx;
} else {
x -= dx;
}
} else if (flag & X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR) {
// x remains unchanged
} else {
int16_t dx;
if (!glyph.ReadS16(&dx)) {
return Error("Glyph too short %d (glyph %u)", glyph.length(), gid);
}
x += dx;
}
if (x < xmin) {
xmin = x;
adjusted_bbox = true;
}
if (x > xmax) {
xmax = x;
adjusted_bbox = true;
}
}
// Read and check y-coords
for (uint32_t i = 0; i < num_flags; ++i) {
uint8_t flag = flags[i];
if (flag & Y_SHORT_VECTOR) {
uint8_t dy;
if (!glyph.ReadU8(&dy)) {
return Error("Glyph too short %d (glyph %u)", glyph.length(), gid);
}
if (flag & Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR) {
y += dy;
} else {
y -= dy;
}
} else if (flag & Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR) {
// x remains unchanged
} else {
int16_t dy;
if (!glyph.ReadS16(&dy)) {
return Error("Glyph too short %d (glyph %u)", glyph.length(), gid);
}
y += dy;
}
if (y < ymin) {
ymin = y;
adjusted_bbox = true;
}
if (y > ymax) {
ymax = y;
adjusted_bbox = true;
}
}
if (glyph.remaining() > 3) {
// We allow 0-3 bytes difference since gly_length is 4-bytes aligned,
// zero-padded length.
Warning("Extra bytes at end of the glyph: %d (glyph %u)", glyph.remaining(), gid);
}
if (adjusted_bbox) {
if (is_tricky_font) {
Warning("Glyph bbox was incorrect; NOT adjusting tricky font (glyph %u)", gid);
} else {
Warning("Glyph bbox was incorrect; adjusting (glyph %u)", gid);
// copy the numberOfContours field
this->iov.push_back(std::make_pair(glyph.buffer(), 2));
// output a fixed-up version of the bounding box
uint8_t* fixed_bbox = new uint8_t[8];
replacements.push_back(fixed_bbox);
xmin = ots_htons(xmin);
std::memcpy(fixed_bbox, &xmin, 2);
ymin = ots_htons(ymin);
std::memcpy(fixed_bbox + 2, &ymin, 2);
xmax = ots_htons(xmax);
std::memcpy(fixed_bbox + 4, &xmax, 2);
ymax = ots_htons(ymax);
std::memcpy(fixed_bbox + 6, &ymax, 2);
this->iov.push_back(std::make_pair(fixed_bbox, 8));
// copy the remainder of the glyph data
this->iov.push_back(std::make_pair(glyph.buffer() + 10, glyph.offset() - 10));
return true;
}
}
this->iov.push_back(std::make_pair(glyph.buffer(), glyph.offset()));
return true;
}
#define ARG_1_AND_2_ARE_WORDS (1u << 0)
#define WE_HAVE_A_SCALE (1u << 3)
#define MORE_COMPONENTS (1u << 5)
#define WE_HAVE_AN_X_AND_Y_SCALE (1u << 6)
#define WE_HAVE_A_TWO_BY_TWO (1u << 7)
#define WE_HAVE_INSTRUCTIONS (1u << 8)
bool OpenTypeGLYF::ParseCompositeGlyph(
Buffer &glyph,
unsigned glyph_id,
ComponentPointCount* component_point_count,
unsigned* skip_count) {
uint16_t flags = 0;
uint16_t gid = 0;
enum class edit_t : uint8_t {
skip_bytes, // param is number of bytes to skip from offset
set_flag, // param is flag to be set (in the 16-bit field at offset)
clear_flag, // param is flag to be cleared
};
// List of glyph data edits to be applied: first value is offset in the data,
// second is a pair of <edit-action, param>.
typedef std::pair<unsigned, std::pair<edit_t, unsigned>> edit_rec;
std::vector<edit_rec> edits;
unsigned prev_start = 0;
bool we_have_instructions = false;
do {
unsigned start = glyph.offset();
if (!glyph.ReadU16(&flags) || !glyph.ReadU16(&gid)) {
return Error("Can't read composite glyph flags or glyphIndex");
}
if (gid >= this->maxp->num_glyphs) {
return Error("Invalid glyph id used in composite glyph: %d", gid);
}
if (flags & ARG_1_AND_2_ARE_WORDS) {
int16_t argument1;
int16_t argument2;
if (!glyph.ReadS16(&argument1) || !glyph.ReadS16(&argument2)) {
return Error("Can't read argument1 or argument2");
}
} else {
uint8_t argument1;
uint8_t argument2;
if (!glyph.ReadU8(&argument1) || !glyph.ReadU8(&argument2)) {
return Error("Can't read argument1 or argument2");
}
}
if (flags & WE_HAVE_A_SCALE) {
int16_t scale;
if (!glyph.ReadS16(&scale)) {
return Error("Can't read scale");
}
} else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
int16_t xscale;
int16_t yscale;
if (!glyph.ReadS16(&xscale) || !glyph.ReadS16(&yscale)) {
return Error("Can't read xscale or yscale");
}
} else if (flags & WE_HAVE_A_TWO_BY_TWO) {
int16_t xscale;
int16_t scale01;
int16_t scale10;
int16_t yscale;
if (!glyph.ReadS16(&xscale) ||
!glyph.ReadS16(&scale01) ||
!glyph.ReadS16(&scale10) ||
!glyph.ReadS16(&yscale)) {
return Error("Can't read transform");
}
}
if (this->loca->offsets[gid] == this->loca->offsets[gid + 1]) {
Warning("empty gid %u used as component in glyph %u", gid, glyph_id);
// DirectWrite chokes on composite glyphs that have a completely empty glyph
// To work around this, we attempt to drop empty components.
// But we don't drop the component if it's the only (remaining) one in the composite.
if (prev_start > 0 || (flags & MORE_COMPONENTS)) {
if (!(flags & MORE_COMPONENTS)) {
// We're dropping the last component, so we need to clear the MORE_COMPONENTS flag
// on the previous one.
edits.push_back(edit_rec{prev_start, std::make_pair(edit_t::clear_flag, MORE_COMPONENTS)});
}
// If this component was the first to provide WE_HAVE_INSTRUCTIONS, set it on the previous (if any).
if ((flags & WE_HAVE_INSTRUCTIONS) && !we_have_instructions && prev_start > 0) {
edits.push_back(edit_rec{prev_start, std::make_pair(edit_t::set_flag, WE_HAVE_INSTRUCTIONS)});
}
// Finally, skip the actual bytes of this component.
edits.push_back(edit_rec{start, std::make_pair(edit_t::skip_bytes, glyph.offset() - start)});
}
} else {
// If this is the first component we're keeping, but we already saw WE_HAVE_INSTRUCTIONS
// (on a dropped component), we need to ensure that flag is set here.
if (prev_start == 0 && we_have_instructions && !(flags & WE_HAVE_INSTRUCTIONS)) {
edits.push_back(edit_rec{start, std::make_pair(edit_t::set_flag, WE_HAVE_INSTRUCTIONS)});
}
prev_start = start;
}
we_have_instructions = we_have_instructions || (flags & WE_HAVE_INSTRUCTIONS);
// Push initial components on stack at level 1
// to traverse them in parent function.
component_point_count->gid_stack.push_back({gid, 1});
} while (flags & MORE_COMPONENTS);
// Sort any required edits by offset in the glyph data.
struct {
bool operator() (const edit_rec& a, const edit_rec& b) const {
return a.first < b.first;
}
} cmp;
std::sort(edits.begin(), edits.end(), cmp);
if (we_have_instructions) {
uint16_t bytecode_length;
if (!glyph.ReadU16(&bytecode_length)) {
return Error("Can't read instructions size");
}
if (this->maxp->version_1 &&
this->maxp->max_size_glyf_instructions < bytecode_length) {
Warning("Bytecode length is bigger than maxp.maxSizeOfInstructions "
"%d: %d",
this->maxp->max_size_glyf_instructions, bytecode_length);
this->maxp->max_size_glyf_instructions = bytecode_length;
}
if (!glyph.Skip(bytecode_length)) {
return Error("Can't read bytecode of length %d", bytecode_length);
}
}
// Record the glyph data in this->iov, accounting for any required edits.
*skip_count = 0;
unsigned offset = 0;
while (!edits.empty()) {
auto& edit = edits.front();
// Handle any glyph data between current offset and the next edit position.
if (edit.first > offset) {
this->iov.push_back(std::make_pair(glyph.buffer() + offset, edit.first - offset));
offset = edit.first;
}
// Handle the edit. Note that there may be multiple set_flag/clear_flag edits
// at the same offset, but skip_bytes will never coincide with another edit.
auto& action = edit.second;
switch (action.first) {
case edit_t::set_flag:
case edit_t::clear_flag: {
// Read the existing flags word.
uint16_t flags;
std::memcpy(&flags, glyph.buffer() + offset, 2);
flags = ots_ntohs(flags);
// Apply all flag changes for the current offset.
while (!edits.empty() && edits.front().first == offset) {
auto& e = edits.front();
switch (e.second.first) {
case edit_t::set_flag:
flags |= e.second.second;
break;
case edit_t::clear_flag:
flags &= ~e.second.second;
break;
default:
assert(false);
break;
}
edits.erase(edits.begin());
}
// Record the modified flags word.
flags = ots_htons(flags);
uint8_t* flags_data = new uint8_t[2];
std::memcpy(flags_data, &flags, 2);
replacements.push_back(flags_data);
this->iov.push_back(std::make_pair(flags_data, 2));
offset += 2;
break;
}
case edit_t::skip_bytes:
offset = edit.first + action.second;
*skip_count += action.second;
edits.erase(edits.begin());
break;
default:
assert(false);
break;
}
}
// Handle any remaining glyph data after the last edit.
if (glyph.offset() > offset) {
this->iov.push_back(std::make_pair(glyph.buffer() + offset, glyph.offset() - offset));
}
return true;
}
bool OpenTypeGLYF::Parse(const uint8_t *data, size_t length) {
OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
GetFont()->GetTypedTable(OTS_TAG_MAXP));
OpenTypeLOCA *loca = static_cast<OpenTypeLOCA*>(
GetFont()->GetTypedTable(OTS_TAG_LOCA));
OpenTypeHEAD *head = static_cast<OpenTypeHEAD*>(
GetFont()->GetTypedTable(OTS_TAG_HEAD));
if (!maxp || !loca || !head) {
return Error("Missing maxp or loca or head table needed by glyf table");
}
OpenTypeNAME *name = static_cast<OpenTypeNAME*>(
GetFont()->GetTypedTable(OTS_TAG_NAME));
bool is_tricky = name->IsTrickyFont();
this->loca = loca;
this->maxp = maxp;
const unsigned num_glyphs = maxp->num_glyphs;
std::vector<uint32_t> &offsets = loca->offsets;
if (offsets.size() != num_glyphs + 1) {
return Error("Invalid glyph offsets size %ld != %d", offsets.size(), num_glyphs + 1);
}
std::vector<uint32_t> resulting_offsets(num_glyphs + 1);
uint32_t current_offset = 0;
for (unsigned i = 0; i < num_glyphs; ++i) {
// Used by ParseCompositeGlyph to return the number of bytes being skipped
// in the glyph description, so we can adjust offsets properly.
unsigned skip_count = 0;
Buffer glyph(GetGlyphBufferSection(data, length, offsets, i));
if (!glyph.buffer())
return false;
if (!glyph.length()) {
resulting_offsets[i] = current_offset;
continue;
}
int16_t num_contours, xmin, ymin, xmax, ymax;
if (!glyph.ReadS16(&num_contours) ||
!glyph.ReadS16(&xmin) ||
!glyph.ReadS16(&ymin) ||
!glyph.ReadS16(&xmax) ||
!glyph.ReadS16(&ymax)) {
return Error("Can't read glyph %d header", i);
}
if (num_contours <= -2) {
// -2, -3, -4, ... are reserved for future use.
return Error("Bad number of contours %d in glyph %d", num_contours, i);
}
if ((xmin == 32767) &&
(xmax == -32767) &&
(ymin == 32767) &&
(ymax == -32767)) {
Warning("bad xmin/xmax/ymin/ymax values");
xmin = xmax = ymin = ymax = 0;
}
if (xmin > xmax || ymin > ymax) {
return Error("Bad bounding box values bl=(%d, %d), tr=(%d, %d) in glyph %d", xmin, ymin, xmax, ymax, i);
}
if (num_contours == 0) {
// This is an empty glyph and shouldn’t have any glyph data, but if it
// does we will simply ignore it.
glyph.set_offset(0);
} else if (num_contours > 0) {
if (!ParseSimpleGlyph(glyph, i, num_contours, xmin, ymin, xmax, ymax, is_tricky)) {
return Error("Failed to parse glyph %d", i);
}
} else {
ComponentPointCount component_point_count;
if (!ParseCompositeGlyph(glyph, i, &component_point_count, &skip_count)) {
return Error("Failed to parse glyph %d", i);
}
// Check maxComponentDepth and validate maxComponentPoints.
// ParseCompositeGlyph placed the first set of component glyphs on the
// component_point_count.gid_stack, which we start to process below. If a
// nested glyph is in turn a component glyph, additional glyphs are placed
// on the stack.
while (component_point_count.gid_stack.size()) {
GidAtLevel stack_top_gid = component_point_count.gid_stack.back();
component_point_count.gid_stack.pop_back();
Buffer points_count_glyph(GetGlyphBufferSection(
data,
length,
offsets,
stack_top_gid.gid));
if (!points_count_glyph.buffer())
return false;
if (!points_count_glyph.length())
continue;
if (!TraverseComponentsCountingPoints(points_count_glyph,
i,
stack_top_gid.level,
&component_point_count)) {
return Error("Error validating component points and depth.");
}
if (component_point_count.accumulated_component_points >
std::numeric_limits<uint16_t>::max()) {
return Error("Illegal composite points value "
"exceeding 0xFFFF for base glyph %d.", i);
} else if (this->maxp->version_1 &&
component_point_count.accumulated_component_points >
this->maxp->max_c_points) {
Warning("Number of composite points in glyph %d exceeds "
"maxp maxCompositePoints: %d vs %d, adjusting limit.",
i,
component_point_count.accumulated_component_points,
this->maxp->max_c_points
);
this->maxp->max_c_points =
component_point_count.accumulated_component_points;
}
}
}
size_t new_size = glyph.offset() - skip_count;
resulting_offsets[i] = current_offset;
// glyphs must be four byte aligned
// TODO(yusukes): investigate whether this padding is really necessary.
// Which part of the spec requires this?
const unsigned padding = (4 - (new_size & 3)) % 4;
if (padding) {
this->iov.push_back(std::make_pair(
reinterpret_cast<const uint8_t*>("\x00\x00\x00\x00"),
static_cast<size_t>(padding)));
new_size += padding;
}
current_offset += new_size;
}
resulting_offsets[num_glyphs] = current_offset;
const uint16_t max16 = std::numeric_limits<uint16_t>::max();
if ((*std::max_element(resulting_offsets.begin(),
resulting_offsets.end()) >= (max16 * 2u)) &&
(head->index_to_loc_format != 1)) {
head->index_to_loc_format = 1;
}
loca->offsets = resulting_offsets;
if (this->iov.empty()) {
// As a special case when all glyph in the font are empty, add a zero byte
// to the table, so that we don’t reject it down the way, and to make the
// table work on Windows as well.
static const uint8_t kZero = 0;
this->iov.push_back(std::make_pair(&kZero, 1));
}
return true;
}
bool OpenTypeGLYF::TraverseComponentsCountingPoints(
Buffer &glyph,
uint16_t base_glyph_id,
uint32_t level,
ComponentPointCount* component_point_count) {
int16_t num_contours;
if (!glyph.ReadS16(&num_contours) ||
!glyph.Skip(8)) {
return Error("Can't read glyph header.");
}
if (num_contours <= -2) {
return Error("Bad number of contours %d in glyph.", num_contours);
}
if (num_contours == 0)
return true;
// FontTools counts a component level for each traversed recursion. We start
// counting at level 0. If we reach a level that's deeper than
// maxComponentDepth, we expand maxComponentDepth unless it's larger than
// the maximum possible depth.
if (level > std::numeric_limits<uint16_t>::max()) {
return Error("Illegal component depth exceeding 0xFFFF in base glyph id %d.",
base_glyph_id);
} else if (this->maxp->version_1 &&
level > this->maxp->max_c_depth) {
this->maxp->max_c_depth = level;
Warning("Component depth exceeds maxp maxComponentDepth "
"in glyph %d, adjust limit to %d.",
base_glyph_id, level);
}
if (num_contours > 0) {
uint16_t num_points = 0;
for (int i = 0; i < num_contours; ++i) {
// Simple glyph, add contour points.
uint16_t tmp_index = 0;
if (!glyph.ReadU16(&tmp_index)) {
return Error("Can't read contour index %d", i);
}
num_points = tmp_index + 1;
}
component_point_count->accumulated_component_points += num_points;
return true;
} else {
assert(num_contours == -1);
// Composite glyph, add gid's to stack.
uint16_t flags = 0;
uint16_t gid = 0;
do {
if (!glyph.ReadU16(&flags) || !glyph.ReadU16(&gid)) {
return Error("Can't read composite glyph flags or glyphIndex");
}
size_t skip_bytes = 0;
skip_bytes += flags & ARG_1_AND_2_ARE_WORDS ? 4 : 2;
if (flags & WE_HAVE_A_SCALE) {
skip_bytes += 2;
} else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
skip_bytes += 4;
} else if (flags & WE_HAVE_A_TWO_BY_TWO) {
skip_bytes += 8;
}
if (!glyph.Skip(skip_bytes)) {
return Error("Failed to parse component glyph.");
}
if (gid >= this->maxp->num_glyphs) {
return Error("Invalid glyph id used in composite glyph: %d", gid);
}
component_point_count->gid_stack.push_back({gid, level + 1u});
} while (flags & MORE_COMPONENTS);
return true;
}
}
Buffer OpenTypeGLYF::GetGlyphBufferSection(
const uint8_t *data,
size_t length,
const std::vector<uint32_t>& loca_offsets,
unsigned glyph_id) {
Buffer null_buffer(nullptr, 0);
const unsigned gly_offset = loca_offsets[glyph_id];
// The LOCA parser checks that these values are monotonic
const unsigned gly_length = loca_offsets[glyph_id + 1] - loca_offsets[glyph_id];
if (!gly_length) {
// this glyph has no outline (e.g. the space character)
return Buffer(data + gly_offset, 0);
}
if (gly_offset >= length) {
Error("Glyph %d offset %d too high %ld", glyph_id, gly_offset, length);
return null_buffer;
}
// Since these are unsigned types, the compiler is not allowed to assume
// that they never overflow.
if (gly_offset + gly_length < gly_offset) {
Error("Glyph %d length (%d < 0)!", glyph_id, gly_length);
return null_buffer;
}
if (gly_offset + gly_length > length) {
Error("Glyph %d length %d too high", glyph_id, gly_length);
return null_buffer;
}
return Buffer(data + gly_offset, gly_length);
}
bool OpenTypeGLYF::Serialize(OTSStream *out) {
for (unsigned i = 0; i < this->iov.size(); ++i) {
if (!out->Write(this->iov[i].first, this->iov[i].second)) {
return Error("Failed to write glyph %d", i);
}
}
return true;
}
} // namespace ots
#undef TABLE_NAME