/*

 * Copyright © 2007,2008,2009,2010  Red Hat, Inc.

 * Copyright © 2010,2012,2013  Google, Inc.

 *

 *  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.

 *

 * Red Hat Author(s): Behdad Esfahbod

 * Google Author(s): Behdad Esfahbod

 */

#ifndef HB_OT_LAYOUT_GSUB_TABLE_HH

#define HB_OT_LAYOUT_GSUB_TABLE_HH

#include "hb-ot-layout-gsubgpos-private.hh"

namespace OT {

struct SingleSubstFormat1

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      /* TODO Switch to range-based API to work around malicious fonts.

       * https://github.com/behdad/harfbuzz/issues/363 */

      hb_codepoint_t glyph_id = iter.get_glyph ();

      if (c->glyphs->has (glyph_id))

	c->glyphs->add ((glyph_id + deltaGlyphID) & 0xFFFFu);

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      /* TODO Switch to range-based API to work around malicious fonts.

       * https://github.com/behdad/harfbuzz/issues/363 */

      hb_codepoint_t glyph_id = iter.get_glyph ();

      c->input->add (glyph_id);

      c->output->add ((glyph_id + deltaGlyphID) & 0xFFFFu);

    }

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_codepoint_t glyph_id = c->buffer->cur().codepoint;

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

    if (likely (index == NOT_COVERED)) return_trace (false);

    /* According to the Adobe Annotated OpenType Suite, result is always

     * limited to 16bit. */

    glyph_id = (glyph_id + deltaGlyphID) & 0xFFFFu;

    c->replace_glyph (glyph_id);

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &glyphs,

			 unsigned int num_glyphs,

			 int delta)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false);

    deltaGlyphID.set (delta); /* TODO(serilaize) overflow? */

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && deltaGlyphID.sanitize (c));

  }

  protected:

  USHORT	format;			/* Format identifier--format = 1 */

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of Substitution table */

  SHORT		deltaGlyphID;		/* Add to original GlyphID to get

					 * substitute GlyphID */

  public:

  DEFINE_SIZE_STATIC (6);

};

struct SingleSubstFormat2

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    unsigned int count = substitute.len;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      if (unlikely (iter.get_coverage () >= count))

        break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */

      if (c->glyphs->has (iter.get_glyph ()))

	c->glyphs->add (substitute[iter.get_coverage ()]);

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    Coverage::Iter iter;

    unsigned int count = substitute.len;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      if (unlikely (iter.get_coverage () >= count))

        break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */

      c->input->add (iter.get_glyph ());

      c->output->add (substitute[iter.get_coverage ()]);

    }

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_codepoint_t glyph_id = c->buffer->cur().codepoint;

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

    if (likely (index == NOT_COVERED)) return_trace (false);

    if (unlikely (index >= substitute.len)) return_trace (false);

    glyph_id = substitute[index];

    c->replace_glyph (glyph_id);

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &glyphs,

			 Supplier<GlyphID> &substitutes,

			 unsigned int num_glyphs)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!substitute.serialize (c, substitutes, num_glyphs))) return_trace (false);

    if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && substitute.sanitize (c));

  }

  protected:

  USHORT	format;			/* Format identifier--format = 2 */

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of Substitution table */

  ArrayOf<GlyphID>

		substitute;		/* Array of substitute

					 * GlyphIDs--ordered by Coverage Index */

  public:

  DEFINE_SIZE_ARRAY (6, substitute);

};

struct SingleSubst

{

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &glyphs,

			 Supplier<GlyphID> &substitutes,

			 unsigned int num_glyphs)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (u.format))) return_trace (false);

    unsigned int format = 2;

    int delta = 0;

    if (num_glyphs) {

      format = 1;

      /* TODO(serialize) check for wrap-around */

      delta = substitutes[0] - glyphs[0];

      for (unsigned int i = 1; i < num_glyphs; i++)

	if (delta != substitutes[i] - glyphs[i]) {

	  format = 2;

	  break;

	}

    }

    u.format.set (format);

    switch (u.format) {

    case 1: return_trace (u.format1.serialize (c, glyphs, num_glyphs, delta));

    case 2: return_trace (u.format2.serialize (c, glyphs, substitutes, num_glyphs));

    default:return_trace (false);

    }

  }

  template <typename context_t>

  inline typename context_t::return_t dispatch (context_t *c) const

  {

    TRACE_DISPATCH (this, u.format);

    if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

    switch (u.format) {

    case 1: return_trace (c->dispatch (u.format1));

    case 2: return_trace (c->dispatch (u.format2));

    default:return_trace (c->default_return_value ());

    }

  }

  protected:

  union {

  USHORT		format;		/* Format identifier */

  SingleSubstFormat1	format1;

  SingleSubstFormat2	format2;

  } u;

};

struct Sequence

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    unsigned int count = substitute.len;

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

      c->glyphs->add (substitute[i]);

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    unsigned int count = substitute.len;

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

      c->output->add (substitute[i]);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    unsigned int count = substitute.len;

    /* Special-case to make it in-place and not consider this

     * as a "multiplied" substitution. */

    if (unlikely (count == 1))

    {

      c->replace_glyph (substitute.array[0]);

      return_trace (true);

    }

    /* Spec disallows this, but Uniscribe allows it.

     * https://github.com/behdad/harfbuzz/issues/253 */

    else if (unlikely (count == 0))

    {

      c->buffer->delete_glyph ();

      return_trace (true);

    }

    unsigned int klass = _hb_glyph_info_is_ligature (&c->buffer->cur()) ?

			 HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH : 0;

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

      _hb_glyph_info_set_lig_props_for_component (&c->buffer->cur(), i);

      c->output_glyph_for_component (substitute.array[i], klass);

    }

    c->buffer->skip_glyph ();

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &glyphs,

			 unsigned int num_glyphs)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!substitute.serialize (c, glyphs, num_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (substitute.sanitize (c));

  }

  protected:

  ArrayOf<GlyphID>

		substitute;		/* String of GlyphIDs to substitute */

  public:

  DEFINE_SIZE_ARRAY (2, substitute);

};

struct MultipleSubstFormat1

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    unsigned int count = sequence.len;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      if (unlikely (iter.get_coverage () >= count))

        break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */

      if (c->glyphs->has (iter.get_glyph ()))

	(this+sequence[iter.get_coverage ()]).closure (c);

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    (this+coverage).add_coverage (c->input);

    unsigned int count = sequence.len;

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

	(this+sequence[i]).collect_glyphs (c);

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);

    if (likely (index == NOT_COVERED)) return_trace (false);

    return_trace ((this+sequence[index]).apply (c));

  }

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &glyphs,

			 Supplier<unsigned int> &substitute_len_list,

			 unsigned int num_glyphs,

			 Supplier<GlyphID> &substitute_glyphs_list)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!sequence.serialize (c, num_glyphs))) return_trace (false);

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

      if (unlikely (!sequence[i].serialize (c, this).serialize (c,

								substitute_glyphs_list,

								substitute_len_list[i]))) return_trace (false);

    substitute_len_list.advance (num_glyphs);

    if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && sequence.sanitize (c, this));

  }

  protected:

  USHORT	format;			/* Format identifier--format = 1 */

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of Substitution table */

  OffsetArrayOf<Sequence>

		sequence;		/* Array of Sequence tables

					 * ordered by Coverage Index */

  public:

  DEFINE_SIZE_ARRAY (6, sequence);

};

struct MultipleSubst

{

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &glyphs,

			 Supplier<unsigned int> &substitute_len_list,

			 unsigned int num_glyphs,

			 Supplier<GlyphID> &substitute_glyphs_list)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (u.format))) return_trace (false);

    unsigned int format = 1;

    u.format.set (format);

    switch (u.format) {

    case 1: return_trace (u.format1.serialize (c, glyphs, substitute_len_list, num_glyphs, substitute_glyphs_list));

    default:return_trace (false);

    }

  }

  template <typename context_t>

  inline typename context_t::return_t dispatch (context_t *c) const

  {

    TRACE_DISPATCH (this, u.format);

    if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

    switch (u.format) {

    case 1: return_trace (c->dispatch (u.format1));

    default:return_trace (c->default_return_value ());

    }

  }

  protected:

  union {

  USHORT		format;		/* Format identifier */

  MultipleSubstFormat1	format1;

  } u;

};

typedef ArrayOf<GlyphID> AlternateSet;	/* Array of alternate GlyphIDs--in

					 * arbitrary order */

struct AlternateSubstFormat1

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    unsigned int count = alternateSet.len;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      if (unlikely (iter.get_coverage () >= count))

        break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */

      if (c->glyphs->has (iter.get_glyph ())) {

	const AlternateSet &alt_set = this+alternateSet[iter.get_coverage ()];

	unsigned int count = alt_set.len;

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

	  c->glyphs->add (alt_set[i]);

      }

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    Coverage::Iter iter;

    unsigned int count = alternateSet.len;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      if (unlikely (iter.get_coverage () >= count))

        break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */

      c->input->add (iter.get_glyph ());

      const AlternateSet &alt_set = this+alternateSet[iter.get_coverage ()];

      unsigned int count = alt_set.len;

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

	c->output->add (alt_set[i]);

    }

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_codepoint_t glyph_id = c->buffer->cur().codepoint;

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

    if (likely (index == NOT_COVERED)) return_trace (false);

    const AlternateSet &alt_set = this+alternateSet[index];

    if (unlikely (!alt_set.len)) return_trace (false);

    hb_mask_t glyph_mask = c->buffer->cur().mask;

    hb_mask_t lookup_mask = c->lookup_mask;

    /* Note: This breaks badly if two features enabled this lookup together. */

    unsigned int shift = _hb_ctz (lookup_mask);

    unsigned int alt_index = ((lookup_mask & glyph_mask) >> shift);

    if (unlikely (alt_index > alt_set.len || alt_index == 0)) return_trace (false);

    glyph_id = alt_set[alt_index - 1];

    c->replace_glyph (glyph_id);

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &glyphs,

			 Supplier<unsigned int> &alternate_len_list,

			 unsigned int num_glyphs,

			 Supplier<GlyphID> &alternate_glyphs_list)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!alternateSet.serialize (c, num_glyphs))) return_trace (false);

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

      if (unlikely (!alternateSet[i].serialize (c, this).serialize (c,

								    alternate_glyphs_list,

								    alternate_len_list[i]))) return_trace (false);

    alternate_len_list.advance (num_glyphs);

    if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && alternateSet.sanitize (c, this));

  }

  protected:

  USHORT	format;			/* Format identifier--format = 1 */

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of Substitution table */

  OffsetArrayOf<AlternateSet>

		alternateSet;		/* Array of AlternateSet tables

					 * ordered by Coverage Index */

  public:

  DEFINE_SIZE_ARRAY (6, alternateSet);

};

struct AlternateSubst

{

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &glyphs,

			 Supplier<unsigned int> &alternate_len_list,

			 unsigned int num_glyphs,

			 Supplier<GlyphID> &alternate_glyphs_list)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (u.format))) return_trace (false);

    unsigned int format = 1;

    u.format.set (format);

    switch (u.format) {

    case 1: return_trace (u.format1.serialize (c, glyphs, alternate_len_list, num_glyphs, alternate_glyphs_list));

    default:return_trace (false);

    }

  }

  template <typename context_t>

  inline typename context_t::return_t dispatch (context_t *c) const

  {

    TRACE_DISPATCH (this, u.format);

    if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

    switch (u.format) {

    case 1: return_trace (c->dispatch (u.format1));

    default:return_trace (c->default_return_value ());

    }

  }

  protected:

  union {

  USHORT		format;		/* Format identifier */

  AlternateSubstFormat1	format1;

  } u;

};

struct Ligature

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    unsigned int count = component.len;

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

      if (!c->glyphs->has (component[i]))

        return;

    c->glyphs->add (ligGlyph);

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    unsigned int count = component.len;

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

      c->input->add (component[i]);

    c->output->add (ligGlyph);

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    if (c->len != component.len)

      return_trace (false);

    for (unsigned int i = 1; i < c->len; i++)

      if (likely (c->glyphs[i] != component[i]))

	return_trace (false);

    return_trace (true);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    unsigned int count = component.len;

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

    /* Special-case to make it in-place and not consider this

     * as a "ligated" substitution. */

    if (unlikely (count == 1))

    {

      c->replace_glyph (ligGlyph);

      return_trace (true);

    }

    bool is_mark_ligature = false;

    unsigned int total_component_count = 0;

    unsigned int match_length = 0;

    unsigned int match_positions[HB_MAX_CONTEXT_LENGTH];

    if (likely (!match_input (c, count,

			      &component[1],

			      match_glyph,

			      NULL,

			      &match_length,

			      match_positions,

			      &is_mark_ligature,

			      &total_component_count)))

      return_trace (false);

    ligate_input (c,

		  count,

		  match_positions,

		  match_length,

		  ligGlyph,

		  is_mark_ligature,

		  total_component_count);

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

			 GlyphID ligature,

			 Supplier<GlyphID> &components, /* Starting from second */

			 unsigned int num_components /* Including first component */)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    ligGlyph = ligature;

    if (unlikely (!component.serialize (c, components, num_components))) return_trace (false);

    return_trace (true);

  }

  public:

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (ligGlyph.sanitize (c) && component.sanitize (c));

  }

  protected:

  GlyphID	ligGlyph;		/* GlyphID of ligature to substitute */

  HeadlessArrayOf<GlyphID>

		component;		/* Array of component GlyphIDs--start

					 * with the second  component--ordered

					 * in writing direction */

  public:

  DEFINE_SIZE_ARRAY (4, component);

};

struct LigatureSet

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    unsigned int num_ligs = ligature.len;

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

      (this+ligature[i]).closure (c);

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    unsigned int num_ligs = ligature.len;

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

      (this+ligature[i]).collect_glyphs (c);

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    unsigned int num_ligs = ligature.len;

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

    {

      const Ligature &lig = this+ligature[i];

      if (lig.would_apply (c))

        return_trace (true);

    }

    return_trace (false);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    unsigned int num_ligs = ligature.len;

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

    {

      const Ligature &lig = this+ligature[i];

      if (lig.apply (c)) return_trace (true);

    }

    return_trace (false);

  }

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &ligatures,

			 Supplier<unsigned int> &component_count_list,

			 unsigned int num_ligatures,

			 Supplier<GlyphID> &component_list /* Starting from second for each ligature */)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!ligature.serialize (c, num_ligatures))) return_trace (false);

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

      if (unlikely (!ligature[i].serialize (c, this).serialize (c,

								ligatures[i],

								component_list,

								component_count_list[i]))) return_trace (false);

    ligatures.advance (num_ligatures);

    component_count_list.advance (num_ligatures);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (ligature.sanitize (c, this));

  }

  protected:

  OffsetArrayOf<Ligature>

		ligature;		/* Array LigatureSet tables

					 * ordered by preference */

  public:

  DEFINE_SIZE_ARRAY (2, ligature);

};

struct LigatureSubstFormat1

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    unsigned int count = ligatureSet.len;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      if (unlikely (iter.get_coverage () >= count))

        break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */

      if (c->glyphs->has (iter.get_glyph ()))

	(this+ligatureSet[iter.get_coverage ()]).closure (c);

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    Coverage::Iter iter;

    unsigned int count = ligatureSet.len;

    for (iter.init (this+coverage); iter.more (); iter.next ())

    {

      if (unlikely (iter.get_coverage () >= count))

        break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */

      c->input->add (iter.get_glyph ());

      (this+ligatureSet[iter.get_coverage ()]).collect_glyphs (c);

    }

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    unsigned int index = (this+coverage).get_coverage (c->glyphs[0]);

    if (likely (index == NOT_COVERED)) return_trace (false);

    const LigatureSet &lig_set = this+ligatureSet[index];

    return_trace (lig_set.would_apply (c));

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_codepoint_t glyph_id = c->buffer->cur().codepoint;

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

    if (likely (index == NOT_COVERED)) return_trace (false);

    const LigatureSet &lig_set = this+ligatureSet[index];

    return_trace (lig_set.apply (c));

  }

  inline bool serialize (hb_serialize_context_t *c,

			 Supplier<GlyphID> &first_glyphs,

			 Supplier<unsigned int> &ligature_per_first_glyph_count_list,

			 unsigned int num_first_glyphs,

			 Supplier<GlyphID> &ligatures_list,

			 Supplier<unsigned int> &component_count_list,

			 Supplier<GlyphID> &component_list /* Starting from second for each ligature */)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!ligatureSet.serialize (c, num_first_glyphs))) return_trace (false);

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

      if (unlikely (!ligatureSet[i].serialize (c, this).serialize (c,

								   ligatures_list,

								   component_count_list,

								   ligature_per_first_glyph_count_list[i],

								   component_list))) return_trace (false);

    ligature_per_first_glyph_count_list.advance (num_first_glyphs);

    if (unlikely (!coverage.serialize (c, this).serialize (c, first_glyphs, num_first_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && ligatureSet.sanitize (c, this));

  }

  protected:

  USHORT	format;			/* Format identifier--format = 1 */

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of Substitution table */

  OffsetArrayOf<LigatureSet>

		ligatureSet;		/* Array LigatureSet tables

					 * ordered by Coverage Index */

  public:

  DEFINE_SIZE_ARRAY (6, ligatureSet);

};