Update harfbuzz-ng to 1a5a91dc0d8bf4b72a2f22dc6300b06ad7000b79.

third_party/harfbuzz-ng/src/hb-ot-layout-gpos-table.hh

 /*
- * Copyright (C) 2007,2008,2009,2010  Red Hat, Inc.
- * Copyright (C) 2010  Google, Inc.
+ * Copyright © 2007,2008,2009,2010  Red Hat, Inc.
+ * Copyright © 2010  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_PRIVATE_HH
-#define HB_OT_LAYOUT_GPOS_PRIVATE_HH
+#ifndef HB_OT_LAYOUT_GPOS_TABLE_HH
+#define HB_OT_LAYOUT_GPOS_TABLE_HH
 
 #include "hb-ot-layout-gsubgpos-private.hh"
 
-HB_BEGIN_DECLS
 
 
-/* buffer var allocations */
+/* buffer **position** var allocations */
 #define attach_lookback() var.u16[0] /* number of glyphs to go back to attach this glyph to its base */
 #define cursive_chain() var.i16[1] /* character to which this connects, may be positive or negative */
 
 
 /* Shared Tables: ValueRecord, Anchor Table, and MarkArray */
 
 typedef USHORT Value;
 
 typedef Value ValueRecord[VAR];
 
@@ skipping 39 matching lines @@
   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_ot_layout_context_t *layout,
-                    const void             *base,
-                    const Value            *values,
-                    hb_glyph_position_t    &glyph_pos) const
+  void apply_value (hb_font_t            *font,
+                    hb_direction_t        direction,
+                    const void           *base,
+                    const Value          *values,
+                    hb_glyph_position_t  &glyph_pos) const
   {
     unsigned int x_ppem, y_ppem;
     unsigned int format = *this;
+    hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (direction);
 
     if (!format) return;
 
-    /* design units -> fractional pixel */
-    if (format & xPlacement) glyph_pos.x_offset  += layout->scale_x (get_short (values++));
-    if (format & yPlacement) glyph_pos.y_offset  += layout->scale_y (get_short (values++));
-    if (format & xAdvance)   glyph_pos.x_advance += layout->scale_x (get_short (values++));
-    if (format & yAdvance)   glyph_pos.y_advance += layout->scale_y (get_short (values++));
+    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++)); else 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++)); else values++;
+    }
 
     if (!has_device ()) return;
 
-    x_ppem = layout->font->x_ppem;
-    y_ppem = layout->font->y_ppem;
+    x_ppem = font->x_ppem;
+    y_ppem = font->y_ppem;
 
     if (!x_ppem && !y_ppem) return;
 
     /* pixel -> fractional pixel */
     if (format & xPlaDevice) {
-      if (x_ppem) glyph_pos.x_offset  += (base + get_device (values++)).get_x_delta (layout); else values++;
+      if (x_ppem) glyph_pos.x_offset  += (base + get_device (values++)).get_x_delta (font); else values++;
     }
     if (format & yPlaDevice) {
-      if (y_ppem) glyph_pos.y_offset  += (base + get_device (values++)).get_y_delta (layout); else values++;
+      if (y_ppem) glyph_pos.y_offset  += (base + get_device (values++)).get_y_delta (font); else values++;
     }
     if (format & xAdvDevice) {
-      if (x_ppem) glyph_pos.x_advance += (base + get_device (values++)).get_x_delta (layout); else values++;
+      if (horizontal && x_ppem) glyph_pos.x_advance += (base + get_device (values++)).get_x_delta (font); else values++;
     }
     if (format & yAdvDevice) {
-      if (y_ppem) glyph_pos.y_advance += (base + get_device (values++)).get_y_delta (layout); else values++;
+      /* y_advance values grow downward but font-space grows upward, hence negation */
+      if (!horizontal && y_ppem) glyph_pos.y_advance -= (base + get_device (values++)).get_y_delta (font); else values++;
     }
   }
 
   private:
   inline bool sanitize_value_devices (hb_sanitize_context_t *c, void *base, Value *values) {
     unsigned int format = *this;
 
     if (format & xPlacement) values++;
     if (format & yPlacement) values++;
     if (format & xAdvance)   values++;
@@ skipping 60 matching lines @@
     return true;
   }
 };
 
 
 struct AnchorFormat1
 {
   friend struct Anchor;
 
   private:
-  inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id HB_UNUSED,
+  inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,
                           hb_position_t *x, hb_position_t *y) const
   {
-      *x = layout->scale_x (xCoordinate);
-      *y = layout->scale_y (yCoordinate);
+      *x = font->em_scale_x (xCoordinate);
+      *y = font->em_scale_y (yCoordinate);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return c->check_struct (this);
   }
 
   private:
   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
 {
   friend struct Anchor;
 
   private:
-  inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id,
+  inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,
                           hb_position_t *x, hb_position_t *y) const
   {
-      unsigned int x_ppem = layout->font->x_ppem;
-      unsigned int y_ppem = layout->font->y_ppem;
+      unsigned int x_ppem = font->x_ppem;
+      unsigned int y_ppem = font->y_ppem;
       hb_position_t cx, cy;
       hb_bool_t ret = false;
 
       if (x_ppem || y_ppem)
-        ret = hb_font_get_contour_point (layout->font, layout->face, anchorPoint, glyph_id, &cx, &cy);
-      *x = x_ppem && ret ? cx : layout->scale_x (xCoordinate);
-      *y = y_ppem && ret ? cy : layout->scale_y (yCoordinate);
+        ret = hb_font_get_glyph_contour_point_for_origin (font, glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);
+      *x = x_ppem && ret ? cx : font->em_scale_x (xCoordinate);
+      *y = y_ppem && ret ? cy : font->em_scale_y (yCoordinate);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return c->check_struct (this);
   }
 
   private:
   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
 {
   friend struct Anchor;
 
   private:
-  inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id HB_UNUSED,
+  inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,
                           hb_position_t *x, hb_position_t *y) const
   {
-      *x = layout->scale_x (xCoordinate);
-      *y = layout->scale_y (yCoordinate);
+      *x = font->em_scale_x (xCoordinate);
+      *y = font->em_scale_y (yCoordinate);
 
-      /* pixel -> fractional pixel */
-      if (layout->font->x_ppem)
-        *x += (this+xDeviceTable).get_x_delta (layout);
-      if (layout->font->y_ppem)
-        *y += (this+yDeviceTable).get_x_delta (layout);
+      if (font->x_ppem)
+        *x += (this+xDeviceTable).get_x_delta (font);
+      if (font->y_ppem)
+        *y += (this+yDeviceTable).get_x_delta (font);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return c->check_struct (this)
         && xDeviceTable.sanitize (c, this)
         && yDeviceTable.sanitize (c, this);
   }
 
   private:
   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_ot_layout_context_t *layout, hb_codepoint_t glyph_id,
+  inline void get_anchor (hb_font_t *font, 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 (layout, glyph_id, x, y); return;
-    case 2: u.format2.get_anchor (layout, glyph_id, x, y); return;
-    case 3: u.format3.get_anchor (layout, glyph_id, x, y); return;
-    default:                                                return;
+    case 1: u.format1.get_anchor (font, glyph_id, x, y); return;
+    case 2: u.format2.get_anchor (font, glyph_id, x, y); return;
+    case 3: u.format3.get_anchor (font, glyph_id, x, y); return;
+    default:                                             return;
     }
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     if (!u.format.sanitize (c)) return false;
     switch (u.format) {
     case 1: return u.format1.sanitize (c);
     case 2: return u.format2.sanitize (c);
     case 3: return u.format3.sanitize (c);
@@ skipping 69 matching lines @@
   {
     TRACE_APPLY ();
     const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);
     unsigned int mark_class = record.klass;
 
     const Anchor& mark_anchor = this + record.markAnchor;
     const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count);
 
     hb_position_t mark_x, mark_y, base_x, base_y;
 
-    mark_anchor.get_anchor (c->layout, c->buffer->info[c->buffer->i].codepoint, &mark_x, &mark_y);
-    glyph_anchor.get_anchor (c->layout, c->buffer->info[glyph_pos].codepoint, &base_x, &base_y);
+    mark_anchor.get_anchor (c->font, c->buffer->info[c->buffer->idx].codepoint, &mark_x, &mark_y);
+    glyph_anchor.get_anchor (c->font, c->buffer->info[glyph_pos].codepoint, &base_x, &base_y);
 
-    hb_glyph_position_t &o = c->buffer->pos[c->buffer->i];
+    hb_glyph_position_t &o = c->buffer->pos[c->buffer->idx];
     o.x_offset = base_x - mark_x;
     o.y_offset = base_y - mark_y;
-    o.attach_lookback() = c->buffer->i - glyph_pos;
+    o.attach_lookback() = c->buffer->idx - glyph_pos;
 
-    c->buffer->i++;
+    c->buffer->idx++;
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return ArrayOf<MarkRecord>::sanitize (c, this);
   }
 };
 
 
 /* Lookups */
 
 struct SinglePosFormat1
 {
   friend struct SinglePos;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
-    valueFormat.apply_value (c->layout, this, values, c->buffer->pos[c->buffer->i]);
+    valueFormat.apply_value (c->font, c->direction, this,
+                             values, c->buffer->pos[c->buffer->idx]);
 
-    c->buffer->i++;
+    c->buffer->idx++;
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return c->check_struct (this)
         && coverage.sanitize (c, this)
         && valueFormat.sanitize_value (c, this, values);
   }
 
@@ skipping 12 matching lines @@
 };
 
 struct SinglePosFormat2
 {
   friend struct SinglePos;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
     if (likely (index >= valueCount))
       return false;
 
-    valueFormat.apply_value (c->layout, this,
+    valueFormat.apply_value (c->font, c->direction, this,
                              &values[index * valueFormat.get_len ()],
-                             c->buffer->pos[c->buffer->i]);
+                             c->buffer->pos[c->buffer->idx]);
 
-    c->buffer->i++;
+    c->buffer->idx++;
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return c->check_struct (this)
         && coverage.sanitize (c, this)
         && valueFormat.sanitize_values (c, this, values, valueCount);
   }
 
@@ skipping 71 matching lines @@
     unsigned int len1 = valueFormats[0].get_len ();
     unsigned int len2 = valueFormats[1].get_len ();
     unsigned int record_size = USHORT::static_size * (1 + len1 + len2);
 
     unsigned int count = len;
     const PairValueRecord *record = CastP<PairValueRecord> (array);
     for (unsigned int i = 0; i < count; i++)
     {
       if (c->buffer->info[pos].codepoint == record->secondGlyph)
       {
-        valueFormats[0].apply_value (c->layout, this, &record->values[0], c->buffer->pos[c->buffer->i]);
-        valueFormats[1].apply_value (c->layout, this, &record->values[len1], c->buffer->pos[pos]);
+        valueFormats[0].apply_value (c->font, c->direction, this,
+                                     &record->values[0], c->buffer->pos[c->buffer->idx]);
+        valueFormats[1].apply_value (c->font, c->direction, this,
+                                     &record->values[len1], c->buffer->pos[pos]);
         if (len2)
           pos++;
-        c->buffer->i = pos;
+        c->buffer->idx = pos;
         return true;
       }
       record = &StructAtOffset<PairValueRecord> (record, record_size);
     }
 
     return false;
   }
 
   struct sanitize_closure_t {
     void *base;
@@ skipping 22 matching lines @@
 };
 
 struct PairPosFormat1
 {
   friend struct PairPos;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
-    if (unlikely (c->buffer->i + 2 > end))
+    hb_apply_context_t::mark_skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, 1);
+    if (skippy_iter.has_no_chance ())
       return false;
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
-    unsigned int j = c->buffer->i + 1;
-    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, NULL))
-    {
-      if (unlikely (j == end))
-        return false;
-      j++;
-    }
+    if (!skippy_iter.next ())
+      return false;
 
-    return (this+pairSet[index]).apply (c, &valueFormat1, j);
+    return (this+pairSet[index]).apply (c, &valueFormat1, skippy_iter.idx);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
 
     unsigned int len1 = valueFormat1.get_len ();
     unsigned int len2 = valueFormat2.get_len ();
     PairSet::sanitize_closure_t closure = {
       this,
       &valueFormat1,
@@ skipping 25 matching lines @@
 };
 
 struct PairPosFormat2
 {
   friend struct PairPos;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
-    if (unlikely (c->buffer->i + 2 > end))
+    hb_apply_context_t::mark_skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, 1);
+    if (skippy_iter.has_no_chance ())
       return false;
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
-    unsigned int j = c->buffer->i + 1;
-    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, NULL))
-    {
-      if (unlikely (j == end))
-        return false;
-      j++;
-    }
+    if (!skippy_iter.next ())
+      return false;
 
     unsigned int len1 = valueFormat1.get_len ();
     unsigned int len2 = valueFormat2.get_len ();
     unsigned int record_len = len1 + len2;
 
-    unsigned int klass1 = (this+classDef1) (c->buffer->info[c->buffer->i].codepoint);
-    unsigned int klass2 = (this+classDef2) (c->buffer->info[j].codepoint);
+    unsigned int klass1 = (this+classDef1) (c->buffer->info[c->buffer->idx].codepoint);
+    unsigned int klass2 = (this+classDef2) (c->buffer->info[skippy_iter.idx].codepoint);
     if (unlikely (klass1 >= class1Count || klass2 >= class2Count))
       return false;
 
     const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
-    valueFormat1.apply_value (c->layout, this, v, c->buffer->pos[c->buffer->i]);
-    valueFormat2.apply_value (c->layout, this, v + len1, c->buffer->pos[j]);
+    valueFormat1.apply_value (c->font, c->direction, this,
+                              v, c->buffer->pos[c->buffer->idx]);
+    valueFormat2.apply_value (c->font, c->direction, this,
+                              v + len1, c->buffer->pos[skippy_iter.idx]);
 
+    c->buffer->idx = skippy_iter.idx;
     if (len2)
-      j++;
-    c->buffer->i = j;
+      c->buffer->idx++;
 
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     if (!(c->check_struct (this)
        && coverage.sanitize (c, this)
        && classDef1.sanitize (c, this)
        && classDef2.sanitize (c, this))) return false;
@@ skipping 101 matching lines @@
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
 
     /* We don't handle mark glyphs here. */
     if (c->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK)
       return false;
 
-    unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
-    if (unlikely (c->buffer->i + 2 > end))
+    hb_apply_context_t::mark_skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, 1);
+    if (skippy_iter.has_no_chance ())
       return false;
 
-    const EntryExitRecord &this_record = entryExitRecord[(this+coverage) (c->buffer->info[c->buffer->i].codepoint)];
+    const EntryExitRecord &this_record = entryExitRecord[(this+coverage) (c->buffer->info[c->buffer->idx].codepoint)];
     if (!this_record.exitAnchor)
       return false;
 
-    unsigned int j = c->buffer->i + 1;
-    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, NULL))
-    {
-      if (unlikely (j == end))
-        return false;
-      j++;
-    }
+    if (!skippy_iter.next ())
+      return false;
 
-    const EntryExitRecord &next_record = entryExitRecord[(this+coverage) (c->buffer->info[j].codepoint)];
+    const EntryExitRecord &next_record = entryExitRecord[(this+coverage) (c->buffer->info[skippy_iter.idx].codepoint)];
     if (!next_record.entryAnchor)
       return false;
 
-    unsigned int i = c->buffer->i;
+    unsigned int i = c->buffer->idx;
+    unsigned int j = skippy_iter.idx;
 
     hb_position_t entry_x, entry_y, exit_x, exit_y;
-    (this+this_record.exitAnchor).get_anchor (c->layout, c->buffer->info[i].codepoint, &exit_x, &exit_y);
-    (this+next_record.entryAnchor).get_anchor (c->layout, c->buffer->info[j].codepoint, &entry_x, &entry_y);
+    (this+this_record.exitAnchor).get_anchor (c->font, c->buffer->info[i].codepoint, &exit_x, &exit_y);
+    (this+next_record.entryAnchor).get_anchor (c->font, c->buffer->info[j].codepoint, &entry_x, &entry_y);
 
-    hb_direction_t direction = c->buffer->props.direction;
+    hb_glyph_position_t *pos = c->buffer->pos;
 
-    /* Align the exit anchor of the left/top glyph with the entry anchor of the right/bottom glyph
-     * by adjusting advance of the left/top glyph. */
-    if (HB_DIRECTION_IS_BACKWARD (direction))
-    {
-      if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
-        c->buffer->pos[j].x_advance = c->buffer->pos[j].x_offset + entry_x - exit_x;
-      else
-        c->buffer->pos[j].y_advance = c->buffer->pos[j].y_offset + entry_y - exit_y;
-    }
-    else
-    {
-      if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
-        c->buffer->pos[i].x_advance = c->buffer->pos[i].x_offset + exit_x - entry_x;
-      else
-        c->buffer->pos[i].y_advance = c->buffer->pos[i].y_offset + exit_y - entry_y;
+    hb_position_t d;
+    /* Main-direction adjustment */
+    switch (c->direction) {
+      case HB_DIRECTION_LTR:
+        pos[i].x_advance  =  exit_x + pos[i].x_offset;
+
+        d = entry_x + pos[j].x_offset;
+        pos[j].x_advance -= d;
+        pos[j].x_offset  -= d;
+        break;
+      case HB_DIRECTION_RTL:
+        d = exit_x + pos[i].x_offset;
+        pos[i].x_advance -= d;
+        pos[i].x_offset  -= d;
+
+        pos[j].x_advance  =  entry_x + pos[j].x_offset;
+        break;
+      case HB_DIRECTION_TTB:
+        pos[i].y_advance  =  exit_y + pos[i].y_offset;
+
+        d = entry_y + pos[j].y_offset;
+        pos[j].y_advance -= d;
+        pos[j].y_offset  -= d;
+        break;
+      case HB_DIRECTION_BTT:
+        d = exit_y + pos[i].y_offset;
+        pos[i].y_advance -= d;
+        pos[i].y_offset  -= d;
+
+        pos[j].y_advance  =  entry_y;
+        break;
+      case HB_DIRECTION_INVALID:
+      default:
+        break;
     }
 
-    if  (c->lookup_props & LookupFlag::RightToLeft)
-    {
-      c->buffer->pos[i].cursive_chain() = j - i;
-      if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
-        c->buffer->pos[i].y_offset = entry_y - exit_y;
+    /* Cross-direction adjustment */
+    if  (c->lookup_props & LookupFlag::RightToLeft) {
+      pos[i].cursive_chain() = j - i;
+      if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
+        pos[i].y_offset = entry_y - exit_y;
       else
-        c->buffer->pos[i].x_offset = entry_x - exit_x;
-    }
-    else
-    {
-      c->buffer->pos[j].cursive_chain() = i - j;
-      if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
-        c->buffer->pos[j].y_offset = exit_y - entry_y;
+        pos[i].x_offset = entry_x - exit_x;
+    } else {
+      pos[j].cursive_chain() = i - j;
+      if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
+        pos[j].y_offset = exit_y - entry_y;
       else
-        c->buffer->pos[j].x_offset = exit_x - entry_x;
+        pos[j].x_offset = exit_x - entry_x;
     }
 
-    c->buffer->i = j;
+    c->buffer->idx = j;
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return coverage.sanitize (c, this)
         && entryExitRecord.sanitize (c, this);
   }
 
   private:
@@ skipping 45 matching lines @@
                                          * ordered by class--zero-based. */
 
 struct MarkBasePosFormat1
 {
   friend struct MarkBasePos;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (mark_index == NOT_COVERED))
       return false;
 
     /* now we search backwards for a non-mark glyph */
     unsigned int property;
-    unsigned int j = c->buffer->i;
-    do
-    {
-      if (unlikely (!j))
-        return false;
-      j--;
-    } while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], LookupFlag::IgnoreMarks, &property));
+    hb_apply_context_t::mark_skipping_backward_iterator_t skippy_iter (c, c->buffer->idx, 1);
+    if (!skippy_iter.prev (&property, LookupFlag::IgnoreMarks))
+      return false;
 
     /* The following assertion is too strong, so we've disabled it. */
     if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH))
     {/*return false;*/}
 
-    unsigned int base_index = (this+baseCoverage) (c->buffer->info[j].codepoint);
+    unsigned int base_index = (this+baseCoverage) (c->buffer->info[skippy_iter.idx].codepoint);
     if (base_index == NOT_COVERED)
       return false;
 
-    return (this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, j);
+    return (this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return c->check_struct (this)
         && markCoverage.sanitize (c, this)
         && baseCoverage.sanitize (c, this)
         && markArray.sanitize (c, this)
         && baseArray.sanitize (c, this, (unsigned int) classCount);
   }
@@ skipping 59 matching lines @@
                                          * LigatureCoverage Index */
 
 struct MarkLigPosFormat1
 {
   friend struct MarkLigPos;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (mark_index == NOT_COVERED))
       return false;
 
     /* now we search backwards for a non-mark glyph */
     unsigned int property;
-    unsigned int j = c->buffer->i;
-    do
-    {
-      if (unlikely (!j))
-        return false;
-      j--;
-    } while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], LookupFlag::IgnoreMarks, &property));
+    hb_apply_context_t::mark_skipping_backward_iterator_t skippy_iter (c, c->buffer->idx, 1);
+    if (!skippy_iter.prev (&property, LookupFlag::IgnoreMarks))
+      return false;
 
     /* The following assertion is too strong, so we've disabled it. */
     if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE))
     {/*return false;*/}
 
+    unsigned int j = skippy_iter.idx;
     unsigned int lig_index = (this+ligatureCoverage) (c->buffer->info[j].codepoint);
     if (lig_index == NOT_COVERED)
       return false;
 
     const LigatureArray& lig_array = this+ligatureArray;
     const LigatureAttach& lig_attach = lig_array[lig_index];
 
     /* Find component to attach to */
     unsigned int comp_count = lig_attach.rows;
     if (unlikely (!comp_count))
       return false;
     unsigned int comp_index;
     /* We must now check whether the ligature ID of the current mark glyph
      * is identical to the ligature ID of the found ligature.  If yes, we
      * can directly use the component index.  If not, we attach the mark
      * glyph to the last component of the ligature. */
-    if (c->buffer->info[j].lig_id() && c->buffer->info[j].lig_id() == c->buffer->info[c->buffer->i].lig_id() && c->buffer->info[c->buffer->i].lig_comp())
+    if (c->buffer->info[j].lig_id() && c->buffer->info[j].lig_id() == c->buffer->info[c->buffer->idx].lig_id() && c->buffer->info[c->buffer->idx].lig_comp())
     {
-      comp_index = c->buffer->info[c->buffer->i].lig_comp() - 1;
+      comp_index = c->buffer->info[c->buffer->idx].lig_comp() - 1;
       if (comp_index >= comp_count)
         comp_index = comp_count - 1;
     }
     else
       comp_index = comp_count - 1;
 
     return (this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
@@ skipping 62 matching lines @@
                                          * ordered by class--zero-based. */
 
 struct MarkMarkPosFormat1
 {
   friend struct MarkMarkPos;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int mark1_index = (this+mark1Coverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int mark1_index = (this+mark1Coverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (mark1_index == NOT_COVERED))
       return false;
 
     /* now we search backwards for a suitable mark glyph until a non-mark glyph */
     unsigned int property;
-    unsigned int j = c->buffer->i;
-    do
-    {
-      if (unlikely (!j))
-        return false;
-      j--;
-    } while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, &property));
+    hb_apply_context_t::mark_skipping_backward_iterator_t skippy_iter (c, c->buffer->idx, 1);
+    if (!skippy_iter.prev (&property))
+      return false;
 
     if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_MARK))
       return false;
 
+    unsigned int j = skippy_iter.idx;
+
     /* Two marks match only if they belong to the same base, or same component
      * of the same ligature.  That is, the component numbers must match, and
      * if those are non-zero, the ligid number should also match. */
-    if ((c->buffer->info[j].lig_comp() != c->buffer->info[c->buffer->i].lig_comp()) ||
-        (c->buffer->info[j].lig_comp() && c->buffer->info[j].lig_id() != c->buffer->info[c->buffer->i].lig_id()))
+    if ((c->buffer->info[j].lig_comp() != c->buffer->info[c->buffer->idx].lig_comp()) ||
+        (c->buffer->info[j].lig_comp() && c->buffer->info[j].lig_id() != c->buffer->info[c->buffer->idx].lig_id()))
       return false;
 
     unsigned int mark2_index = (this+mark2Coverage) (c->buffer->info[j].codepoint);
     if (mark2_index == NOT_COVERED)
       return false;
 
     return (this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
@@ skipping 50 matching lines @@
   }
 
   private:
   union {
   USHORT                format;         /* Format identifier */
   MarkMarkPosFormat1    format1;
   } u;
 };
 
 
-HB_BEGIN_DECLS
 static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index);
-HB_END_DECLS
 
 struct ContextPos : Context
 {
   friend struct PosLookupSubTable;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     return Context::apply (c, position_lookup);
@@ skipping 102 matching lines @@
   public:
   DEFINE_SIZE_UNION (2, sub_format);
 };
 
 
 struct PosLookup : Lookup
 {
   inline const PosLookupSubTable& get_subtable (unsigned int i) const
   { return this+CastR<OffsetArrayOf<PosLookupSubTable> > (subTable)[i]; }
 
-  inline bool apply_once (hb_ot_layout_context_t *layout,
+  inline bool apply_once (hb_font_t *font,
                           hb_buffer_t *buffer,
                           hb_mask_t lookup_mask,
                           unsigned int context_length,
                           unsigned int nesting_level_left) const
   {
     unsigned int lookup_type = get_type ();
     hb_apply_context_t c[1] = {{0}};
 
-    c->layout = layout;
+    c->font = font;
+    c->face = font->face;
     c->buffer = buffer;
+    c->direction = buffer->props.direction;
     c->lookup_mask = lookup_mask;
     c->context_length = context_length;
     c->nesting_level_left = nesting_level_left;
     c->lookup_props = get_props ();
 
-    if (!_hb_ot_layout_check_glyph_property (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_props, &c->property))
+    if (!_hb_ot_layout_check_glyph_property (c->face, &c->buffer->info[c->buffer->idx], c->lookup_props, &c->property))
       return false;
 
     for (unsigned int i = 0; i < get_subtable_count (); i++)
       if (get_subtable (i).apply (c, lookup_type))
         return true;
 
     return false;
   }
 
-   inline bool apply_string (hb_ot_layout_context_t *layout,
+   inline bool apply_string (hb_font_t   *font,
                              hb_buffer_t *buffer,
                              hb_mask_t    mask) const
   {
     bool ret = false;
 
     if (unlikely (!buffer->len))
       return false;
 
-    buffer->i = 0;
-    while (buffer->i < buffer->len)
+    buffer->idx = 0;
+    while (buffer->idx < buffer->len)
     {
-      if ((buffer->info[buffer->i].mask & mask) &&
-          apply_once (layout, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL))
+      if ((buffer->info[buffer->idx].mask & mask) &&
+          apply_once (font, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL))
         ret = true;
       else
-        buffer->i++;
+        buffer->idx++;
     }
 
     return ret;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     if (unlikely (!Lookup::sanitize (c))) return false;
     OffsetArrayOf<PosLookupSubTable> &list = CastR<OffsetArrayOf<PosLookupSubTable> > (subTable);
     return list.sanitize (c, this, get_type ());
   }
 };
 
 typedef OffsetListOf<PosLookup> PosLookupList;
 
 /*
- * GPOS
+ * GPOS -- The Glyph Positioning Table
  */
 
 struct GPOS : GSUBGPOS
 {
   static const hb_tag_t Tag     = HB_OT_TAG_GPOS;
 
   inline const PosLookup& get_lookup (unsigned int i) const
   { return CastR<PosLookup> (GSUBGPOS::get_lookup (i)); }
 
-  inline bool position_lookup (hb_ot_layout_context_t *layout,
+  inline bool position_lookup (hb_font_t    *font,
                                hb_buffer_t  *buffer,
                                unsigned int  lookup_index,
                                hb_mask_t     mask) const
-  { return get_lookup (lookup_index).apply_string (layout, buffer, mask); }
+  { return get_lookup (lookup_index).apply_string (font, buffer, mask); }
 
+  static inline void position_start (hb_buffer_t *buffer);
   static inline void position_finish (hb_buffer_t *buffer);
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     if (unlikely (!GSUBGPOS::sanitize (c))) return false;
     OffsetTo<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
     return list.sanitize (c, this);
   }
   public:
   DEFINE_SIZE_STATIC (10);
 };
 
+
+static void
+fix_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction)
+{
+    unsigned int j = pos[i].cursive_chain();
+    if (likely (!j))
+      return;
+
+    j += i;
+
+    pos[i].cursive_chain() = 0;
+
+    fix_cursive_minor_offset (pos, j, direction);
+
+    if (HB_DIRECTION_IS_HORIZONTAL (direction))
+      pos[i].y_offset += pos[j].y_offset;
+    else
+      pos[i].x_offset += pos[j].x_offset;
+}
+
+static void
+fix_mark_attachment (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction)
+{
+  if (likely (!(pos[i].attach_lookback())))
+    return;
+
+  unsigned int j = i - pos[i].attach_lookback();
+
+  pos[i].x_advance = 0;
+  pos[i].y_advance = 0;
+  pos[i].x_offset += pos[j].x_offset;
+  pos[i].y_offset += pos[j].y_offset;
+
+  if (HB_DIRECTION_IS_FORWARD (direction))
+    for (unsigned int k = j; k < i; k++) {
+      pos[i].x_offset -= pos[k].x_advance;
+      pos[i].y_offset -= pos[k].y_advance;
+    }
+  else
+    for (unsigned int k = j + 1; k < i + 1; k++) {
+      pos[i].x_offset += pos[k].x_advance;
+      pos[i].y_offset += pos[k].y_advance;
+    }
+}
+
+void
+GPOS::position_start (hb_buffer_t *buffer)
+{
+  buffer->clear_positions ();
+
+  unsigned int count = buffer->len;
+  for (unsigned int i = 0; i < count; i++)
+    buffer->pos[i].attach_lookback() = buffer->pos[i].cursive_chain() = 0;
+}
+
 void
 GPOS::position_finish (hb_buffer_t *buffer)
 {
-  unsigned int i, j;
-  unsigned int len = hb_buffer_get_length (buffer);
-  hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer);
+  unsigned int len;
+  hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);
   hb_direction_t direction = buffer->props.direction;
 
-  /* Handle cursive connections:
-   * First handle all chain-back connections, then handle all chain-forward connections. */
-  if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
-  {
-    for (j = 0; j < len; j++) {
-      if (pos[j].cursive_chain() < 0)
-        pos[j].y_offset += pos[j + pos[j].cursive_chain()].y_offset;
-    }
-    for (i = len; i > 0; i--) {
-      j = i - 1;
-      if (pos[j].cursive_chain() > 0)
-        pos[j].y_offset += pos[j + pos[j].cursive_chain()].y_offset;
-    }
-  }
-  else
-  {
-    for (j = 0; j < len; j++) {
-      if (pos[j].cursive_chain() < 0)
-        pos[j].x_offset += pos[j + pos[j].cursive_chain()].x_offset;
-    }
-    for (i = len; i > 0; i--) {
-      j = i - 1;
-      if (pos[j].cursive_chain() > 0)
-        pos[j].x_offset += pos[j + pos[j].cursive_chain()].x_offset;
-    }
-  }
-
+  /* Handle cursive connections */
+  for (unsigned int i = 0; i < len; i++)
+    fix_cursive_minor_offset (pos, i, direction);
 
   /* Handle attachments */
-  for (i = 0; i < len; i++)
-    if (pos[i].attach_lookback())
-    {
-      unsigned int back = i - pos[i].attach_lookback();
-      pos[i].x_offset += pos[back].x_offset;
-      pos[i].y_offset += pos[back].y_offset;
+  for (unsigned int i = 0; i < len; i++)
+    fix_mark_attachment (pos, i, direction);
 
-      if (HB_DIRECTION_IS_BACKWARD (buffer->props.direction))
-        for (j = back + 1; j < i + 1; j++) {
-          pos[i].x_offset += pos[j].x_advance;
-          pos[i].y_offset += pos[j].y_advance;
-        }
-      else
-        for (j = back; j < i; j++) {
-          pos[i].x_offset -= pos[j].x_advance;
-          pos[i].y_offset -= pos[j].y_advance;
-        }
-    }
+  HB_BUFFER_DEALLOCATE_VAR (buffer, lig_comp);
+  HB_BUFFER_DEALLOCATE_VAR (buffer, lig_id);
+  HB_BUFFER_DEALLOCATE_VAR (buffer, props_cache);
 }
 
 
 /* Out-of-class implementation for methods recursing */
 
 inline bool ExtensionPos::apply (hb_apply_context_t *c) const
 {
   TRACE_APPLY ();
   return get_subtable ().apply (c, get_type ());
 }
 
 inline bool ExtensionPos::sanitize (hb_sanitize_context_t *c)
 {
   TRACE_SANITIZE ();
   if (unlikely (!Extension::sanitize (c))) return false;
   unsigned int offset = get_offset ();
   if (unlikely (!offset)) return true;
   return StructAtOffset<PosLookupSubTable> (this, offset).sanitize (c, get_type ());
 }
 
 static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index)
 {
-  const GPOS &gpos = *(c->layout->face->ot_layout->gpos);
+  const GPOS &gpos = *(c->face->ot_layout->gpos);
   const PosLookup &l = gpos.get_lookup (lookup_index);
 
   if (unlikely (c->nesting_level_left == 0))
     return false;
 
   if (unlikely (c->context_length < 1))
     return false;
 
-  return l.apply_once (c->layout, c->buffer, c->lookup_mask, c->context_length, c->nesting_level_left - 1);
+  return l.apply_once (c->font, c->buffer, c->lookup_mask, c->context_length, c->nesting_level_left - 1);
 }
 
 
 #undef attach_lookback
 #undef cursive_chain
 
 
-HB_END_DECLS
 
-#endif /* HB_OT_LAYOUT_GPOS_PRIVATE_HH */
+#endif /* HB_OT_LAYOUT_GPOS_TABLE_HH */