/*

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

#define HB_OT_LAYOUT_GPOS_TABLE_HH

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

namespace OT {

/* buffer **position** var allocations */

#define attach_chain() var.i16[0] /* glyph to which this attaches to, relative to current glyphs; negative for going back, positive for forward. */

#define attach_type() var.u8[2] /* attachment type */

/* Note! if attach_chain() is zero, the value of attach_type() is irrelevant. */

enum attach_type_t {

  ATTACH_TYPE_NONE	= 0X00,

  /* Each attachment should be either a mark or a cursive; can't be both. */

  ATTACH_TYPE_MARK	= 0X01,

  ATTACH_TYPE_CURSIVE	= 0X02,

};

/* Shared Tables: ValueRecord, Anchor Table, and MarkArray */

typedef USHORT Value;

typedef Value ValueRecord[VAR];

struct ValueFormat : USHORT

{

  enum Flags {

    xPlacement	= 0x0001u,	/* Includes horizontal adjustment for placement */

    yPlacement	= 0x0002u,	/* Includes vertical adjustment for placement */

    xAdvance	= 0x0004u,	/* Includes horizontal adjustment for advance */

    yAdvance	= 0x0008u,	/* Includes vertical adjustment for advance */

    xPlaDevice	= 0x0010u,	/* Includes horizontal Device table for placement */

    yPlaDevice	= 0x0020u,	/* Includes vertical Device table for placement */

    xAdvDevice	= 0x0040u,	/* Includes horizontal Device table for advance */

    yAdvDevice	= 0x0080u,	/* Includes vertical Device table for advance */

    ignored	= 0x0F00u,	/* Was used in TrueType Open for MM fonts */

    reserved	= 0xF000u,	/* For future use */

    devices	= 0x00F0u	/* Mask for having any Device table */

  };

/* All fields are options.  Only those available advance the value pointer. */

#if 0

  SHORT		xPlacement;		/* Horizontal adjustment for

					 * placement--in design units */

  SHORT		yPlacement;		/* Vertical adjustment for

					 * placement--in design units */

  SHORT		xAdvance;		/* Horizontal adjustment for

					 * advance--in design units (only used

					 * for horizontal writing) */

  SHORT		yAdvance;		/* Vertical adjustment for advance--in

					 * design units (only used for vertical

					 * writing) */

  Offset	xPlaDevice;		/* Offset to Device table for

					 * horizontal placement--measured from

					 * beginning of PosTable (may be NULL) */

  Offset	yPlaDevice;		/* Offset to Device table for vertical

					 * placement--measured from beginning

					 * of PosTable (may be NULL) */

  Offset	xAdvDevice;		/* Offset to Device table for

					 * horizontal advance--measured from

					 * beginning of PosTable (may be NULL) */

  Offset	yAdvDevice;		/* Offset to Device table for vertical

					 * advance--measured from beginning of

					 * PosTable (may be NULL) */

#endif

  inline unsigned int get_len (void) const

  { return _hb_popcount32 ((unsigned int) *this); }

  inline unsigned int get_size (void) const

  { return get_len () * Value::static_size; }

  void apply_value (hb_apply_context_t   *c,

		    const void           *base,

		    const Value          *values,

		    hb_glyph_position_t  &glyph_pos) const

  {

    unsigned int format = *this;

    if (!format) return;

    hb_font_t *font = c->font;

    hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (c->direction);

    if (format & xPlacement) glyph_pos.x_offset  += font->em_scale_x (get_short (values++));

    if (format & yPlacement) glyph_pos.y_offset  += font->em_scale_y (get_short (values++));

    if (format & xAdvance) {

      if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values));

      values++;

    }

    /* y_advance values grow downward but font-space grows upward, hence negation */

    if (format & yAdvance) {

      if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values));

      values++;

    }

    if (!has_device ()) return;

    bool use_x_device = font->x_ppem || font->num_coords;

    bool use_y_device = font->y_ppem || font->num_coords;

    if (!use_x_device && !use_y_device) return;

    const VariationStore &store = c->var_store;

    /* pixel -> fractional pixel */

    if (format & xPlaDevice) {

      if (use_x_device) glyph_pos.x_offset  += (base + get_device (values)).get_x_delta (font, store);

      values++;

    }

    if (format & yPlaDevice) {

      if (use_y_device) glyph_pos.y_offset  += (base + get_device (values)).get_y_delta (font, store);

      values++;

    }

    if (format & xAdvDevice) {

      if (horizontal && use_x_device) glyph_pos.x_advance += (base + get_device (values)).get_x_delta (font, store);

      values++;

    }

    if (format & yAdvDevice) {

      /* y_advance values grow downward but font-space grows upward, hence negation */

      if (!horizontal && use_y_device) glyph_pos.y_advance -= (base + get_device (values)).get_y_delta (font, store);

      values++;

    }

  }

  private:

  inline bool sanitize_value_devices (hb_sanitize_context_t *c, const void *base, const Value *values) const

  {

    unsigned int format = *this;

    if (format & xPlacement) values++;

    if (format & yPlacement) values++;

    if (format & xAdvance)   values++;

    if (format & yAdvance)   values++;

    if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;

    if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;

    if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;

    if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;

    return true;

  }

  static inline OffsetTo<Device>& get_device (Value* value)

  { return *CastP<OffsetTo<Device> > (value); }

  static inline const OffsetTo<Device>& get_device (const Value* value)

  { return *CastP<OffsetTo<Device> > (value); }

  static inline const SHORT& get_short (const Value* value)

  { return *CastP<SHORT> (value); }

  public:

  inline bool has_device (void) const {

    unsigned int format = *this;

    return (format & devices) != 0;

  }

  inline bool sanitize_value (hb_sanitize_context_t *c, const void *base, const Value *values) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_range (values, get_size ()) && (!has_device () || sanitize_value_devices (c, base, values)));

  }

  inline bool sanitize_values (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count) const

  {

    TRACE_SANITIZE (this);

    unsigned int len = get_len ();

    if (!c->check_array (values, get_size (), count)) return_trace (false);

    if (!has_device ()) return_trace (true);

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

      if (!sanitize_value_devices (c, base, values))

        return_trace (false);

      values += len;

    }

    return_trace (true);

  }

  /* Just sanitize referenced Device tables.  Doesn't check the values themselves. */

  inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count, unsigned int stride) const

  {

    TRACE_SANITIZE (this);

    if (!has_device ()) return_trace (true);

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

      if (!sanitize_value_devices (c, base, values))

        return_trace (false);

      values += stride;

    }

    return_trace (true);

  }

};

struct AnchorFormat1

{

  inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,

			  hb_position_t *x, hb_position_t *y) const

  {

    hb_font_t *font = c->font;

    *x = font->em_scale_x (xCoordinate);

    *y = font->em_scale_y (yCoordinate);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

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

  SHORT		xCoordinate;		/* Horizontal value--in design units */

  SHORT		yCoordinate;		/* Vertical value--in design units */

  public:

  DEFINE_SIZE_STATIC (6);

};

struct AnchorFormat2

{

  inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id,

			  hb_position_t *x, hb_position_t *y) const

  {

    hb_font_t *font = c->font;

    unsigned int x_ppem = font->x_ppem;

    unsigned int y_ppem = font->y_ppem;

    hb_position_t cx, cy;

    hb_bool_t ret;

    ret = (x_ppem || y_ppem) &&

	   font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);

    *x = ret && x_ppem ? cx : font->em_scale_x (xCoordinate);

    *y = ret && y_ppem ? cy : font->em_scale_y (yCoordinate);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

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

  SHORT		xCoordinate;		/* Horizontal value--in design units */

  SHORT		yCoordinate;		/* Vertical value--in design units */

  USHORT	anchorPoint;		/* Index to glyph contour point */

  public:

  DEFINE_SIZE_STATIC (8);

};

struct AnchorFormat3

{

  inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,

			  hb_position_t *x, hb_position_t *y) const

  {

    hb_font_t *font = c->font;

    *x = font->em_scale_x (xCoordinate);

    *y = font->em_scale_y (yCoordinate);

    if (font->x_ppem || font->num_coords)

      *x += (this+xDeviceTable).get_x_delta (font, c->var_store);

    if (font->y_ppem || font->num_coords)

      *y += (this+yDeviceTable).get_y_delta (font, c->var_store);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));

  }

  protected:

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

  SHORT		xCoordinate;		/* Horizontal value--in design units */

  SHORT		yCoordinate;		/* Vertical value--in design units */

  OffsetTo<Device>

		xDeviceTable;		/* Offset to Device table for X

					 * coordinate-- from beginning of

					 * Anchor table (may be NULL) */

  OffsetTo<Device>

		yDeviceTable;		/* Offset to Device table for Y

					 * coordinate-- from beginning of

					 * Anchor table (may be NULL) */

  public:

  DEFINE_SIZE_STATIC (10);

};

struct Anchor

{

  inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id,

			  hb_position_t *x, hb_position_t *y) const

  {

    *x = *y = 0;

    switch (u.format) {

    case 1: u.format1.get_anchor (c, glyph_id, x, y); return;

    case 2: u.format2.get_anchor (c, glyph_id, x, y); return;

    case 3: u.format3.get_anchor (c, glyph_id, x, y); return;

    default:						 return;

    }

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    if (!u.format.sanitize (c)) return_trace (false);

    switch (u.format) {

    case 1: return_trace (u.format1.sanitize (c));

    case 2: return_trace (u.format2.sanitize (c));

    case 3: return_trace (u.format3.sanitize (c));

    default:return_trace (true);

    }

  }

  protected:

  union {

  USHORT		format;		/* Format identifier */

  AnchorFormat1		format1;

  AnchorFormat2		format2;

  AnchorFormat3		format3;

  } u;

  public:

  DEFINE_SIZE_UNION (2, format);

};

struct AnchorMatrix

{

  inline const Anchor& get_anchor (unsigned int row, unsigned int col, unsigned int cols, bool *found) const {

    *found = false;

    if (unlikely (row >= rows || col >= cols)) return Null(Anchor);

    *found = !matrixZ[row * cols + col].is_null ();

    return this+matrixZ[row * cols + col];

  }

  inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const

  {

    TRACE_SANITIZE (this);

    if (!c->check_struct (this)) return_trace (false);

    if (unlikely (_hb_unsigned_int_mul_overflows (rows, cols))) return_trace (false);

    unsigned int count = rows * cols;

    if (!c->check_array (matrixZ, matrixZ[0].static_size, count)) return_trace (false);

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

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

    return_trace (true);

  }

  USHORT	rows;			/* Number of rows */

  protected:

  OffsetTo<Anchor>

		matrixZ[VAR];		/* Matrix of offsets to Anchor tables--

					 * from beginning of AnchorMatrix table */

  public:

  DEFINE_SIZE_ARRAY (2, matrixZ);

};

struct MarkRecord

{

  friend struct MarkArray;

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

  {

    TRACE_SANITIZE (this);

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

  }

  protected:

  USHORT	klass;			/* Class defined for this mark */

  OffsetTo<Anchor>

		markAnchor;		/* Offset to Anchor table--from

					 * beginning of MarkArray table */

  public:

  DEFINE_SIZE_STATIC (4);

};

struct MarkArray : ArrayOf<MarkRecord>	/* Array of MarkRecords--in Coverage order */

{

  inline bool apply (hb_apply_context_t *c,

		     unsigned int mark_index, unsigned int glyph_index,

		     const AnchorMatrix &anchors, unsigned int class_count,

		     unsigned int glyph_pos) const

  {

    TRACE_APPLY (this);

    hb_buffer_t *buffer = c->buffer;

    const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);

    unsigned int mark_class = record.klass;

    const Anchor& mark_anchor = this + record.markAnchor;

    bool found;

    const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count, &found);

    /* If this subtable doesn't have an anchor for this base and this class,

     * return false such that the subsequent subtables have a chance at it. */

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

    hb_position_t mark_x, mark_y, base_x, base_y;

    mark_anchor.get_anchor (c, buffer->cur().codepoint, &mark_x, &mark_y);

    glyph_anchor.get_anchor (c, buffer->info[glyph_pos].codepoint, &base_x, &base_y);

    hb_glyph_position_t &o = buffer->cur_pos();

    o.x_offset = base_x - mark_x;

    o.y_offset = base_y - mark_y;

    o.attach_type() = ATTACH_TYPE_MARK;

    o.attach_chain() = (int) glyph_pos - (int) buffer->idx;

    buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;

    buffer->idx++;

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (ArrayOf<MarkRecord>::sanitize (c, this));

  }

};

/* Lookups */

struct SinglePosFormat1

{

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

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

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_buffer_t *buffer = c->buffer;

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

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

    valueFormat.apply_value (c, this, values, buffer->cur_pos());

    buffer->idx++;

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

		  coverage.sanitize (c, this) &&

		  valueFormat.sanitize_value (c, this, values));

  }

  protected:

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

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of subtable */

  ValueFormat	valueFormat;		/* Defines the types of data in the

					 * ValueRecord */

  ValueRecord	values;			/* Defines positioning

					 * value(s)--applied to all glyphs in

					 * the Coverage table */

  public:

  DEFINE_SIZE_ARRAY (6, values);

};

struct SinglePosFormat2

{

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

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

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_buffer_t *buffer = c->buffer;

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

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

    if (likely (index >= valueCount)) return_trace (false);

    valueFormat.apply_value (c, this,

			     &values[index * valueFormat.get_len ()],

			     buffer->cur_pos());

    buffer->idx++;

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

		  coverage.sanitize (c, this) &&

		  valueFormat.sanitize_values (c, this, values, valueCount));

  }

  protected:

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

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of subtable */

  ValueFormat	valueFormat;		/* Defines the types of data in the

					 * ValueRecord */

  USHORT	valueCount;		/* Number of ValueRecords */

  ValueRecord	values;			/* Array of ValueRecords--positioning

					 * values applied to glyphs */

  public:

  DEFINE_SIZE_ARRAY (8, values);

};

struct SinglePos

{

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

  SinglePosFormat1	format1;

  SinglePosFormat2	format2;

  } u;

};

struct PairValueRecord

{

  friend struct PairSet;

  protected:

  GlyphID	secondGlyph;		/* GlyphID of second glyph in the

					 * pair--first glyph is listed in the

					 * Coverage table */

  ValueRecord	values;			/* Positioning data for the first glyph

					 * followed by for second glyph */

  public:

  DEFINE_SIZE_ARRAY (2, values);

};

struct PairSet

{

  friend struct PairPosFormat1;

  inline void collect_glyphs (hb_collect_glyphs_context_t *c,

			      const ValueFormat *valueFormats) const

  {

    TRACE_COLLECT_GLYPHS (this);

    unsigned int len1 = valueFormats[0].get_len ();

    unsigned int len2 = valueFormats[1].get_len ();

    unsigned int record_size = USHORT::static_size * (1 + len1 + len2);

    const PairValueRecord *record = CastP<PairValueRecord> (arrayZ);

    unsigned int count = len;

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

    {

      c->input->add (record->secondGlyph);

      record = &StructAtOffset<PairValueRecord> (record, record_size);

    }

  }

  inline bool apply (hb_apply_context_t *c,

		     const ValueFormat *valueFormats,

		     unsigned int pos) const

  {

    TRACE_APPLY (this);

    hb_buffer_t *buffer = c->buffer;

    unsigned int len1 = valueFormats[0].get_len ();

    unsigned int len2 = valueFormats[1].get_len ();

    unsigned int record_size = USHORT::static_size * (1 + len1 + len2);

    const PairValueRecord *record_array = CastP<PairValueRecord> (arrayZ);

    unsigned int count = len;

    /* Hand-coded bsearch. */

    if (unlikely (!count))

      return_trace (false);

    hb_codepoint_t x = buffer->info[pos].codepoint;

    int min = 0, max = (int) count - 1;

    while (min <= max)

    {

      int mid = (min + max) / 2;

      const PairValueRecord *record = &StructAtOffset<PairValueRecord> (record_array, record_size * mid);

      hb_codepoint_t mid_x = record->secondGlyph;

      if (x < mid_x)

        max = mid - 1;

      else if (x > mid_x)

        min = mid + 1;

      else

      {

	valueFormats[0].apply_value (c, this, &record->values[0], buffer->cur_pos());

	valueFormats[1].apply_value (c, this, &record->values[len1], buffer->pos[pos]);

	if (len2)

	  pos++;

	buffer->idx = pos;

	return_trace (true);

      }

    }

    return_trace (false);

  }

  struct sanitize_closure_t {

    const void *base;

    const ValueFormat *valueFormats;

    unsigned int len1; /* valueFormats[0].get_len() */

    unsigned int stride; /* 1 + len1 + len2 */

  };

  inline bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const

  {

    TRACE_SANITIZE (this);

    if (!(c->check_struct (this)

       && c->check_array (arrayZ, USHORT::static_size * closure->stride, len))) return_trace (false);

    unsigned int count = len;

    const PairValueRecord *record = CastP<PairValueRecord> (arrayZ);

    return_trace (closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride) &&

		  closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride));

  }

  protected:

  USHORT	len;			/* Number of PairValueRecords */

  USHORT	arrayZ[VAR];		/* Array of PairValueRecords--ordered

					 * by GlyphID of the second glyph */

  public:

  DEFINE_SIZE_ARRAY (2, arrayZ);

};

struct PairPosFormat1

{

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

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

    unsigned int count = pairSet.len;

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

      (this+pairSet[i]).collect_glyphs (c, valueFormat);

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_buffer_t *buffer = c->buffer;

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

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

    hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;

    skippy_iter.reset (buffer->idx, 1);

    if (!skippy_iter.next ()) return_trace (false);

    return_trace ((this+pairSet[index]).apply (c, valueFormat, skippy_iter.idx));

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    if (!c->check_struct (this)) return_trace (false);

    unsigned int len1 = valueFormat[0].get_len ();

    unsigned int len2 = valueFormat[1].get_len ();

    PairSet::sanitize_closure_t closure = {

      this,

      valueFormat,

      len1,

      1 + len1 + len2

    };

    return_trace (coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure));

  }

  protected:

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

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of subtable */

  ValueFormat	valueFormat[2];		/* [0] Defines the types of data in

					 * ValueRecord1--for the first glyph

					 * in the pair--may be zero (0) */

					/* [1] Defines the types of data in

					 * ValueRecord2--for the second glyph

					 * in the pair--may be zero (0) */

  OffsetArrayOf<PairSet>

		pairSet;		/* Array of PairSet tables

					 * ordered by Coverage Index */

  public:

  DEFINE_SIZE_ARRAY (10, pairSet);

};

struct PairPosFormat2

{

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

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

    unsigned int count1 = class1Count;

    const ClassDef &klass1 = this+classDef1;

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

      klass1.add_class (c->input, i);

    unsigned int count2 = class2Count;

    const ClassDef &klass2 = this+classDef2;

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

      klass2.add_class (c->input, i);

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_buffer_t *buffer = c->buffer;

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

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

    hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;

    skippy_iter.reset (buffer->idx, 1);

    if (!skippy_iter.next ()) return_trace (false);

    unsigned int len1 = valueFormat1.get_len ();

    unsigned int len2 = valueFormat2.get_len ();

    unsigned int record_len = len1 + len2;

    unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint);

    unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);

    if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) return_trace (false);

    const Value *v = &values[record_len * (klass1 * class2Count + klass2)];

    valueFormat1.apply_value (c, this, v, buffer->cur_pos());

    valueFormat2.apply_value (c, this, v + len1, buffer->pos[skippy_iter.idx]);

    buffer->idx = skippy_iter.idx;

    if (len2)

      buffer->idx++;

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    if (!(c->check_struct (this)

       && coverage.sanitize (c, this)

       && classDef1.sanitize (c, this)

       && classDef2.sanitize (c, this))) return_trace (false);

    unsigned int len1 = valueFormat1.get_len ();

    unsigned int len2 = valueFormat2.get_len ();

    unsigned int stride = len1 + len2;

    unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();

    unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;

    return_trace (c->check_array (values, record_size, count) &&

		  valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&

		  valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride));

  }

  protected:

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

  OffsetTo<Coverage>

		coverage;		/* Offset to Coverage table--from

					 * beginning of subtable */

  ValueFormat	valueFormat1;		/* ValueRecord definition--for the

					 * first glyph of the pair--may be zero

					 * (0) */

  ValueFormat	valueFormat2;		/* ValueRecord definition--for the

					 * second glyph of the pair--may be

					 * zero (0) */

  OffsetTo<ClassDef>

		classDef1;		/* Offset to ClassDef table--from

					 * beginning of PairPos subtable--for

					 * the first glyph of the pair */

  OffsetTo<ClassDef>

		classDef2;		/* Offset to ClassDef table--from

					 * beginning of PairPos subtable--for

					 * the second glyph of the pair */

  USHORT	class1Count;		/* Number of classes in ClassDef1

					 * table--includes Class0 */

  USHORT	class2Count;		/* Number of classes in ClassDef2

					 * table--includes Class0 */

  ValueRecord	values;			/* Matrix of value pairs:

					 * class1-major, class2-minor,

					 * Each entry has value1 and value2 */

  public:

  DEFINE_SIZE_ARRAY (16, values);

};

struct PairPos

{

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

  PairPosFormat1	format1;

  PairPosFormat2	format2;

  } u;

};

struct EntryExitRecord

{

  friend struct CursivePosFormat1;

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

  {