/*

 * Copyright © 2016  Igalia S.L.

 *

 *  This is part of HarfBuzz, a text shaping library.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and its documentation for any purpose, provided that the

 * above copyright notice and the following two paragraphs appear in

 * all copies of this software.

 *

 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR

 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN

 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 *

 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,

 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS

 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO

 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 *

 * Igalia Author(s): Frédéric Wang

 */

#ifndef HB_OT_MATH_TABLE_HH

#define HB_OT_MATH_TABLE_HH

#include "hb-open-type.hh"

#include "hb-ot-layout-common.hh"

#include "hb-ot-math.h"

#include "hb-depend-data.hh"

namespace OT {

struct MathValueRecord

{

  hb_position_t get_x_value (hb_font_t *font, const void *base) const

  { return hb_saturate_add (font->em_scale_x (value), (base+deviceTable).get_x_delta (font)); }

  hb_position_t get_y_value (hb_font_t *font, const void *base) const

  { return hb_saturate_add (font->em_scale_y (value), (base+deviceTable).get_y_delta (font)); }

  MathValueRecord* copy (hb_serialize_context_t *c, const void *base) const

  {

    TRACE_SERIALIZE (this);

    auto *out = c->embed (this);

    if (unlikely (!out)) return_trace (nullptr);

    out->deviceTable.serialize_copy (c, deviceTable, base, 0, hb_serialize_context_t::Head);

    return_trace (out);

  }

  bool sanitize (hb_sanitize_context_t *c, const void *base) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) && deviceTable.sanitize (c, base));

  }

  protected:

  HBINT16   value;    /* The X or Y value in design units */

  Offset16To<Device>  deviceTable;  /* Offset to the device table - from the

           * beginning of parent table.  May be NULL.

           * Suggested format for device table is 1. */

  public:

  DEFINE_SIZE_STATIC (4);

};

struct MathConstants

{

  friend struct MATH;

  MathConstants* copy (hb_serialize_context_t *c) const

  {

    TRACE_SERIALIZE (this);

    auto *out = c->start_embed (this);

    HBINT16 *p = c->allocate_size<HBINT16> (HBINT16::static_size * 2);

    if (unlikely (!p)) return_trace (nullptr);

    hb_memcpy (p, percentScaleDown, HBINT16::static_size * 2);

    HBUINT16 *m = c->allocate_size<HBUINT16> (HBUINT16::static_size * 2);

    if (unlikely (!m)) return_trace (nullptr);

    hb_memcpy (m, minHeight, HBUINT16::static_size * 2);

    unsigned count = ARRAY_LENGTH (mathValueRecords);

    for (unsigned i = 0; i < count; i++)

      if (!c->copy (mathValueRecords[i], this))

        return_trace (nullptr);

    if (!c->embed (radicalDegreeBottomRaisePercent)) return_trace (nullptr);

    return_trace (out);

  }

  bool sanitize_math_value_records (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    unsigned int count = ARRAY_LENGTH (mathValueRecords);

    for (unsigned int i = 0; i < count; i++)

      if (!mathValueRecords[i].sanitize (c, this))

  return_trace (false);

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) && sanitize_math_value_records (c));

  }

  hb_position_t get_value (hb_ot_math_constant_t constant,

         hb_font_t *font) const

  {

    switch (constant) {

    case HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN:

    case HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN:

      return percentScaleDown[constant - HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN];

    case HB_OT_MATH_CONSTANT_DELIMITED_SUB_FORMULA_MIN_HEIGHT:

    case HB_OT_MATH_CONSTANT_DISPLAY_OPERATOR_MIN_HEIGHT:

      return font->em_scale_y (minHeight[constant - HB_OT_MATH_CONSTANT_DELIMITED_SUB_FORMULA_MIN_HEIGHT]);

    case HB_OT_MATH_CONSTANT_RADICAL_KERN_AFTER_DEGREE:

    case HB_OT_MATH_CONSTANT_RADICAL_KERN_BEFORE_DEGREE:

    case HB_OT_MATH_CONSTANT_SKEWED_FRACTION_HORIZONTAL_GAP:

    case HB_OT_MATH_CONSTANT_SPACE_AFTER_SCRIPT:

      return mathValueRecords[constant - HB_OT_MATH_CONSTANT_MATH_LEADING].get_x_value (font, this);

    case HB_OT_MATH_CONSTANT_ACCENT_BASE_HEIGHT:

    case HB_OT_MATH_CONSTANT_AXIS_HEIGHT:

    case HB_OT_MATH_CONSTANT_FLATTENED_ACCENT_BASE_HEIGHT:

    case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_DISPLAY_STYLE_SHIFT_DOWN:

    case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_GAP_MIN:

    case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_SHIFT_DOWN:

    case HB_OT_MATH_CONSTANT_FRACTION_DENOM_DISPLAY_STYLE_GAP_MIN:

    case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_DISPLAY_STYLE_SHIFT_UP:

    case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_GAP_MIN:

    case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_SHIFT_UP:

    case HB_OT_MATH_CONSTANT_FRACTION_NUM_DISPLAY_STYLE_GAP_MIN:

    case HB_OT_MATH_CONSTANT_FRACTION_RULE_THICKNESS:

    case HB_OT_MATH_CONSTANT_LOWER_LIMIT_BASELINE_DROP_MIN:

    case HB_OT_MATH_CONSTANT_LOWER_LIMIT_GAP_MIN:

    case HB_OT_MATH_CONSTANT_MATH_LEADING:

    case HB_OT_MATH_CONSTANT_OVERBAR_EXTRA_ASCENDER:

    case HB_OT_MATH_CONSTANT_OVERBAR_RULE_THICKNESS:

    case HB_OT_MATH_CONSTANT_OVERBAR_VERTICAL_GAP:

    case HB_OT_MATH_CONSTANT_RADICAL_DISPLAY_STYLE_VERTICAL_GAP:

    case HB_OT_MATH_CONSTANT_RADICAL_EXTRA_ASCENDER:

    case HB_OT_MATH_CONSTANT_RADICAL_RULE_THICKNESS:

    case HB_OT_MATH_CONSTANT_RADICAL_VERTICAL_GAP:

    case HB_OT_MATH_CONSTANT_SKEWED_FRACTION_VERTICAL_GAP:

    case HB_OT_MATH_CONSTANT_STACK_BOTTOM_DISPLAY_STYLE_SHIFT_DOWN:

    case HB_OT_MATH_CONSTANT_STACK_BOTTOM_SHIFT_DOWN:

    case HB_OT_MATH_CONSTANT_STACK_DISPLAY_STYLE_GAP_MIN:

    case HB_OT_MATH_CONSTANT_STACK_GAP_MIN:

    case HB_OT_MATH_CONSTANT_STACK_TOP_DISPLAY_STYLE_SHIFT_UP:

    case HB_OT_MATH_CONSTANT_STACK_TOP_SHIFT_UP:

    case HB_OT_MATH_CONSTANT_STRETCH_STACK_BOTTOM_SHIFT_DOWN:

    case HB_OT_MATH_CONSTANT_STRETCH_STACK_GAP_ABOVE_MIN:

    case HB_OT_MATH_CONSTANT_STRETCH_STACK_GAP_BELOW_MIN:

    case HB_OT_MATH_CONSTANT_STRETCH_STACK_TOP_SHIFT_UP:

    case HB_OT_MATH_CONSTANT_SUBSCRIPT_BASELINE_DROP_MIN:

    case HB_OT_MATH_CONSTANT_SUBSCRIPT_SHIFT_DOWN:

    case HB_OT_MATH_CONSTANT_SUBSCRIPT_TOP_MAX:

    case HB_OT_MATH_CONSTANT_SUB_SUPERSCRIPT_GAP_MIN:

    case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BASELINE_DROP_MAX:

    case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BOTTOM_MAX_WITH_SUBSCRIPT:

    case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BOTTOM_MIN:

    case HB_OT_MATH_CONSTANT_SUPERSCRIPT_SHIFT_UP:

    case HB_OT_MATH_CONSTANT_SUPERSCRIPT_SHIFT_UP_CRAMPED:

    case HB_OT_MATH_CONSTANT_UNDERBAR_EXTRA_DESCENDER:

    case HB_OT_MATH_CONSTANT_UNDERBAR_RULE_THICKNESS:

    case HB_OT_MATH_CONSTANT_UNDERBAR_VERTICAL_GAP:

    case HB_OT_MATH_CONSTANT_UPPER_LIMIT_BASELINE_RISE_MIN:

    case HB_OT_MATH_CONSTANT_UPPER_LIMIT_GAP_MIN:

      return mathValueRecords[constant - HB_OT_MATH_CONSTANT_MATH_LEADING].get_y_value (font, this);

    case HB_OT_MATH_CONSTANT_RADICAL_DEGREE_BOTTOM_RAISE_PERCENT:

      return radicalDegreeBottomRaisePercent;

    default:

      return 0;

    }

  }

  protected:

  HBINT16 percentScaleDown[2];

  HBUINT16 minHeight[2];

  MathValueRecord mathValueRecords[51];

  HBINT16 radicalDegreeBottomRaisePercent;

  public:

  DEFINE_SIZE_STATIC (214);

};

struct MathItalicsCorrectionInfo

{

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    const hb_set_t &glyphset = c->plan->_glyphset_mathed;

    const hb_map_t &glyph_map = *c->plan->glyph_map;

    auto *out = c->serializer->start_embed (*this);

    if (unlikely (!c->serializer->extend_min (out))) return_trace (false);

    hb_sorted_vector_t<hb_codepoint_t> new_coverage;

    + hb_zip (this+coverage, italicsCorrection)

    | hb_filter (glyphset, hb_first)

    | hb_filter (serialize_math_record_array (c->serializer, out->italicsCorrection, this), hb_second)

    | hb_map (hb_first)

    | hb_map (glyph_map)

    | hb_sink (new_coverage)

    ;

    out->coverage.serialize_serialize (c->serializer, new_coverage.iter ());

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

      coverage.sanitize (c, this) &&

      italicsCorrection.sanitize (c, this));

  }

  hb_position_t get_value (hb_codepoint_t glyph,

         hb_font_t *font) const

  {

    unsigned int index = (this+coverage).get_coverage (glyph);

    return italicsCorrection[index].get_x_value (font, this);

  }

  protected:

  Offset16To<Coverage>       coverage;    /* Offset to Coverage table -

             * from the beginning of

             * MathItalicsCorrectionInfo

             * table. */

  Array16Of<MathValueRecord> italicsCorrection; /* Array of MathValueRecords

             * defining italics correction

             * values for each

             * covered glyph. */

  public:

  DEFINE_SIZE_ARRAY (4, italicsCorrection);

};

struct MathTopAccentAttachment

{

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    const hb_set_t &glyphset = c->plan->_glyphset_mathed;

    const hb_map_t &glyph_map = *c->plan->glyph_map;

    auto *out = c->serializer->start_embed (*this);

    if (unlikely (!c->serializer->extend_min (out))) return_trace (false);

    hb_sorted_vector_t<hb_codepoint_t> new_coverage;

    + hb_zip (this+topAccentCoverage, topAccentAttachment)

    | hb_filter (glyphset, hb_first)

    | hb_filter (serialize_math_record_array (c->serializer, out->topAccentAttachment, this), hb_second)

    | hb_map (hb_first)

    | hb_map (glyph_map)

    | hb_sink (new_coverage)

    ;

    out->topAccentCoverage.serialize_serialize (c->serializer, new_coverage.iter ());

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

      topAccentCoverage.sanitize (c, this) &&

      topAccentAttachment.sanitize (c, this));

  }

  hb_position_t get_value (hb_codepoint_t glyph,

         hb_font_t *font) const

  {

    unsigned int index = (this+topAccentCoverage).get_coverage (glyph);

    if (index == NOT_COVERED)

      return font->get_glyph_h_advance (glyph) / 2;

    return topAccentAttachment[index].get_x_value (font, this);

  }

  protected:

  Offset16To<Coverage>       topAccentCoverage;   /* Offset to Coverage table -

             * from the beginning of

             * MathTopAccentAttachment

             * table. */

  Array16Of<MathValueRecord> topAccentAttachment; /* Array of MathValueRecords

             * defining top accent

             * attachment points for each

             * covered glyph. */

  public:

  DEFINE_SIZE_ARRAY (2 + 2, topAccentAttachment);

};

struct MathKern

{

  MathKern* copy (hb_serialize_context_t *c) const

  {

    TRACE_SERIALIZE (this);

    auto *out = c->start_embed (this);

    if (unlikely (!c->embed (heightCount))) return_trace (nullptr);

    unsigned count = 2 * heightCount + 1;

    for (unsigned i = 0; i < count; i++)

      if (!c->copy (mathValueRecordsZ.arrayZ[i], this))

        return_trace (nullptr);

    return_trace (out);

  }

  bool sanitize_math_value_records (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    unsigned int count = 2 * heightCount + 1;

    for (unsigned int i = 0; i < count; i++)

      if (!mathValueRecordsZ.arrayZ[i].sanitize (c, this)) return_trace (false);

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

      hb_barrier () &&

      c->check_array (mathValueRecordsZ.arrayZ, 2 * heightCount + 1) &&

      sanitize_math_value_records (c));

  }

  hb_position_t get_value (hb_position_t correction_height, hb_font_t *font) const

  {

    const MathValueRecord* correctionHeight = mathValueRecordsZ.arrayZ;

    const MathValueRecord* kernValue = mathValueRecordsZ.arrayZ + heightCount;

    int sign = font->y_scale < 0 ? -1 : +1;

    /* According to OpenType spec (v1.9), except for the boundary cases, the index

     * chosen for kern value should be i such that

     *    correctionHeight[i-1] <= correction_height < correctionHeight[i]

     * We can use the binary search algorithm of std::upper_bound(). Or, we can

     * use the internal hb_bsearch_impl.

     */

    unsigned int pos;

    auto cmp = +[](const void* key, const void* p,

                   int sign, hb_font_t* font, const MathKern* mathKern) -> int {

      hb_position_t a = *(hb_position_t *) key;

      hb_position_t b = ((MathValueRecord *) p)->get_y_value (font, mathKern);

      if (a == b) return 0;

      return sign > 0 ? (a < b ? -1 : +1) : (b < a ? -1 : +1);

    };

    unsigned int i = hb_bsearch_impl(&pos, correction_height, correctionHeight,

                                     heightCount, MathValueRecord::static_size,

                                     cmp, sign, font, this) ? pos + 1 : pos;

    return kernValue[i].get_x_value (font, this);

  }

  unsigned int get_entries (unsigned int start_offset,

          unsigned int *entries_count, /* IN/OUT */

          hb_ot_math_kern_entry_t *kern_entries, /* OUT */

          hb_font_t *font) const

  {

    const MathValueRecord* correctionHeight = mathValueRecordsZ.arrayZ;

    const MathValueRecord* kernValue = mathValueRecordsZ.arrayZ + heightCount;

    const unsigned int entriesCount = heightCount + 1;

    if (entries_count && kern_entries)

    {

      unsigned int start = hb_min (start_offset, entriesCount);

      unsigned int end = hb_min (start + *entries_count, entriesCount);

      *entries_count = end - start;

      for (unsigned int i = 0; i < *entries_count; i++) {

  unsigned int j = start + i;

  hb_position_t max_height;

  if (j == heightCount) {

    max_height = INT32_MAX;

  } else {

    max_height = correctionHeight[j].get_y_value (font, this);

  }

  kern_entries[i] = {max_height, kernValue[j].get_x_value (font, this)};

      }

    }

    return entriesCount;

  }

  protected:

  HBUINT16  heightCount;

  UnsizedArrayOf<MathValueRecord>

    mathValueRecordsZ;

        /* Array of correction heights at

         * which the kern value changes.

         * Sorted by the height value in

         * design units (heightCount entries),

         * Followed by:

         * Array of kern values corresponding

         * to heights. (heightCount+1 entries).

         */

  public:

  DEFINE_SIZE_ARRAY (2, mathValueRecordsZ);

};

struct MathKernInfoRecord

{

  MathKernInfoRecord* copy (hb_serialize_context_t *c, const void *base) const

  {

    TRACE_SERIALIZE (this);

    auto *out = c->embed (this);

    if (unlikely (!out)) return_trace (nullptr);

    unsigned count = ARRAY_LENGTH (mathKern);

    for (unsigned i = 0; i < count; i++)

      out->mathKern[i].serialize_copy (c, mathKern[i], base, 0, hb_serialize_context_t::Head);

    return_trace (out);

  }

  bool sanitize (hb_sanitize_context_t *c, const void *base) const

  {

    TRACE_SANITIZE (this);

    unsigned int count = ARRAY_LENGTH (mathKern);

    for (unsigned int i = 0; i < count; i++)

      if (unlikely (!mathKern[i].sanitize (c, base)))

  return_trace (false);

    return_trace (true);

  }

  hb_position_t get_kerning (hb_ot_math_kern_t kern,

           hb_position_t correction_height,

           hb_font_t *font,

           const void *base) const

  {

    unsigned int idx = kern;

    if (unlikely (idx >= ARRAY_LENGTH (mathKern))) return 0;

    return (base+mathKern[idx]).get_value (correction_height, font);

  }

  unsigned int get_kernings (hb_ot_math_kern_t kern,

           unsigned int start_offset,

           unsigned int *entries_count, /* IN/OUT */

           hb_ot_math_kern_entry_t *kern_entries, /* OUT */

           hb_font_t *font,

           const void *base) const

  {

    unsigned int idx = kern;

    if (unlikely (idx >= ARRAY_LENGTH (mathKern)) || !mathKern[idx]) {

      if (entries_count) *entries_count = 0;

      return 0;

    }

    return (base+mathKern[idx]).get_entries (start_offset,

               entries_count,

               kern_entries,

               font);

  }

  protected:

  /* Offset to MathKern table for each corner -

   * from the beginning of MathKernInfo table.  May be NULL. */

  Offset16To<MathKern> mathKern[4];

  public:

  DEFINE_SIZE_STATIC (8);

};

struct MathKernInfo

{

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    const hb_set_t &glyphset = c->plan->_glyphset_mathed;

    const hb_map_t &glyph_map = *c->plan->glyph_map;

    auto *out = c->serializer->start_embed (*this);

    if (unlikely (!c->serializer->extend_min (out))) return_trace (false);

    hb_sorted_vector_t<hb_codepoint_t> new_coverage;

    + hb_zip (this+mathKernCoverage, mathKernInfoRecords)

    | hb_filter (glyphset, hb_first)

    | hb_filter (serialize_math_record_array (c->serializer, out->mathKernInfoRecords, this), hb_second)

    | hb_map (hb_first)

    | hb_map (glyph_map)

    | hb_sink (new_coverage)

    ;

    out->mathKernCoverage.serialize_serialize (c->serializer, new_coverage.iter ());

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

      mathKernCoverage.sanitize (c, this) &&

      mathKernInfoRecords.sanitize (c, this));

  }

  hb_position_t get_kerning (hb_codepoint_t glyph,

           hb_ot_math_kern_t kern,

           hb_position_t correction_height,

           hb_font_t *font) const

  {

    unsigned int index = (this+mathKernCoverage).get_coverage (glyph);

    return mathKernInfoRecords[index].get_kerning (kern, correction_height, font, this);

  }

  unsigned int get_kernings (hb_codepoint_t glyph,

           hb_ot_math_kern_t kern,

           unsigned int start_offset,

           unsigned int *entries_count, /* IN/OUT */

           hb_ot_math_kern_entry_t *kern_entries, /* OUT */

           hb_font_t *font) const

  {

    unsigned int index = (this+mathKernCoverage).get_coverage (glyph);

    return mathKernInfoRecords[index].get_kernings (kern,

                start_offset,

                entries_count,

                kern_entries,

                font,

                this);

  }

  protected:

  Offset16To<Coverage>

    mathKernCoverage;

        /* Offset to Coverage table -

         * from the beginning of the

         * MathKernInfo table. */

  Array16Of<MathKernInfoRecord>

    mathKernInfoRecords;

        /* Array of MathKernInfoRecords,

         * per-glyph information for

         * mathematical positioning

         * of subscripts and

         * superscripts. */

  public:

  DEFINE_SIZE_ARRAY (4, mathKernInfoRecords);

};

struct MathGlyphInfo

{

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    auto *out = c->serializer->embed (*this);

    if (unlikely (!out)) return_trace (false);

    out->mathItalicsCorrectionInfo.serialize_subset (c, mathItalicsCorrectionInfo, this);

    out->mathTopAccentAttachment.serialize_subset (c, mathTopAccentAttachment, this);

    const hb_set_t &glyphset = c->plan->_glyphset_mathed;

    const hb_map_t &glyph_map = *c->plan->glyph_map;

    auto it =

    + hb_iter (this+extendedShapeCoverage)

    | hb_take (c->plan->source->get_num_glyphs ())

    | hb_filter (glyphset)

    | hb_map_retains_sorting (glyph_map)

    ;

    if (it) out->extendedShapeCoverage.serialize_serialize (c->serializer, it);

    else out->extendedShapeCoverage = 0;

    out->mathKernInfo.serialize_subset (c, mathKernInfo, this);

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

      mathItalicsCorrectionInfo.sanitize (c, this) &&

      mathTopAccentAttachment.sanitize (c, this) &&

      extendedShapeCoverage.sanitize (c, this) &&

      mathKernInfo.sanitize (c, this));

  }

  hb_position_t

  get_italics_correction (hb_codepoint_t  glyph, hb_font_t *font) const

  { return (this+mathItalicsCorrectionInfo).get_value (glyph, font); }

  hb_position_t

  get_top_accent_attachment (hb_codepoint_t  glyph, hb_font_t *font) const

  { return (this+mathTopAccentAttachment).get_value (glyph, font); }

  bool is_extended_shape (hb_codepoint_t glyph) const

  { return (this+extendedShapeCoverage).get_coverage (glyph) != NOT_COVERED; }

  hb_position_t get_kerning (hb_codepoint_t glyph,

           hb_ot_math_kern_t kern,

           hb_position_t correction_height,

           hb_font_t *font) const

  { return (this+mathKernInfo).get_kerning (glyph, kern, correction_height, font); }

  hb_position_t get_kernings (hb_codepoint_t glyph,

            hb_ot_math_kern_t kern,

            unsigned int start_offset,

            unsigned int *entries_count, /* IN/OUT */

            hb_ot_math_kern_entry_t *kern_entries, /* OUT */

            hb_font_t *font) const

  { return (this+mathKernInfo).get_kernings (glyph,

               kern,

               start_offset,

               entries_count,

               kern_entries,

               font); }

  protected:

  /* Offset to MathItalicsCorrectionInfo table -

   * from the beginning of MathGlyphInfo table. */

  Offset16To<MathItalicsCorrectionInfo> mathItalicsCorrectionInfo;

  /* Offset to MathTopAccentAttachment table -

   * from the beginning of MathGlyphInfo table. */

  Offset16To<MathTopAccentAttachment> mathTopAccentAttachment;

  /* Offset to coverage table for Extended Shape glyphs -

   * from the beginning of MathGlyphInfo table. When the left or right glyph of

   * a box is an extended shape variant, the (ink) box (and not the default

   * position defined by values in MathConstants table) should be used for

   * vertical positioning purposes.  May be NULL.. */

  Offset16To<Coverage> extendedShapeCoverage;

   /* Offset to MathKernInfo table -

    * from the beginning of MathGlyphInfo table. */

  Offset16To<MathKernInfo> mathKernInfo;

  public:

  DEFINE_SIZE_STATIC (8);

};

struct MathGlyphVariantRecord

{

  friend struct MathGlyphConstruction;

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    auto *out = c->serializer->embed (this);

    if (unlikely (!out)) return_trace (false);

    const hb_map_t& glyph_map = *c->plan->glyph_map;

    return_trace (c->serializer->check_assign (out->variantGlyph, glyph_map.get (variantGlyph), HB_SERIALIZE_ERROR_INT_OVERFLOW));

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  void depend (hb_depend_data_builder_t *depend_data, unsigned source) const

  { depend_data->add_depend(source, HB_OT_TAG_MATH, variantGlyph); }

  void closure_glyphs (hb_set_t *variant_glyphs) const

  { variant_glyphs->add (variantGlyph); }

  protected:

  HBGlyphID16 variantGlyph;       /* Glyph ID for the variant. */

  HBUINT16  advanceMeasurement; /* Advance width/height, in design units, of the

         * variant, in the direction of requested

         * glyph extension. */

  public:

  DEFINE_SIZE_STATIC (4);

};

struct PartFlags : HBUINT16

{

  enum Flags {

    Extender  = 0x0001u, /* If set, the part can be skipped or repeated. */

    Defined = 0x0001u, /* All defined flags. */

  };

  public:

  DEFINE_SIZE_STATIC (2);

};

struct MathGlyphPartRecord

{

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    auto *out = c->serializer->embed (this);

    if (unlikely (!out)) return_trace (false);

    const hb_map_t& glyph_map = *c->plan->glyph_map;

    return_trace (c->serializer->check_assign (out->glyph, glyph_map.get (glyph), HB_SERIALIZE_ERROR_INT_OVERFLOW));

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  void extract (hb_ot_math_glyph_part_t &out,

    int64_t mult,

    hb_font_t *font) const

  {

    out.glyph     = glyph;

    out.start_connector_length  = font->em_mult (startConnectorLength, mult);

    out.end_connector_length  = font->em_mult (endConnectorLength, mult);

    out.full_advance    = font->em_mult (fullAdvance, mult);

    static_assert ((unsigned int) HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER ==

       (unsigned int) PartFlags::Extender, "");

    out.flags = (hb_ot_math_glyph_part_flags_t)

    (unsigned int)

    (partFlags & PartFlags::Defined);

  }

  void depend (hb_depend_data_builder_t *depend_data, unsigned source) const

  { depend_data->add_depend(source, HB_OT_TAG_MATH, glyph); }

  void closure_glyphs (hb_set_t *variant_glyphs) const

  { variant_glyphs->add (glyph); }

  protected:

  HBGlyphID16 glyph;    /* Glyph ID for the part. */

  HBUINT16  startConnectorLength;

        /* Advance width/ height of the straight bar

         * connector material, in design units, is at

         * the beginning of the glyph, in the

         * direction of the extension. */

  HBUINT16  endConnectorLength;

        /* Advance width/ height of the straight bar

         * connector material, in design units, is at

         * the end of the glyph, in the direction of

         * the extension. */

  HBUINT16  fullAdvance;  /* Full advance width/height for this part,

         * in the direction of the extension.

         * In design units. */

  PartFlags partFlags;  /* Part qualifiers. */

  public:

  DEFINE_SIZE_STATIC (10);

};

struct MathGlyphAssembly

{

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    if (!c->serializer->copy (italicsCorrection, this)) return_trace (false);

    if (!c->serializer->copy<HBUINT16> (partRecords.len)) return_trace (false);

    for (const auto& record : partRecords.iter ())

      if (!record.subset (c)) return_trace (false);

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

      italicsCorrection.sanitize (c, this) &&

      partRecords.sanitize (c));

  }

  unsigned int get_parts (hb_direction_t direction,

        hb_font_t *font,

        unsigned int start_offset,

        unsigned int *parts_count, /* IN/OUT */

        hb_ot_math_glyph_part_t *parts /* OUT */,

        hb_position_t *italics_correction /* OUT */) const

  {

    if (parts_count && parts)

    {

      int64_t mult = font->dir_mult (direction);

      for (auto _ : hb_zip (partRecords.as_array ().sub_array (start_offset, parts_count),

          hb_array (parts, *parts_count)))

  _.first.extract (_.second, mult, font);

    }

    if (italics_correction)

      *italics_correction = italicsCorrection.get_x_value (font, this);

    return partRecords.len;

  }

  void depend (hb_depend_data_builder_t *depend_data, unsigned source) const

  {

    for (const auto& _ : partRecords.iter ())

      _.depend (depend_data, source);

  }

  void closure_glyphs (hb_set_t *variant_glyphs) const

  {

    for (const auto& _ : partRecords.iter ())

      _.closure_glyphs (variant_glyphs);

  }

  protected:

  MathValueRecord

    italicsCorrection;

        /* Italics correction of this

         * MathGlyphAssembly. Should not

         * depend on the assembly size. */

  Array16Of<MathGlyphPartRecord>

    partRecords;  /* Array of part records, from

         * left to right and bottom to

         * top. */

  public:

  DEFINE_SIZE_ARRAY (6, partRecords);

};

struct MathGlyphConstruction

{

  bool subset (hb_subset_context_t *c) const

  {

    TRACE_SUBSET (this);

    auto *out = c->serializer->start_embed (*this);

    if (unlikely (!c->serializer->extend_min (out))) return_trace (false);

    out->glyphAssembly.serialize_subset (c, glyphAssembly, this);

    if (!c->serializer->check_assign (out->mathGlyphVariantRecord.len, mathGlyphVariantRecord.len, HB_SERIALIZE_ERROR_INT_OVERFLOW))

      return_trace (false);

    for (const auto& record : mathGlyphVariantRecord.iter ())

      if (!record.subset (c)) return_trace (false);

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

      glyphAssembly.sanitize (c, this) &&

      mathGlyphVariantRecord.sanitize (c));

  }

  const MathGlyphAssembly &get_assembly () const { return this+glyphAssembly; }

  unsigned int get_variants (hb_direction_t direction,

           hb_font_t *font,

           unsigned int start_offset,

           unsigned int *variants_count, /* IN/OUT */

           hb_ot_math_glyph_variant_t *variants /* OUT */) const

  {

    if (variants_count && variants)

    {

      int64_t mult = font->dir_mult (direction);

      for (auto _ : hb_zip (mathGlyphVariantRecord.as_array ().sub_array (start_offset, variants_count),

          hb_array (variants, *variants_count)))

  _.second = {_.first.variantGlyph, font->em_mult (_.first.advanceMeasurement, mult)};

    }

    return mathGlyphVariantRecord.len;

  }

  void depend (hb_depend_data_builder_t *depend_data, unsigned source) const

  {

    (this+glyphAssembly).depend (depend_data, source);

    for (const auto& _ : mathGlyphVariantRecord.iter ())

      _.depend (depend_data, source);

  }

  void closure_glyphs (hb_set_t *variant_glyphs) const

  {

    (this+glyphAssembly).closure_glyphs (variant_glyphs);

    for (const auto& _ : mathGlyphVariantRecord.iter ())

      _.closure_glyphs (variant_glyphs);

  }

  protected:

  /* Offset to MathGlyphAssembly table for this shape - from the beginning of

     MathGlyphConstruction table.  May be NULL. */

  Offset16To<MathGlyphAssembly>   glyphAssembly;

  /* MathGlyphVariantRecords for alternative variants of the glyphs. */

  Array16Of<MathGlyphVariantRecord> mathGlyphVariantRecord;

  public:

  DEFINE_SIZE_ARRAY (4, mathGlyphVariantRecord);

};

struct MathVariants

{

  void depend (hb_depend_data_builder_t *depend_data) const

  {

    const hb_array_t<const Offset16To<MathGlyphConstruction>> glyph_construction_offsets = glyphConstruction.as_array (vertGlyphCount + horizGlyphCount);

    if (vertGlyphCoverage)

    {

      const auto vert_offsets = glyph_construction_offsets.sub_array (0, vertGlyphCount);

      + hb_zip (this+vertGlyphCoverage, vert_offsets)

      | hb_apply ([&] (const hb_pair_t<hb_codepoint_t, const Offset16To<MathGlyphConstruction>&> &_)

                  {

                    const MathGlyphConstruction &mgc = this+_.second;

                    mgc.depend (depend_data, _.first);

                  })

      ;

    }

    if (horizGlyphCoverage)

    {

      const auto hori_offsets = glyph_construction_offsets.sub_array (vertGlyphCount, horizGlyphCount);

      + hb_zip (this+horizGlyphCoverage, hori_offsets)

      | hb_apply ([&] (const hb_pair_t<hb_codepoint_t, const Offset16To<MathGlyphConstruction>&> &_)

                  {

                    const MathGlyphConstruction &mgc = this+_.second;

                    mgc.depend (depend_data, _.first);

                  })

      ;

    }

  }

  void closure_glyphs (const hb_set_t *glyph_set,

                       hb_set_t *variant_glyphs) const

  {

    const hb_array_t<const Offset16To<MathGlyphConstruction>> glyph_construction_offsets = glyphConstruction.as_array (vertGlyphCount + horizGlyphCount);

    if (vertGlyphCoverage)

    {

      const auto vert_offsets = glyph_construction_offsets.sub_array (0, vertGlyphCount);

      + hb_zip (this+vertGlyphCoverage, vert_offsets)

      | hb_filter (glyph_set, hb_first)

      | hb_map (hb_second)

      | hb_map (hb_add (this))