/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "FontCreator.h"

#include <array>
#include <cassert>
#include <string>

static const size_t headerSize = 12;
static const size_t directoryEntrySize = 16;
static const int16_t unitsPerEm = 1024;
static const uint16_t numGlyphs = 26 * 2 + 1;

static inline uint16_t integralLog2(uint16_t x)
{
    uint16_t result = 0;
    while (x >>= 1)
        ++result;
    return result;
}

static inline uint16_t roundDownToPowerOfTwo(uint16_t x)
{
    x |= x >> 1;
    x |= x >> 2;
    x |= x >> 4;
    x |= x >> 8;
    return (x >> 1) + 1;
}

static inline bool isFourByteAligned(size_t x)
{
    return !(x & 3);
}

// Assumption: T2 can hold every value that a T1 can hold.
template<typename T1, typename T2> static inline T1 clampTo(T2 x)
{
    x = std::min(x, static_cast<T2>(std::numeric_limits<T1>::max()));
    x = std::max(x, static_cast<T2>(std::numeric_limits<T1>::min()));
    return static_cast<T1>(x);
}

template <typename V>
static inline void append32(V& result, uint32_t value)
{
    result.push_back(value >> 24);
    result.push_back(value >> 16);
    result.push_back(value >> 8);
    result.push_back(value);
}

template <typename V>
static void writeCFFEncodedNumber(V& vector, float number)
{
    vector.push_back(0xFF);
    // Convert to 16.16 fixed-point
    append32(vector, clampTo<int32_t>(number * 0x10000));
}

static const char rLineTo = 0x05;
static const char endChar = 0x0e;
static const char rMoveTo = 0x15;

class CFFBuilder {
public:
    CFFBuilder(float width, std::pair<float, float> origin)
    {
        writeCFFEncodedNumber(result, width);
        writeCFFEncodedNumber(result, origin.first);
        writeCFFEncodedNumber(result, origin.second);
        result.push_back(rMoveTo);
    }

    std::vector<uint8_t> takeResult()
    {
        result.push_back(endChar);
        return std::move(result);
    }

    void moveTo(std::pair<float, float> targetPoint)
    {
        writePoint(targetPoint);
        result.push_back(rMoveTo);

        startingPoint = current;
    }

    void lineTo(std::pair<float, float> targetPoint)
    {
        writePoint(targetPoint);
        result.push_back(rLineTo);
    }

    void closePath()
    {
        if (current != startingPoint)
            lineTo(startingPoint);
    }

private:
    void writePoint(std::pair<float, float> destination)
    {
        std::pair<float, float> delta = std::make_pair(destination.first - current.first, destination.second - current.second);
        writeCFFEncodedNumber(result, delta.first);
        writeCFFEncodedNumber(result, delta.second);

        current = destination;
    }

    std::vector<uint8_t> result;
    std::pair<float, float> startingPoint;
    std::pair<float, float> current;
};

class GLYFBuilder {
public:
    GLYFBuilder(float, std::pair<float, float>)
    {
    }

    std::vector<uint8_t> takeResult()
    {
        std::vector<uint8_t> result;
        append16(result, endPtsOfContours.size());
        append16(result, clampTo<int16_t>(minX));
        append16(result, clampTo<int16_t>(minY));
        append16(result, clampTo<int16_t>(maxX));
        append16(result, clampTo<int16_t>(maxY));

        for (uint16_t p : endPtsOfContours)
            append16(result, p);
        append16(result, 0);
        for (uint8_t f : flags)
            result.push_back(f);
        for (uint16_t c : xCoordinates)
            append16(result, c);
        for (uint16_t c : yCoordinates)
            append16(result, c);

        return result;
    }

    void moveTo(std::pair<float, float> targetPoint)
    {
        writePoint(targetPoint, true);

        startingPoint = current;
    }

    void lineTo(std::pair<float, float> targetPoint)
    {
        writePoint(targetPoint, true);
    }

    void closePath()
    {
        if (current != startingPoint)
            lineTo(startingPoint);
        endPtsOfContours.push_back(pointCount - 1);
    }

private:
    void writePoint(std::pair<float, float> destination, bool onCurve)
    {
        flags.push_back(onCurve ? 1 : 0); // Flags

        std::pair<float, float> delta = std::make_pair(destination.first - current.first, destination.second - current.second);
        xCoordinates.push_back(delta.first);
        yCoordinates.push_back(delta.second);

        current = destination;
        minX = std::min(minX, destination.first);
        maxX = std::max(maxX, destination.first);
        minY = std::min(minY, destination.second);
        maxY = std::max(maxY, destination.second);
        ++pointCount;
    }

    static void append16(std::vector<uint8_t>& destination, uint16_t value)
    {
        destination.push_back(value >> 8);
        destination.push_back(value);
    }

    std::vector<uint16_t> endPtsOfContours;
    std::vector<uint8_t> flags;
    std::vector<int16_t> xCoordinates;
    std::vector<int16_t> yCoordinates;
    std::pair<float, float> startingPoint;
    std::pair<float, float> current;
    float minX { std::numeric_limits<float>::max() };
    float maxX { std::numeric_limits<float>::min() };
    float minY { std::numeric_limits<float>::max() };
    float maxY { std::numeric_limits<float>::min() };
    unsigned pointCount { 0 };
};

template <typename T>
std::vector<uint8_t> generateBoxCharString()
{
    T builder(unitsPerEm, std::make_pair(0.f, 0.f));
    builder.moveTo(std::make_pair(200.f, 200.f));
    builder.lineTo(std::make_pair(200.f, 800.f));
    builder.lineTo(std::make_pair(800.f, 800.f));
    builder.lineTo(std::make_pair(800.f, 200.f));
    builder.closePath();
    return builder.takeResult();
}

template <typename T>
std::vector<uint8_t> generateCheckCharString()
{
    T builder(unitsPerEm, std::make_pair(0.f, 0.f));
    builder.moveTo(std::make_pair(200.f, 500.f));
    builder.lineTo(std::make_pair(250.f, 550.f));
    builder.lineTo(std::make_pair(500.f, 300.f));
    builder.lineTo(std::make_pair(900.f, 700.f));
    builder.lineTo(std::make_pair(950.f, 650.f));
    builder.lineTo(std::make_pair(500.f, 200.f));
    builder.closePath();
    return builder.takeResult();
}

template <typename T>
std::vector<uint8_t> generateXCharString()
{
    T builder(unitsPerEm, std::make_pair(0.f, 0.f));
    builder.moveTo(std::make_pair(500.0f, 550.0f));
    builder.lineTo(std::make_pair(900.f, 950.f));
    builder.lineTo(std::make_pair(950.f, 900.f));
    builder.lineTo(std::make_pair(550.f, 500.f));
    builder.lineTo(std::make_pair(950.f, 100.f));
    builder.lineTo(std::make_pair(900.f,  50.f));
    builder.lineTo(std::make_pair(500.f, 450.f));
    builder.lineTo(std::make_pair(100.f,  50.f));
    builder.lineTo(std::make_pair(50.f , 100.f));
    builder.lineTo(std::make_pair(450.f, 500.f));
    builder.lineTo(std::make_pair(50.f , 900.f));
    builder.lineTo(std::make_pair(100.f, 950.f));
    builder.closePath();
    return builder.takeResult();
}

template<typename T>
const T& itemForGlyph(uint16_t glyph, const T& boxCharString, const T& checkCharString, const T& xCharString)
{
    if (!glyph)
        return boxCharString;
    if (glyph == 1)
        return checkCharString;
    return xCharString;
}

struct FeatureSelector {
    uint16_t selector;
    std::string name;
    uint16_t stringIndex;
    bool defaultSelector;
};

struct FeatureType {
    uint16_t type;
    std::string name;
    uint16_t stringIndex;
    size_t settingTableOffsetLocation;
    std::vector<FeatureSelector> selectors;
    bool exclusive;
};

class Generator {
public:
    std::vector<uint8_t> generate(Type type)
    {
        if (type == Type::OpenType)
            name = "FontWithFeaturesOTF";
        else
            name = "FontWithFeaturesTTF";

        featureDescription = generateFeatureDescription();

        uint16_t numTables = type == Type::OpenType ? 10 : 12;
        uint16_t roundedNumTables = roundDownToPowerOfTwo(numTables);
        uint16_t searchRange = roundedNumTables * 16; // searchRange: "(Maximum power of 2 <= numTables) x 16."

        if (type == Type::OpenType) {
            result.push_back('O');
            result.push_back('T');
            result.push_back('T');
            result.push_back('O');
        } else {
            result.push_back('t');
            result.push_back('r');
            result.push_back('u');
            result.push_back('e');
        }
        append16(numTables);
        append16(searchRange);
        append16(integralLog2(roundedNumTables)); // entrySelector: "Log2(maximum power of 2 <= numTables)."
        append16(numTables * 16 - searchRange); // rangeShift: "NumTables x 16-searchRange."

        assert(result.size() == headerSize);

        // Leave space for the directory entries.
        for (size_t i = 0; i < directoryEntrySize * numTables; ++i)
            result.push_back(0);

        if (type == Type::OpenType) {
            appendTable("CFF ", &Generator::appendCFFTable);
            appendTable("GSUB", &Generator::appendGSUBTable);
        }
        appendTable("OS/2", &Generator::appendOS2Table);
        appendTable("cmap", &Generator::appendCMAPTable);
        if (type == Type::TrueType) {
            appendTable("feat", &Generator::appendFEATTable);
            appendTable("glyf", &Generator::appendGLYFTable);
        }
        auto headTableOffset = result.size();
        appendTable("head", &Generator::appendHEADTable);
        appendTable("hhea", &Generator::appendHHEATable);
        appendTable("hmtx", &Generator::appendHMTXTable);
        if (type == Type::TrueType)
            appendTable("loca", &Generator::appendLOCATable);
        appendTable("maxp", &Generator::appendMAXPTable);
        if (type == Type::TrueType)
            appendTable("morx", &Generator::appendMORXTable);
        appendTable("name", &Generator::appendNAMETable);
        appendTable("post", &Generator::appendPOSTTable);

        assert(numTables == m_tablesAppendedCount);

        // checksumAdjustment: "To compute: set it to 0, calculate the checksum for the 'head' table and put it in the table directory,
        // sum the entire font as uint32, then store B1B0AFBA - sum. The checksum for the 'head' table will now be wrong. That is OK."
        overwrite32(headTableOffset + 8, 0xB1B0AFBAU - calculateChecksum(0, result.size()));

        return std::move(result);
    }

private:
    class Placeholder {
    public:
        Placeholder(Generator& generator, size_t baseOfOffset)
            : generator(generator)
            , baseOfOffset(baseOfOffset)
            , location(generator.result.size())
        {
            generator.append16(0);
        }

        Placeholder(Placeholder&& other)
            : generator(other.generator)
            , baseOfOffset(other.baseOfOffset)
            , location(other.location)
            , active(other.active)
        {
            other.active = false;
        }

        void populate()
        {
            assert(active);
            size_t delta = generator.result.size() - baseOfOffset;
            assert(delta < std::numeric_limits<uint16_t>::max());
            generator.overwrite16(location, delta);
            active = false;
        }

        ~Placeholder()
        {
            assert(!active);
        }

    private:
        Generator& generator;
        const size_t baseOfOffset;
        const size_t location;
        bool active { true };
    };

    Placeholder placeholder(size_t baseOfOffset)
    {
        return Placeholder(*this, baseOfOffset);
    }

    void append16(uint16_t value)
    {
        result.push_back(value >> 8);
        result.push_back(value);
    }

    void append32(uint32_t value)
    {
        ::append32(result, value);
    }

    void append32BitCode(const char code[4])
    {
        result.push_back(code[0]);
        result.push_back(code[1]);
        result.push_back(code[2]);
        result.push_back(code[3]);
    }

    void overwrite16(size_t location, uint16_t value)
    {
        assert(result.size() >= location + 2);
        result[location] = value >> 8;
        result[location + 1] = value;
    }

    void overwrite32(size_t location, uint32_t value)
    {
        assert(result.size() >= location + 4);
        result[location] = value >> 24;
        result[location + 1] = value >> 16;
        result[location + 2] = value >> 8;
        result[location + 3] = value;
    }

    void insertSelector(std::vector<FeatureSelector>& selectors, uint16_t selector, std::string selectorString, bool defaultSelector)
    {
        selectors.push_back({selector, selectorString, m_stringIndex++, defaultSelector});
    }

    void insertFeature(std::vector<FeatureType>& result, uint16_t type, std::string typeString, uint16_t selector, std::string selectorString, bool exclusive)
    {
        // O(n) but performance is not an issue here
        for (size_t i = 0; i < result.size(); ++i) {
            if (result[i].type == type) {
                insertSelector(result[i].selectors, selector, selectorString, false);
                return;
            }
        }
        result.push_back({type, typeString, m_stringIndex++, 0, std::vector<FeatureSelector>(), exclusive});
        insertSelector(result[result.size() - 1].selectors, selector, selectorString, true);
    }

    static const uint16_t kCharacterShapeType = 20;
    static const uint16_t kContextualAlternatesType = 36;
    static const uint16_t kFractionsType = 11;
    static const uint16_t kLetterCaseType = 3;
    static const uint16_t kLigaturesType = 1;
    static const uint16_t kLowerCaseType = 37;
    static const uint16_t kNumberCaseType = 21;
    static const uint16_t kNumberSpacingType = 6;
    static const uint16_t kRubyKanaType = 28;
    static const uint16_t kStyleOptionsType = 19;
    static const uint16_t kTextSpacingType = 22;
    static const uint16_t kTypographicExtrasType = 14;
    static const uint16_t kUpperCaseType = 38;
    static const uint16_t kVerticalPositionType = 10;

    static const uint16_t kCommonLigaturesOffSelector = 3;
    static const uint16_t kCommonLigaturesOnSelector = 2;
    static const uint16_t kContextualAlternatesOffSelector = 1;
    static const uint16_t kContextualAlternatesOnSelector = 0;
    static const uint16_t kContextualLigaturesOffSelector = 19;
    static const uint16_t kContextualLigaturesOnSelector = 18;
    static const uint16_t kDiagonalFractionsSelector = 2;
    static const uint16_t kHistoricalLigaturesOffSelector = 21;
    static const uint16_t kHistoricalLigaturesOnSelector = 20;
    static const uint16_t kInferiorsSelector = 2;
    static const uint16_t kJIS1978CharactersSelector = 2;
    static const uint16_t kJIS1983CharactersSelector = 3;
    static const uint16_t kJIS1990CharactersSelector = 4;
    static const uint16_t kJIS2004CharactersSelector = 11;
    static const uint16_t kLowerCaseNumbersSelector = 0;
    static const uint16_t kLowerCasePetiteCapsSelector = 2;
    static const uint16_t kLowerCaseSmallCapsSelector = 1;
    static const uint16_t kMonospacedNumbersSelector = 0;
    static const uint16_t kMonospacedTextSelector = 1;
    static const uint16_t kOrdinalsSelector = 3;
    static const uint16_t kProportionalNumbersSelector = 1;
    static const uint16_t kProportionalTextSelector = 0;
    static const uint16_t kRareLigaturesOffSelector = 5;
    static const uint16_t kRareLigaturesOnSelector = 4;
    static const uint16_t kRubyKanaOnSelector = 2;
    static const uint16_t kRubyKanaSelector = 1;
    static const uint16_t kSimplifiedCharactersSelector = 1;
    static const uint16_t kSlashedZeroOnSelector = 4;
    static const uint16_t kSuperiorsSelector = 1;
    static const uint16_t kTitlingCapsSelector = 4;
    static const uint16_t kTraditionalCharactersSelector = 0;
    static const uint16_t kUpperCaseNumbersSelector = 1;
    static const uint16_t kUpperCasePetiteCapsSelector = 2;
    static const uint16_t kUpperCaseSmallCapsSelector = 1;
    static const uint16_t kVerticalFractionsSelector = 1;

    static const uint16_t defaultUnusedSelector = 99;

    std::vector<FeatureType> generateFeatureDescription()
    {
        std::vector<FeatureType> result;

        // For any given feature type, the first selector inside it is the default selector for that type.
        insertFeature(result, kLigaturesType, "kLigaturesType", kCommonLigaturesOnSelector, "kCommonLigaturesOnSelector", false);
        insertFeature(result, kLigaturesType, "kLigaturesType", kContextualLigaturesOnSelector, "kContextualLigaturesOnSelector", false);
        insertFeature(result, kLigaturesType, "kLigaturesType", kCommonLigaturesOffSelector, "kCommonLigaturesOffSelector", false);
        insertFeature(result, kLigaturesType, "kLigaturesType", kContextualLigaturesOffSelector, "kContextualLigaturesOffSelector", false);
        insertFeature(result, kLigaturesType, "kLigaturesType", kRareLigaturesOnSelector, "kRareLigaturesOnSelector", false);
        insertFeature(result, kLigaturesType, "kLigaturesType", kRareLigaturesOffSelector, "kRareLigaturesOffSelector", false);
        insertFeature(result, kLigaturesType, "kLigaturesType", kHistoricalLigaturesOnSelector, "kHistoricalLigaturesOnSelector", false);
        insertFeature(result, kLigaturesType, "kLigaturesType", kHistoricalLigaturesOffSelector, "kHistoricalLigaturesOffSelector", false);
        insertFeature(result, kContextualAlternatesType, "kContextualAlternatesType", kContextualAlternatesOnSelector, "kContextualAlternatesOnSelector", false);
        insertFeature(result, kContextualAlternatesType, "kContextualAlternatesType", kContextualAlternatesOffSelector, "kContextualAlternatesOffSelector", false);
        insertFeature(result, kVerticalPositionType, "kVerticalPositionType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kVerticalPositionType, "kVerticalPositionType", kInferiorsSelector, "kInferiorsSelector", true);
        insertFeature(result, kVerticalPositionType, "kVerticalPositionType", kSuperiorsSelector, "kSuperiorsSelector", true);
        insertFeature(result, kLowerCaseType, "kLowerCaseType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kUpperCaseType, "kUpperCaseType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kLowerCaseType, "kLowerCaseType", kLowerCaseSmallCapsSelector, "kLowerCaseSmallCapsSelector", true);
        insertFeature(result, kUpperCaseType, "kUpperCaseType", kUpperCaseSmallCapsSelector, "kUpperCaseSmallCapsSelector", true);
        insertFeature(result, kLowerCaseType, "kLowerCaseType", kLowerCasePetiteCapsSelector, "kLowerCasePetiteCapsSelector", true);
        insertFeature(result, kUpperCaseType, "kUpperCaseType", kUpperCasePetiteCapsSelector, "kUpperCasePetiteCapsSelector", true);
        insertFeature(result, kLetterCaseType, "kLetterCaseType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kLetterCaseType, "kLetterCaseType", 14, "14", true);
        insertFeature(result, kStyleOptionsType, "kStyleOptionsType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kStyleOptionsType, "kStyleOptionsType", kTitlingCapsSelector, "kTitlingCapsSelector", true);
        insertFeature(result, kNumberCaseType, "kNumberCaseType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kNumberCaseType, "kNumberCaseType", kUpperCaseNumbersSelector, "kUpperCaseNumbersSelector", true);
        insertFeature(result, kNumberCaseType, "kNumberCaseType", kLowerCaseNumbersSelector, "kLowerCaseNumbersSelector", true);
        insertFeature(result, kNumberSpacingType, "kNumberSpacingType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kNumberSpacingType, "kNumberSpacingType", kProportionalNumbersSelector, "kProportionalNumbersSelector", true);
        insertFeature(result, kNumberSpacingType, "kNumberSpacingType", kMonospacedNumbersSelector, "kMonospacedNumbersSelector", true);
        insertFeature(result, kFractionsType, "kFractionsType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kFractionsType, "kFractionsType", kDiagonalFractionsSelector, "kDiagonalFractionsSelector", true);
        insertFeature(result, kFractionsType, "kFractionsType", kVerticalFractionsSelector, "kVerticalFractionsSelector", true);
        insertFeature(result, kVerticalPositionType, "kVerticalPositionType", kOrdinalsSelector, "kOrdinalsSelector", true);
        insertFeature(result, kTypographicExtrasType, "kTypographicExtrasType", kSlashedZeroOnSelector, "kSlashedZeroOnSelector", false);
        insertFeature(result, kLigaturesType, "kLigaturesType", kHistoricalLigaturesOnSelector, "kHistoricalLigaturesOnSelector", false);
        insertFeature(result, kCharacterShapeType, "kCharacterShapeType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kCharacterShapeType, "kCharacterShapeType", kJIS1978CharactersSelector, "kJIS1978CharactersSelector", true);
        insertFeature(result, kCharacterShapeType, "kCharacterShapeType", kJIS1983CharactersSelector, "kJIS1983CharactersSelector", true);
        insertFeature(result, kCharacterShapeType, "kCharacterShapeType", kJIS1990CharactersSelector, "kJIS1990CharactersSelector", true);
        insertFeature(result, kCharacterShapeType, "kCharacterShapeType", kJIS2004CharactersSelector, "kJIS2004CharactersSelector", true);
        insertFeature(result, kCharacterShapeType, "kCharacterShapeType", kSimplifiedCharactersSelector, "kSimplifiedCharactersSelector", true);
        insertFeature(result, kCharacterShapeType, "kCharacterShapeType", kTraditionalCharactersSelector, "kTraditionalCharactersSelector", true);
        insertFeature(result, kTextSpacingType, "kTextSpacingType", defaultUnusedSelector, "defaultUnusedSelector", true);
        insertFeature(result, kTextSpacingType, "kTextSpacingType", kMonospacedTextSelector, "kMonospacedTextSelector", true);
        insertFeature(result, kTextSpacingType, "kTextSpacingType", kProportionalTextSelector, "kProportionalTextSelector", true);
        insertFeature(result, kRubyKanaType, "kRubyKanaType", kRubyKanaOnSelector, "kRubyKanaOnSelector", false);

        return result;
    }
    
    void appendCFFTable()
    {
        auto startingOffset = result.size();

        // Header
        result.push_back(1); // Major version
        result.push_back(0); // Minor version
        result.push_back(4); // Header size
        result.push_back(4); // Offsets within CFF table are 4 bytes long

        // Name INDEX
        std::string fontName = name;
        append16(1); // INDEX contains 1 element
        result.push_back(4); // Offsets in this INDEX are 4 bytes long
        append32(1); // 1-index offset of name data
        append32(static_cast<uint32_t>(fontName.length() + 1)); // 1-index offset just past end of name data
        for (char c : fontName)
            result.push_back(c);

        const char operand32Bit = 29;
        const char fullNameKey = 2;
        const char familyNameKey = 3;
        const char fontBBoxKey = 5;
        const char charsetIndexKey = 15;
        const char charstringsIndexKey = 17;
        const char privateDictIndexKey = 18;
        const uint32_t userDefinedStringStartIndex = 391;
        const unsigned sizeOfTopIndex = 56;

        // Top DICT INDEX.
        append16(1); // INDEX contains 1 element
        result.push_back(4); // Offsets in this INDEX are 4 bytes long
        append32(1); // 1-index offset of DICT data
        append32(1 + sizeOfTopIndex); // 1-index offset just past end of DICT data

        // DICT information
        size_t topDictStart = result.size();
        result.push_back(operand32Bit);
        append32(userDefinedStringStartIndex);
        result.push_back(fullNameKey);
        result.push_back(operand32Bit);
        append32(userDefinedStringStartIndex);
        result.push_back(familyNameKey);
        result.push_back(operand32Bit);
        append32(clampTo<int32_t>(0)); // Bounding box x
        result.push_back(operand32Bit);
        append32(clampTo<int32_t>(-1)); // Bounding box y
        result.push_back(operand32Bit);
        append32(clampTo<int32_t>(unitsPerEm)); // Bounding box max x
        result.push_back(operand32Bit);
        append32(clampTo<int32_t>(unitsPerEm)); // Bounding box max y
        result.push_back(fontBBoxKey);
        result.push_back(operand32Bit);
        size_t charsetOffsetLocation = result.size();
        append32(0); // Offset of Charset info. Will be overwritten later.
        result.push_back(charsetIndexKey);
        result.push_back(operand32Bit);
        size_t charstringsOffsetLocation = result.size();
        append32(0); // Offset of CharStrings INDEX. Will be overwritten later.
        result.push_back(charstringsIndexKey);
        result.push_back(operand32Bit);
        append32(0); // 0-sized private dict
        result.push_back(operand32Bit);
        append32(0); // no location for private dict
        result.push_back(privateDictIndexKey); // Private dict size and offset
        assert(result.size() == topDictStart + sizeOfTopIndex);

        // String INDEX
        append16(1); // Number of elements in INDEX
        result.push_back(4); // Offsets in this INDEX are 4 bytes long
        uint32_t offset = 1;
        append32(offset);
        offset += fontName.length();
        append32(offset);
        for (char c : fontName)
            result.push_back(c);

        append16(0); // Empty subroutine INDEX
    
        // Charset info
        overwrite32(charsetOffsetLocation, static_cast<uint32_t>(result.size() - startingOffset));
        result.push_back(0);
        for (int i = 1; i < numGlyphs; ++i)
            append16(i);

        // CharStrings INDEX
        std::vector<uint8_t> boxCharString = generateBoxCharString<CFFBuilder>();
        std::vector<uint8_t> checkCharString = generateCheckCharString<CFFBuilder>();
        std::vector<uint8_t> xCharString = generateXCharString<CFFBuilder>();
        assert(numGlyphs > 26);
        overwrite32(charstringsOffsetLocation, static_cast<uint32_t>(result.size() - startingOffset));
        append16(numGlyphs);
        result.push_back(4); // Offsets in this INDEX are 4 bytes long
        offset = 1;
        append32(offset);
        for (uint16_t glyph = 0; glyph < numGlyphs; ++glyph) {
            offset += itemForGlyph(glyph, boxCharString, checkCharString, xCharString).size();
            append32(offset);
        }
        for (uint16_t glyph = 0; glyph < numGlyphs; ++glyph) {
            const std::vector<uint8_t>& charString = itemForGlyph(glyph, boxCharString, checkCharString, xCharString);
            result.insert(result.end(), charString.begin(), charString.end());
        }
    }

    // Keep in sync with loca
    void appendGLYFTable()
    {
        std::vector<uint8_t> boxCharString = generateBoxCharString<GLYFBuilder>();
        std::vector<uint8_t> checkCharString = generateCheckCharString<GLYFBuilder>();
        std::vector<uint8_t> xCharString = generateXCharString<GLYFBuilder>();
        for (uint16_t glyph = 0; glyph < numGlyphs; ++glyph) {
            const std::vector<uint8_t>& charString = itemForGlyph(glyph, boxCharString, checkCharString, xCharString);
            result.insert(result.end(), charString.begin(), charString.end());
        }
    }

    // Keep in sync with glyf
    void appendLOCATable()
    {
        std::vector<uint8_t> boxCharString = generateBoxCharString<GLYFBuilder>();
        std::vector<uint8_t> checkCharString = generateCheckCharString<GLYFBuilder>();
        std::vector<uint8_t> xCharString = generateXCharString<GLYFBuilder>();
        uint32_t index = 0;
        for (uint16_t glyph = 0; glyph < numGlyphs; ++glyph) {
            append32(index);
            index += itemForGlyph(glyph, boxCharString, checkCharString, xCharString).size();
        }
        append32(index);
    }

    void appendFEATTable()
    {
        size_t tableLocation = result.size();
        append32(0x00010000); // Version
        append16(featureDescription.size()); // Number of entries in the feature name array
        append16(0); // reserved
        append32(0); // reserved

        // Feature name array
        for (FeatureType& type : featureDescription) {
            append16(type.type); // Feature type
            append16(type.selectors.size()); // Number of settings
            type.settingTableOffsetLocation = result.size();
            append32(0); // Offset in bytes from beginning of this table to feature's setting name array
            append16(type.exclusive ? 0x8000 : 0); // Flags. 0x8000 = Exclusive
            append16(type.stringIndex + m_baseStringIndex); // Index in the name table for the name of this feature
        }

        // Setting name array
        for (FeatureType& type : featureDescription) {
            overwrite32(type.settingTableOffsetLocation, static_cast<uint32_t>(result.size() - tableLocation));
            for (FeatureSelector& selector : type.selectors) {
                append16(selector.selector); // Setting: kNormalPositionSelector (initial setting is default)
                append16(selector.stringIndex + m_baseStringIndex); // Index in the name table for the name of this setting
            }
        }
    }

    void appendMetamorphosisChain(const FeatureType& type, const FeatureSelector& selector, uint16_t glyphToReplace, uint16_t withMe)
    {
        size_t chainLocation = result.size();
        append32(type.exclusive && selector.defaultSelector ? 1 : 0); // Default flags
        size_t chainSizeLocation = result.size();
        append32(0); // Placeholder for chain length in bytes (padded to multiple of 4)
        append32(2); // Number of feature subtable entries
        append32(1); // Number of subtables in the chain

        // Feature table
        append16(type.type); // Feature type
        append16(selector.selector); // Feature selector
        append32(1); // Enable flags
        append32(0xFFFFFFFF); // disable flags

        // Feature table 2
        append16(0); // Feature type: kAllTypographicFeaturesType
        append16(1); // Feature selector: kAllTypeFeaturesOffSelector
        append32(0); // Enable flags
        append32(0); // disable flags

        // Metamorphosis subtable
        size_t metamorphosisSubtableSizeLocation = result.size();
        append32(0); // Placeholder for chain length in bytes (padded to multiple of 4)
        append32(4); // Coverage flags and subtable type. Subtable type 4: Noncontextual ("swash") subtable
        append32(1); // subFeature flags

        // Non-contextual glyph substitution subtable
        append16(6); // Lookup format: sorted list of (glyph index, lookup value) pairs
        
        // BinSrchHeader
        append16(4); // Size of a lookup unit for this search in bytes
        append16(1); // Number of units to be searched
        append16(4); // Search range: The value of unitSize times the largest power of 2 that is less than or equal to the value of nUnits.
        append16(0); // Entry selector: The log base 2 of the largest power of 2 less than or equal to the value of nUnits.
        append16(0); // Range shift: The value of unitSize times the difference of the value of nUnits minus the largest power of 2 less than or equal to the value of nUnits.
        // Entries
        append16(glyphToReplace);
        append16(withMe);

        overwrite32(metamorphosisSubtableSizeLocation, static_cast<uint32_t>(result.size() - metamorphosisSubtableSizeLocation));

        while (result.size() % 4)
            result.push_back(0);
        overwrite32(chainSizeLocation, static_cast<uint32_t>(result.size() - chainLocation));
    }

    void appendMORXTable()
    {
        append16(2); // Version
        append16(0); // Unused
        size_t numberOfChainsLocation = result.size();
        append32(0); // Number of metamorphosis chains placeholder

        int count = 0;
        for (FeatureType& type : featureDescription) {
            for (FeatureSelector& selector : type.selectors) {
                appendMetamorphosisChain(type, selector, count + 3, 1);
                count++;
            }
        }
    
        overwrite32(numberOfChainsLocation, count);
    }

    void appendSubstitutionSubtable(size_t subtableRecordLocation, uint16_t iGetReplaced, uint16_t replacedWithMe)
    {
        overwrite16(subtableRecordLocation + 6, result.size() - subtableRecordLocation);
        auto subtableLocation = result.size();
        append16(2); // Format 2
        append16(0); // Placeholder for offset to coverage table, relative to beginning of substitution table
        append16(1); // GlyphCount
        append16(replacedWithMe); // Substitute with this glyph.

        // Coverage table
        overwrite16(subtableLocation + 2, result.size() - subtableLocation);
        append16(1); // CoverageFormat
        append16(1); // GlyphCount
        append16(iGetReplaced); // This glyph is covered in the coverage.
    }

    void appendScriptSubtable(uint16_t featureCount)
    {
        auto dfltScriptTableLocation = result.size();
        append16(0); // Placeholder for offset of default language system table, relative to beginning of Script table
        append16(0); // Number of following language system tables

        // LangSys table
        overwrite16(dfltScriptTableLocation, result.size() - dfltScriptTableLocation);
        append16(0); // LookupOrder "= NULL ... reserved"
        append16(0xFFFF); // No features are required
        append16(featureCount); // Number of FeatureIndex values
        for (uint16_t i = 0; i < featureCount; ++i)
            append16(i); // Features indices
    }

    struct Feature {
        bool operator<(const Feature& o) const
        {
            return tag < o.tag;
        }

        std::array<char, 5> tag;
        uint16_t glyphToReplace;
    };

    void appendGSUBTable()
    {
        std::vector<Feature> features {{{"liga"}, 3}, {{"clig"}, 4}, {{"dlig"}, 5}, {{"hlig"}, 6}, {{"calt"}, 7}, {{"subs"}, 8}, {{"sups"}, 9}, {{"smcp"}, 10}, {{"c2sc"}, 11}, {{"pcap"}, 12}, {{"c2pc"}, 13}, {{"unic"}, 14}, {{"titl"}, 15}, {{"lnum"}, 16}, {{"onum"}, 17}, {{"pnum"}, 18}, {{"tnum"}, 19}, {{"frac"}, 20}, {{"afrc"}, 21}, {{"ordn"}, 22}, {{"zero"}, 23}, {{"hist"}, 24}, {{"jp78"}, 25}, {{"jp83"}, 26}, {{"jp90"}, 27}, {{"jp04"}, 28}, {{"smpl"}, 29}, {{"trad"}, 30}, {{"fwid"}, 31}, {{"pwid"}, 32}, {{"ruby"}, 33}};
        std::sort(features.begin(), features.end());
        auto tableLocation = result.size();
        auto headerSize = 10;

        append32(0x00010000); // Version
        append16(headerSize); // Offset to ScriptList
        Placeholder toFeatureList = placeholder(tableLocation);
        Placeholder toLookupList = placeholder(tableLocation);
        assert(tableLocation + headerSize == result.size());

        // ScriptList
        auto scriptListLocation = result.size();
        append16(1); // Number of ScriptRecords
        append32BitCode("DFLT");
        append16(0); // Placeholder for offset of Script table, relative to beginning of ScriptList

        overwrite16(scriptListLocation + 6, result.size() - scriptListLocation);
        appendScriptSubtable(static_cast<uint16_t>(features.size()));

        // FeatureList
        toFeatureList.populate();
        auto featureListLocation = result.size();
        size_t featureListSize = 2 + 6 * features.size();
        size_t featureTableSize = 6;
        append16(features.size()); // FeatureCount
        for (unsigned i = 0; i < features.size(); ++i) {
            auto& code = features[i];
            append32BitCode(code.tag.data()); // Feature name
            append16(featureListSize + featureTableSize * i); // Offset of feature table, relative to beginning of FeatureList table
        }
        assert(featureListLocation + featureListSize == result.size());

        for (unsigned i = 0; i < features.size(); ++i) {
            auto featureTableStart = result.size();
            append16(0); // FeatureParams "= NULL ... reserved"
            append16(1); // LookupCount
            append16(i); // LookupListIndex
            assert(featureTableStart + featureTableSize == result.size());
        }

        // LookupList
        toLookupList.populate();
        auto lookupListLocation = result.size();
        append16(features.size()); // LookupCount
        for (unsigned i = 0; i < features.size(); ++i)
            append16(0); // Placeholder for offset to lookup table, relative to beginning of LookupList
        size_t subtableRecordLocations[features.size()];
        for (unsigned i = 0; i < features.size(); ++i) {
            subtableRecordLocations[i] = result.size();
            overwrite16(lookupListLocation + 2 + 2 * i, result.size() - lookupListLocation);
            append16(1); // Type 1: "Replace one glyph with one glyph"
            append16(0); // LookupFlag
            append16(1); // SubTableCount
            append16(0); // Placeholder for offset to subtable, relative to beginning of Lookup table
        }

        for (unsigned i = 0; i < features.size(); ++i)
            appendSubstitutionSubtable(subtableRecordLocations[i], features[i].glyphToReplace, 1);
    }

    void appendOS2Table()
    {
        append16(2); // Version
        append16(clampTo<int16_t>(unitsPerEm)); // Average advance
        append16(clampTo<uint16_t>(500)); // Weight class
        append16(5); // Width class
        append16(0); // Protected font
        // WebKit handles these superscripts and subscripts
        append16(0); // Subscript X Size
        append16(0); // Subscript Y Size
        append16(0); // Subscript X Offset
        append16(0); // Subscript Y Offset
        append16(0); // Superscript X Size
        append16(0); // Superscript Y Size
        append16(0); // Superscript X Offset
        append16(0); // Superscript Y Offset
        append16(0); // Strikeout width
        append16(0); // Strikeout Position
        append16(0); // No classification

        for (int i = 0; i < 10; ++i)
            result.push_back(0);

        for (int i = 0; i < 4; ++i)
            append32(0); // "Bit assignments are pending. Set to 0"
        append32(0x544B4257); // Font Vendor. "WBKT"
        append16(0); // Font Patterns.
        append16(0); // First unicode index
        append16(0xFFFF); // Last unicode index
        append16(clampTo<int16_t>(unitsPerEm)); // Typographical ascender
        append16(clampTo<int16_t>(-1)); // Typographical descender
        append16(clampTo<int16_t>(unitsPerEm / 10)); // Typographical line gap
        append16(clampTo<uint16_t>(unitsPerEm)); // Windows-specific ascent
        append16(clampTo<uint16_t>(0)); // Windows-specific descent
        append32(0xFF10FC07); // Bitmask for supported codepages (Part 1). Report all pages as supported.
        append32(0x0000FFFF); // Bitmask for supported codepages (Part 2). Report all pages as supported.
        append16(clampTo<int16_t>(unitsPerEm / 2)); // x-height
        append16(clampTo<int16_t>(unitsPerEm)); // Cap-height
        append16(0); // Default char
        append16(' '); // Break character
        append16(3); // Maximum context needed to perform font features
        append16(3); // Smallest optical point size
        append16(0xFFFF); // Largest optical point size
    }

    void appendFormat12CMAPTable()
    {
        // Braindead scheme: One segment for each character
        auto subtableLocation = result.size();
        append32(12 << 16); // Format 12
        append32(0); // Placeholder for byte length
        append32(0); // Language independent
        append32(2); //  nGroups
        append32('A'); // startCharCode
        append32('Z'); // endCharCode
        append32(1); // startGlyphCode
        append32('a'); // startCharCode
        append32('z'); // endCharCode
        append32(27); // startGlyphCode
        overwrite32(subtableLocation + 4, static_cast<uint32_t>(result.size() - subtableLocation));
    }

    void appendFormat4CMAPTable()
    {
        auto subtableLocation = result.size();
        append16(4); // Format 4
        append16(0); // Placeholder for length in bytes
        append16(0); // Language independent
        uint16_t segCount = 3;
        append16(clampTo<uint16_t>(2 * segCount)); // segCountX2: "2 x segCount"
        uint16_t originalSearchRange = roundDownToPowerOfTwo(segCount);
        uint16_t searchRange = clampTo<uint16_t>(2 * originalSearchRange); // searchRange: "2 x (2**floor(log2(segCount)))"
        append16(searchRange);
        append16(integralLog2(originalSearchRange)); // entrySelector: "log2(searchRange/2)"
        append16(clampTo<uint16_t>((2 * segCount) - searchRange)); // rangeShift: "2 x segCount - searchRange"

        // Ending character codes
        append16('Z');
        append16('z');
        append16(0xFFFF);

        append16(0); // reserved

        // Starting character codes
        append16('A');
        append16('a');
        append16(0xFFFF);

        // idDelta
        append16(static_cast<uint16_t>(27) - static_cast<uint16_t>('A'));
        append16(static_cast<uint16_t>(1) - static_cast<uint16_t>('a'));
        append16(0x0001);

        // idRangeOffset
        append16(0); // idRangeOffset
        append16(0);
        append16(0);

        // Fonts strive to hold 2^16 glyphs, but with the current encoding scheme, we write 8 bytes per codepoint into this subtable.
        // Because the size of this subtable must be represented as a 16-bit number, we are limiting the number of glyphs we support to 2^13.
        // FIXME: If we hit this limit in the wild, use a more compact encoding scheme for this subtable.
        overwrite16(subtableLocation + 2, clampTo<uint16_t>(result.size() - subtableLocation));
    }
    
    void appendCMAPTable()
    {
        auto startingOffset = result.size();
        append16(0);
        append16(3); // Number of subtables

        append16(0); // Unicode
        append16(3); // Unicode version 2.2+
        append32(28); // Byte offset of subtable

        append16(3); // Microsoft
        append16(1); // Unicode BMP
        auto format4OffsetLocation = result.size();
        append32(0); // Byte offset of subtable

        append16(3); // Microsoft
        append16(10); // Unicode
        append32(28); // Byte offset of subtable

        appendFormat12CMAPTable();
        overwrite32(format4OffsetLocation, static_cast<uint32_t>(result.size() - startingOffset));
        appendFormat4CMAPTable();
    }
    
    void appendHEADTable()
    {
        append32(0x00010000); // Version
        append32(0x00010000); // Revision
        append32(0); // Checksum placeholder; to be overwritten by the caller.
        append32(0x5F0F3CF5); // Magic number.
        append16((1 << 9) | 1);

        append16(unitsPerEm);
        append32(0); // First half of creation date
        append32(0); // Last half of creation date
        append32(0); // First half of modification date
        append32(0); // Last half of modification date
        append16(clampTo<int16_t>(0)); // bounding box x
        append16(clampTo<int16_t>(-1)); // bounding box y
        append16(clampTo<int16_t>(unitsPerEm)); // bounding box max x
        append16(clampTo<int16_t>(unitsPerEm)); // bounding box max y
        append16(0); // Traits
        append16(3); // Smallest readable size in pixels
        append16(0); // Might contain LTR or RTL glyphs
        append16(1); // Long offsets in the 'loca' table.
        append16(0); // Glyph data format
    }
    
    void appendHHEATable()
    {
        append32(0x00010000); // Version
        append16(clampTo<int16_t>(unitsPerEm)); // ascent
        append16(clampTo<int16_t>(-1)); // descent
        // WebKit SVG font rendering has hard coded the line gap to be 1/10th of the font size since 2008 (see r29719).
        append16(clampTo<int16_t>(unitsPerEm / 10)); // line gap
        append16(clampTo<uint16_t>(unitsPerEm)); // advance width max
        append16(clampTo<int16_t>(0)); // Minimum left side bearing
        append16(clampTo<int16_t>(0)); // Minimum right side bearing
        append16(clampTo<int16_t>(unitsPerEm)); // X maximum extent
        // Since WebKit draws the caret and ignores the following values, it doesn't matter what we set them to.
        append16(1); // Vertical caret
        append16(0); // Vertical caret
        append16(0); // "Set value to 0 for non-slanted fonts"
        append32(0); // Reserved
        append32(0); // Reserved
        append16(0); // Current format
        append16(numGlyphs); // Number of advance widths in HMTX table
    }
    
    void appendHMTXTable()
    {
        for (unsigned i = 0; i < numGlyphs; ++i) {
            append16(clampTo<uint16_t>(static_cast<int32_t>(unitsPerEm))); // horizontal advance
            append16(itemForGlyph(i, 200, 200, 50)); // left side bearing
        }
    }
    
    void appendMAXPTable()
    {
        append32(0x00010000); // Version
        append16(numGlyphs); // Number of glyphs
        append16(0xFFFF); // Maximum number of points in non-compound glyph
        append16(0xFFFF); // Maximum number of contours in non-compound glyph
        append16(0xFFFF); // Maximum number of points in compound glyph
        append16(0xFFFF); // Maximum number of contours in compound glyph
        append16(2); // Maximum number of zones
        append16(0); // Maximum number of points used in zone 0
        append16(0); // Maximum number of storage area locations
        append16(0); // Maximum number of function definitions
        append16(0); // Maximum number of instruction definitions
        append16(0); // Maximum stack depth
        append16(0); // Maximum size of instructions
        append16(numGlyphs); // Maximum number of glyphs referenced at top level
        append16(0); // No compound glyphs
    }

    struct NameRecord {
        bool operator<(const NameRecord& o) const
        {
            return nameIdentifier < o.nameIdentifier;
        }

        uint16_t nameIdentifier;
        std::string value;
    };

    void appendNameSubtable(const NameRecord& nameRecord)
    {
        append16(0); // Unicode
        append16(3); // Unicode version 2.0 or later
        append16(0); // Language
        append16(nameRecord.nameIdentifier); // Name identifier
        append16(nameRecord.value.length() * 2); // Code units get 2 bytes each
        append16(m_nameOffset); // Offset into name data
        m_nameOffset += nameRecord.value.size() * 2; // Code units get 2 bytes each
    }

    void append2ByteASCIIString(std::string& s)
    {
        for (auto codeUnit : s)
            append16(codeUnit);
    }

    void appendNAMETable()
    {
        std::string familyName = name; // 1: Font Family
        std::string version = "1.0";

        uint16_t numberOfRecords = m_stringIndex + 6;
        append16(0); // Format selector
        append16(numberOfRecords); // Number of name records in table
        append16(6 + 12 * numberOfRecords); // Offset in bytes to the beginning of name character strings

        std::vector<NameRecord> nameRecords = { { 1, familyName }, { 2, familyName }, { 3, familyName }, { 4, familyName }, { 5, version }, { 6, familyName } };
        for (FeatureType& type : featureDescription) {
            nameRecords.push_back({ static_cast<uint16_t>(m_baseStringIndex + type.stringIndex), type.name });
            for (FeatureSelector& selector : type.selectors)
                nameRecords.push_back({ static_cast<uint16_t>(m_baseStringIndex + selector.stringIndex), selector.name });
        }
        std::sort(nameRecords.begin(), nameRecords.end());

        for (auto& nameRecord : nameRecords)
            appendNameSubtable(nameRecord);

        for (auto& nameRecord : nameRecords)
            append2ByteASCIIString(nameRecord.value);
    }
    
    void appendPOSTTable()
    {
        append32(0x00030000); // Format. Printing is undefined
        append32(0); // Italic angle in degrees
        append16(0); // Underline position
        append16(0); // Underline thickness
        append32(0); // Monospaced
        append32(0); // "Minimum memory usage when a TrueType font is downloaded as a Type 42 font"
        append32(0); // "Maximum memory usage when a TrueType font is downloaded as a Type 42 font"
        append32(0); // "Minimum memory usage when a TrueType font is downloaded as a Type 1 font"
        append32(0); // "Maximum memory usage when a TrueType font is downloaded as a Type 1 font"
    }

    uint32_t calculateChecksum(size_t startingOffset, size_t endingOffset) const
    {
        assert(isFourByteAligned(endingOffset - startingOffset));
        uint32_t sum = 0;
        for (size_t offset = startingOffset; offset < endingOffset; offset += 4) {
            sum += static_cast<unsigned char>(result[offset + 3])
                | (static_cast<unsigned char>(result[offset + 2]) << 8)
                | (static_cast<unsigned char>(result[offset + 1]) << 16)
                | (static_cast<unsigned char>(result[offset]) << 24);
        }
        return sum;
    }

    typedef void (Generator::*FontAppendingFunction)();
    void appendTable(const char identifier[4], FontAppendingFunction appendingFunction)
    {
        size_t offset = result.size();
        assert(isFourByteAligned(offset));
        (this->*appendingFunction)();
        size_t unpaddedSize = result.size() - offset;
        while (!isFourByteAligned(result.size()))
            result.push_back(0);
        assert(isFourByteAligned(result.size()));
        size_t directoryEntryOffset = headerSize + m_tablesAppendedCount * directoryEntrySize;
        result[directoryEntryOffset] = identifier[0];
        result[directoryEntryOffset + 1] = identifier[1];
        result[directoryEntryOffset + 2] = identifier[2];
        result[directoryEntryOffset + 3] = identifier[3];
        overwrite32(directoryEntryOffset + 4, calculateChecksum(offset, result.size()));
        overwrite32(directoryEntryOffset + 8, static_cast<uint32_t>(offset));
        overwrite32(directoryEntryOffset + 12, static_cast<uint32_t>(unpaddedSize));
        ++m_tablesAppendedCount;
    }

    unsigned m_tablesAppendedCount { 0 };
    unsigned m_nameOffset { 0 };
    static constexpr uint16_t m_baseStringIndex { 257 };
    uint16_t m_stringIndex { 0 };
    std::vector<FeatureType> featureDescription;
    std::vector<uint8_t> result;
    std::string name;
};

std::vector<uint8_t> generateFont(Type type)
{
    return Generator().generate(type);
}