Shortening buffer accessors: rename buffer->in_pos to buffer->i

src/hb-buffer-private.hh

@@ -112,7 +112,7 @@ struct _hb_buffer_t {
   hb_bool_t    have_positions; /* whether we have positions */
   unsigned int len;
   unsigned int out_len;
-  unsigned int in_pos;
+  unsigned int i;
 
   hb_internal_glyph_info_t     *info;
   hb_internal_glyph_info_t     *out_info;

src/hb-buffer.cc

@@ -183,7 +183,7 @@ hb_buffer_clear (hb_buffer_t *buffer)
   buffer->have_positions = FALSE;
   buffer->len = 0;
   buffer->out_len = 0;
-  buffer->in_pos = 0;
+  buffer->i = 0;
   buffer->out_info = buffer->info;
   buffer->max_lig_id = 0;
 }
@@ -285,7 +285,7 @@ _hb_buffer_swap (hb_buffer_t *buffer)
   buffer->len = buffer->out_len;
   buffer->out_len = tmp;
 
-  buffer->in_pos = 0;
+  buffer->i = 0;
 }
 
 /* The following function copies `num_out' elements from `glyph_data'
@@ -294,18 +294,18 @@ _hb_buffer_swap (hb_buffer_t *buffer)
    Finally, it sets the `length' field of `out' equal to
    `pos' of the `out' structure.
 
-   If `component' is 0xFFFF, the component value from buffer->in_pos
+   If `component' is 0xFFFF, the component value from buffer->i
    will copied `num_out' times, otherwise `component' itself will
    be used to fill the `component' fields.
 
-   If `lig_id' is 0xFFFF, the lig_id value from buffer->in_pos
+   If `lig_id' is 0xFFFF, the lig_id value from buffer->i
    will copied `num_out' times, otherwise `lig_id' itself will
    be used to fill the `lig_id' fields.
 
    The mask for all replacement glyphs are taken
-   from the glyph at position `buffer->in_pos'.
+   from the glyph at position `buffer->i'.
 
-   The cluster value for the glyph at position buffer->in_pos is used
+   The cluster value for the glyph at position buffer->i is used
    for all replacement glyphs */
 
 void
@@ -321,17 +321,17 @@ _hb_buffer_add_output_glyphs (hb_buffer_t *buffer,
   unsigned int cluster;
 
   if (buffer->out_info != buffer->info ||
-      buffer->out_len + num_out > buffer->in_pos + num_in)
+      buffer->out_len + num_out > buffer->i + num_in)
   {
     hb_buffer_ensure_separate (buffer, buffer->out_len + num_out);
   }
 
-  mask = buffer->info[buffer->in_pos].mask;
-  cluster = buffer->info[buffer->in_pos].cluster;
+  mask = buffer->info[buffer->i].mask;
+  cluster = buffer->info[buffer->i].cluster;
   if (component == 0xFFFF)
-    component = buffer->info[buffer->in_pos].component;
+    component = buffer->info[buffer->i].component;
   if (lig_id == 0xFFFF)
-    lig_id = buffer->info[buffer->in_pos].lig_id;
+    lig_id = buffer->info[buffer->i].lig_id;
 
   for (i = 0; i < num_out; i++)
   {
@@ -344,7 +344,7 @@ _hb_buffer_add_output_glyphs (hb_buffer_t *buffer,
     info->gproperty = HB_BUFFER_GLYPH_PROPERTIES_UNKNOWN;
   }
 
-  buffer->in_pos  += num_in;
+  buffer->i  += num_in;
   buffer->out_len += num_out;
 }
 
@@ -361,17 +361,17 @@ _hb_buffer_add_output_glyphs_be16 (hb_buffer_t *buffer,
   unsigned int cluster;
 
   if (buffer->out_info != buffer->info ||
-      buffer->out_len + num_out > buffer->in_pos + num_in)
+      buffer->out_len + num_out > buffer->i + num_in)
   {
     hb_buffer_ensure_separate (buffer, buffer->out_len + num_out);
   }
 
-  mask = buffer->info[buffer->in_pos].mask;
-  cluster = buffer->info[buffer->in_pos].cluster;
+  mask = buffer->info[buffer->i].mask;
+  cluster = buffer->info[buffer->i].cluster;
   if (component == 0xFFFF)
-    component = buffer->info[buffer->in_pos].component;
+    component = buffer->info[buffer->i].component;
   if (lig_id == 0xFFFF)
-    lig_id = buffer->info[buffer->in_pos].lig_id;
+    lig_id = buffer->info[buffer->i].lig_id;
 
   for (i = 0; i < num_out; i++)
   {
@@ -384,7 +384,7 @@ _hb_buffer_add_output_glyphs_be16 (hb_buffer_t *buffer,
     info->gproperty = HB_BUFFER_GLYPH_PROPERTIES_UNKNOWN;
   }
 
-  buffer->in_pos  += num_in;
+  buffer->i  += num_in;
   buffer->out_len += num_out;
 }
 
@@ -399,10 +399,10 @@ _hb_buffer_add_output_glyph (hb_buffer_t *buffer,
   if (buffer->out_info != buffer->info)
   {
     hb_buffer_ensure (buffer, buffer->out_len + 1);
-    buffer->out_info[buffer->out_len] = buffer->info[buffer->in_pos];
+    buffer->out_info[buffer->out_len] = buffer->info[buffer->i];
   }
-  else if (buffer->out_len != buffer->in_pos)
-    buffer->out_info[buffer->out_len] = buffer->info[buffer->in_pos];
+  else if (buffer->out_len != buffer->i)
+    buffer->out_info[buffer->out_len] = buffer->info[buffer->i];
 
   info = &buffer->out_info[buffer->out_len];
   info->codepoint = glyph_index;
@@ -412,7 +412,7 @@ _hb_buffer_add_output_glyph (hb_buffer_t *buffer,
     info->lig_id = lig_id;
   info->gproperty = HB_BUFFER_GLYPH_PROPERTIES_UNKNOWN;
 
-  buffer->in_pos++;
+  buffer->i++;
   buffer->out_len++;
 }
 
@@ -424,15 +424,15 @@ _hb_buffer_next_glyph (hb_buffer_t *buffer)
     if (buffer->out_info != buffer->info)
     {
       hb_buffer_ensure (buffer, buffer->out_len + 1);
-      buffer->out_info[buffer->out_len] = buffer->info[buffer->in_pos];
+      buffer->out_info[buffer->out_len] = buffer->info[buffer->i];
     }
-    else if (buffer->out_len != buffer->in_pos)
-      buffer->out_info[buffer->out_len] = buffer->info[buffer->in_pos];
+    else if (buffer->out_len != buffer->i)
+      buffer->out_info[buffer->out_len] = buffer->info[buffer->i];
 
     buffer->out_len++;
   }
 
-  buffer->in_pos++;
+  buffer->i++;
 }
 
 

src/hb-ot-layout-gpos-private.hh

@@ -399,17 +399,17 @@ struct MarkArray : ArrayOf<MarkRecord>	/* Array of MarkRecords--in Coverage orde
 
     hb_position_t mark_x, mark_y, base_x, base_y;
 
-    mark_anchor.get_anchor (c->layout, c->buffer->info[c->buffer->in_pos].codepoint, &mark_x, &mark_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);
 
-    hb_internal_glyph_position_t &o = c->buffer->pos[c->buffer->in_pos];
+    hb_internal_glyph_position_t &o = c->buffer->pos[c->buffer->i];
     o.x_advance = 0;
     o.y_advance = 0;
     o.x_offset  = base_x - mark_x;
     o.y_offset  = base_y - mark_y;
-    o.back      = c->buffer->in_pos - glyph_pos;
+    o.back      = c->buffer->i - glyph_pos;
 
-    c->buffer->in_pos++;
+    c->buffer->i++;
     return true;
   }
 
@@ -430,13 +430,13 @@ struct SinglePosFormat1
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
-    valueFormat.apply_value (c->layout, this, values, c->buffer->pos[c->buffer->in_pos]);
+    valueFormat.apply_value (c->layout, this, values, c->buffer->pos[c->buffer->i]);
 
-    c->buffer->in_pos++;
+    c->buffer->i++;
     return true;
   }
 
@@ -469,7 +469,7 @@ struct SinglePosFormat2
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
@@ -478,9 +478,9 @@ struct SinglePosFormat2
 
     valueFormat.apply_value (c->layout, this,
 			     &values[index * valueFormat.get_len ()],
-			     c->buffer->pos[c->buffer->in_pos]);
+			     c->buffer->pos[c->buffer->i]);
 
-    c->buffer->in_pos++;
+    c->buffer->i++;
     return true;
   }
 
@@ -572,11 +572,11 @@ struct PairSet
     {
       if (c->buffer->info[pos].codepoint == record->secondGlyph)
       {
-	valueFormats[0].apply_value (c->layout, this, &record->values[0], c->buffer->pos[c->buffer->in_pos]);
+	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]);
 	if (len2)
 	  pos++;
-	c->buffer->in_pos = pos;
+	c->buffer->i = pos;
 	return true;
       }
       record = &StructAtOffset<PairValueRecord> (record, record_size);
@@ -619,15 +619,15 @@ struct PairPosFormat1
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int end = MIN (c->buffer->len, c->buffer->in_pos + c->context_length);
-    if (unlikely (c->buffer->in_pos + 2 > end))
+    unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
+    if (unlikely (c->buffer->i + 2 > end))
       return false;
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
-    unsigned int j = c->buffer->in_pos + 1;
+    unsigned int j = c->buffer->i + 1;
     while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_flag, NULL))
     {
       if (unlikely (j == end))
@@ -681,15 +681,15 @@ struct PairPosFormat2
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int end = MIN (c->buffer->len, c->buffer->in_pos + c->context_length);
-    if (unlikely (c->buffer->in_pos + 2 > end))
+    unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
+    if (unlikely (c->buffer->i + 2 > end))
       return false;
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
-    unsigned int j = c->buffer->in_pos + 1;
+    unsigned int j = c->buffer->i + 1;
     while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_flag, NULL))
     {
       if (unlikely (j == end))
@@ -701,18 +701,18 @@ struct PairPosFormat2
     unsigned int len2 = valueFormat2.get_len ();
     unsigned int record_len = len1 + len2;
 
-    unsigned int klass1 = (this+classDef1) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int klass1 = (this+classDef1) (c->buffer->info[c->buffer->i].codepoint);
     unsigned int klass2 = (this+classDef2) (c->buffer->info[j].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->in_pos]);
+    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]);
 
     if (len2)
       j++;
-    c->buffer->in_pos = j;
+    c->buffer->i = j;
 
     return true;
   }
@@ -954,7 +954,7 @@ struct CursivePosFormat1
     if (c->property == HB_OT_LAYOUT_GLYPH_CLASS_MARK)
       return false;
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
@@ -964,14 +964,14 @@ struct CursivePosFormat1
       goto end;
 
     hb_position_t entry_x, entry_y;
-    (this+record.entryAnchor).get_anchor (c->layout, c->buffer->info[c->buffer->in_pos].codepoint, &entry_x, &entry_y);
+    (this+record.entryAnchor).get_anchor (c->layout, c->buffer->info[c->buffer->i].codepoint, &entry_x, &entry_y);
 
     /* TODO vertical */
 
     if (c->buffer->direction == HB_DIRECTION_RTL)
     {
       /* advance is absolute, not relative */
-      c->buffer->pos[c->buffer->in_pos].x_advance = entry_x - gpi->anchor_x;
+      c->buffer->pos[c->buffer->i].x_advance = entry_x - gpi->anchor_x;
     }
     else
     {
@@ -981,23 +981,23 @@ struct CursivePosFormat1
 
     if  (c->lookup_flag & LookupFlag::RightToLeft)
     {
-      c->buffer->pos[last_pos].cursive_chain = last_pos - c->buffer->in_pos;
+      c->buffer->pos[last_pos].cursive_chain = last_pos - c->buffer->i;
       c->buffer->pos[last_pos].y_offset = entry_y - gpi->anchor_y;
     }
     else
     {
-      c->buffer->pos[c->buffer->in_pos].cursive_chain = c->buffer->in_pos - last_pos;
-      c->buffer->pos[c->buffer->in_pos].y_offset = gpi->anchor_y - entry_y;
+      c->buffer->pos[c->buffer->i].cursive_chain = c->buffer->i - last_pos;
+      c->buffer->pos[c->buffer->i].y_offset = gpi->anchor_y - entry_y;
     }
 
   end:
     if (record.exitAnchor)
     {
-      gpi->last = c->buffer->in_pos;
-      (this+record.exitAnchor).get_anchor (c->layout, c->buffer->info[c->buffer->in_pos].codepoint, &gpi->anchor_x, &gpi->anchor_y);
+      gpi->last = c->buffer->i;
+      (this+record.exitAnchor).get_anchor (c->layout, c->buffer->info[c->buffer->i].codepoint, &gpi->anchor_x, &gpi->anchor_y);
     }
 
-    c->buffer->in_pos++;
+    c->buffer->i++;
     return true;
   }
 
@@ -1063,13 +1063,13 @@ struct MarkBasePosFormat1
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->i].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->in_pos;
+    unsigned int j = c->buffer->i;
     do
     {
       if (unlikely (!j))
@@ -1165,13 +1165,13 @@ struct MarkLigPosFormat1
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->i].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->in_pos;
+    unsigned int j = c->buffer->i;
     do
     {
       if (unlikely (!j))
@@ -1199,9 +1199,9 @@ struct MarkLigPosFormat1
      * 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->in_pos].lig_id && c->buffer->info[c->buffer->in_pos].component)
+    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].component)
     {
-      comp_index = c->buffer->info[c->buffer->in_pos].component - 1;
+      comp_index = c->buffer->info[c->buffer->i].component - 1;
       if (comp_index >= comp_count)
 	comp_index = comp_count - 1;
     }
@@ -1284,13 +1284,13 @@ struct MarkMarkPosFormat1
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int mark1_index = (this+mark1Coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int mark1_index = (this+mark1Coverage) (c->buffer->info[c->buffer->i].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->in_pos;
+    unsigned int j = c->buffer->i;
     do
     {
       if (unlikely (!j))
@@ -1304,8 +1304,8 @@ struct MarkMarkPosFormat1
     /* 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].component != c->buffer->info[c->buffer->in_pos].component) ||
-	(c->buffer->info[j].component && c->buffer->info[j].lig_id != c->buffer->info[c->buffer->in_pos].lig_id))
+    if ((c->buffer->info[j].component != c->buffer->info[c->buffer->i].component) ||
+	(c->buffer->info[j].component && c->buffer->info[j].lig_id != c->buffer->info[c->buffer->i].lig_id))
       return false;
 
     unsigned int mark2_index = (this+mark2Coverage) (c->buffer->info[j].codepoint);
@@ -1513,7 +1513,7 @@ struct PosLookup : Lookup
     c->nesting_level_left = nesting_level_left;
     c->lookup_flag = get_flag ();
 
-    if (!_hb_ot_layout_check_glyph_property (c->layout->face, &c->buffer->info[c->buffer->in_pos], c->lookup_flag, &c->property))
+    if (!_hb_ot_layout_check_glyph_property (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_flag, &c->property))
       return false;
 
     for (unsigned int i = 0; i < get_subtable_count (); i++)
@@ -1534,11 +1534,11 @@ struct PosLookup : Lookup
 
     layout->info.gpos.last = HB_OT_LAYOUT_GPOS_NO_LAST; /* no last valid glyph for cursive pos. */
 
-    buffer->in_pos = 0;
-    while (buffer->in_pos < buffer->len)
+    buffer->i = 0;
+    while (buffer->i < buffer->len)
     {
       bool done;
-      if (~buffer->info[buffer->in_pos].mask & mask)
+      if (~buffer->info[buffer->i].mask & mask)
       {
 	  done = apply_once (layout, buffer, NO_CONTEXT, MAX_NESTING_LEVEL);
 	  ret |= done;
@@ -1552,7 +1552,7 @@ struct PosLookup : Lookup
       }
 
       if (!done)
-	buffer->in_pos++;
+	buffer->i++;
     }
 
     return ret;

src/hb-ot-layout-gsub-private.hh

@@ -39,7 +39,7 @@ struct SingleSubstFormat1
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->in_pos].codepoint;
+    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->i].codepoint;
     unsigned int index = (this+coverage) (glyph_id);
     if (likely (index == NOT_COVERED))
       return false;
@@ -80,7 +80,7 @@ struct SingleSubstFormat2
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->in_pos].codepoint;
+    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->i].codepoint;
     unsigned int index = (this+coverage) (glyph_id);
     if (likely (index == NOT_COVERED))
       return false;
@@ -204,7 +204,7 @@ struct MultipleSubstFormat1
   {
     TRACE_APPLY ();
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
@@ -273,7 +273,7 @@ struct AlternateSubstFormat1
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->in_pos].codepoint;
+    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->i].codepoint;
 
     unsigned int index = (this+coverage) (glyph_id);
     if (likely (index == NOT_COVERED))
@@ -367,11 +367,11 @@ struct Ligature
     TRACE_APPLY ();
     unsigned int i, j;
     unsigned int count = component.len;
-    unsigned int end = MIN (c->buffer->len, c->buffer->in_pos + c->context_length);
-    if (unlikely (c->buffer->in_pos + count > end))
+    unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
+    if (unlikely (c->buffer->i + count > end))
       return false;
 
-    for (i = 1, j = c->buffer->in_pos + 1; i < count; i++, j++)
+    for (i = 1, j = c->buffer->i + 1; i < count; i++, j++)
     {
       unsigned int property;
       while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_flag, &property))
@@ -393,13 +393,13 @@ struct Ligature
 				     is_mark ? HB_OT_LAYOUT_GLYPH_CLASS_MARK
 					     : HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE);
 
-    if (j == c->buffer->in_pos + i) /* No input glyphs skipped */
+    if (j == c->buffer->i + i) /* No input glyphs skipped */
       /* We don't use a new ligature ID if there are no skipped
 	 glyphs and the ligature already has an ID. */
       c->buffer->add_output_glyphs_be16 (i,
 					       1, (const uint16_t *) &ligGlyph,
 					       0,
-					       c->buffer->info[c->buffer->in_pos].lig_id && !c->buffer->info[c->buffer->in_pos].component ?
+					       c->buffer->info[c->buffer->i].lig_id && !c->buffer->info[c->buffer->i].component ?
 					       0xFFFF : c->buffer->allocate_lig_id ());
     else
     {
@@ -415,10 +415,10 @@ struct Ligature
 
       for ( i = 1; i < count; i++ )
       {
-	while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[c->buffer->in_pos], c->lookup_flag, NULL))
-	  c->buffer->add_output_glyph (c->buffer->info[c->buffer->in_pos].codepoint, i, lig_id);
+	while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_flag, NULL))
+	  c->buffer->add_output_glyph (c->buffer->info[c->buffer->i].codepoint, i, lig_id);
 
-	(c->buffer->in_pos)++;
+	(c->buffer->i)++;
       }
     }
 
@@ -483,7 +483,7 @@ struct LigatureSubstFormat1
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->in_pos].codepoint;
+    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->i].codepoint;
 
     bool first_is_mark = !!(c->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK);
 
@@ -604,7 +604,7 @@ struct ReverseChainSingleSubstFormat1
     if (unlikely (c->context_length != NO_CONTEXT))
       return false; /* No chaining to this type */
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
@@ -619,8 +619,8 @@ struct ReverseChainSingleSubstFormat1
 			 match_coverage, this,
 			 1))
     {
-      c->buffer->info[c->buffer->in_pos].codepoint = substitute[index];
-      c->buffer->in_pos--; /* Reverse! */
+      c->buffer->info[c->buffer->i].codepoint = substitute[index];
+      c->buffer->i--; /* Reverse! */
       return true;
     }
 
@@ -789,7 +789,7 @@ struct SubstLookup : Lookup
     c->nesting_level_left = nesting_level_left;
     c->lookup_flag = get_flag ();
 
-    if (!_hb_ot_layout_check_glyph_property (c->layout->face, &c->buffer->info[c->buffer->in_pos], c->lookup_flag, &c->property))
+    if (!_hb_ot_layout_check_glyph_property (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_flag, &c->property))
       return false;
 
     if (unlikely (lookup_type == SubstLookupSubTable::Extension))
@@ -827,10 +827,10 @@ struct SubstLookup : Lookup
     {
 	/* in/out forward substitution */
 	buffer->clear_output ();
-	buffer->in_pos = 0;
-	while (buffer->in_pos < buffer->len)
+	buffer->i = 0;
+	while (buffer->i < buffer->len)
 	{
-	  if ((~buffer->info[buffer->in_pos].mask & mask) &&
+	  if ((~buffer->info[buffer->i].mask & mask) &&
 	      apply_once (layout, buffer, NO_CONTEXT, MAX_NESTING_LEVEL))
 	    ret = true;
 	  else
@@ -843,17 +843,17 @@ struct SubstLookup : Lookup
     else
     {
 	/* in-place backward substitution */
-	buffer->in_pos = buffer->len - 1;
+	buffer->i = buffer->len - 1;
 	do
 	{
-	  if ((~buffer->info[buffer->in_pos].mask & mask) &&
+	  if ((~buffer->info[buffer->i].mask & mask) &&
 	      apply_once (layout, buffer, NO_CONTEXT, MAX_NESTING_LEVEL))
 	    ret = true;
 	  else
-	    buffer->in_pos--;
+	    buffer->i--;
 
 	}
-	while ((int) buffer->in_pos >= 0);
+	while ((int) buffer->i >= 0);
     }
 
     return ret;

src/hb-ot-layout-gsubgpos-private.hh

@@ -88,11 +88,11 @@ static inline bool match_input (hb_apply_context_t *c,
 				unsigned int *context_length_out)
 {
   unsigned int i, j;
-  unsigned int end = MIN (c->buffer->len, c->buffer->in_pos + c->context_length);
-  if (unlikely (c->buffer->in_pos + count > end))
+  unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
+  if (unlikely (c->buffer->i + count > end))
     return false;
 
-  for (i = 1, j = c->buffer->in_pos + 1; i < count; i++, j++)
+  for (i = 1, j = c->buffer->i + 1; i < count; i++, j++)
   {
     while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_flag, NULL))
     {
@@ -105,7 +105,7 @@ static inline bool match_input (hb_apply_context_t *c,
       return false;
   }
 
-  *context_length_out = j - c->buffer->in_pos;
+  *context_length_out = j - c->buffer->i;
 
   return true;
 }
@@ -143,11 +143,11 @@ static inline bool match_lookahead (hb_apply_context_t *c,
 				    unsigned int offset)
 {
   unsigned int i, j;
-  unsigned int end = MIN (c->buffer->len, c->buffer->in_pos + c->context_length);
-  if (unlikely (c->buffer->in_pos + offset + count > end))
+  unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
+  if (unlikely (c->buffer->i + offset + count > end))
     return false;
 
-  for (i = 0, j = c->buffer->in_pos + offset; i < count; i++, j++)
+  for (i = 0, j = c->buffer->i + offset; i < count; i++, j++)
   {
     while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_flag, NULL))
     {
@@ -185,8 +185,8 @@ static inline bool apply_lookup (hb_apply_context_t *c,
 				 const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */
 				 apply_lookup_func_t apply_func)
 {
-  unsigned int end = MIN (c->buffer->len, c->buffer->in_pos + c->context_length);
-  if (unlikely (c->buffer->in_pos + count > end))
+  unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
+  if (unlikely (c->buffer->i + count > end))
     return false;
 
   /* TODO We don't support lookupRecord arrays that are not increasing:
@@ -198,9 +198,9 @@ static inline bool apply_lookup (hb_apply_context_t *c,
    */
   for (unsigned int i = 0; i < count; /* NOP */)
   {
-    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[c->buffer->in_pos], c->lookup_flag, NULL))
+    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_flag, NULL))
     {
-      if (unlikely (c->buffer->in_pos == end))
+      if (unlikely (c->buffer->i == end))
 	return true;
       /* No lookup applied for this index */
       c->buffer->next_glyph ();
@@ -208,7 +208,7 @@ static inline bool apply_lookup (hb_apply_context_t *c,
 
     if (lookupCount && i == lookupRecord->sequenceIndex)
     {
-      unsigned int old_pos = c->buffer->in_pos;
+      unsigned int old_pos = c->buffer->i;
 
       /* Apply a lookup */
       bool done = apply_func (c, lookupRecord->lookupListIndex);
@@ -216,8 +216,8 @@ static inline bool apply_lookup (hb_apply_context_t *c,
       lookupRecord++;
       lookupCount--;
       /* Err, this is wrong if the lookup jumped over some glyphs */
-      i += c->buffer->in_pos - old_pos;
-      if (unlikely (c->buffer->in_pos == end))
+      i += c->buffer->i - old_pos;
+      if (unlikely (c->buffer->i == end))
 	return true;
 
       if (!done)
@@ -337,7 +337,7 @@ struct ContextFormat1
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
@@ -376,12 +376,12 @@ struct ContextFormat2
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
     const ClassDef &class_def = this+classDef;
-    index = class_def (c->buffer->info[c->buffer->in_pos].codepoint);
+    index = class_def (c->buffer->info[c->buffer->i].codepoint);
     const RuleSet &rule_set = this+ruleSet[index];
     /* LONGTERMTODO: Old code fetches glyph classes at most once and caches
      * them across subrule lookups.  Not sure it's worth it.
@@ -424,7 +424,7 @@ struct ContextFormat3
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage[0]) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage[0]) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
@@ -520,7 +520,7 @@ static inline bool chain_context_lookup (hb_apply_context_t *c,
 {
   /* First guess */
   if (unlikely (c->buffer->out_len < backtrackCount ||
-		c->buffer->in_pos + inputCount + lookaheadCount > c->buffer->len ||
+		c->buffer->i + inputCount + lookaheadCount > c->buffer->len ||
 		inputCount + lookaheadCount > c->context_length))
     return false;
 
@@ -628,7 +628,7 @@ struct ChainContextFormat1
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
@@ -666,7 +666,7 @@ struct ChainContextFormat2
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
@@ -674,7 +674,7 @@ struct ChainContextFormat2
     const ClassDef &input_class_def = this+inputClassDef;
     const ClassDef &lookahead_class_def = this+lookaheadClassDef;
 
-    index = input_class_def (c->buffer->info[c->buffer->in_pos].codepoint);
+    index = input_class_def (c->buffer->info[c->buffer->i].codepoint);
     const ChainRuleSet &rule_set = this+ruleSet[index];
     /* LONGTERMTODO: Old code fetches glyph classes at most once and caches
      * them across subrule lookups.  Not sure it's worth it.
@@ -732,7 +732,7 @@ struct ChainContextFormat3
     TRACE_APPLY ();
     const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
 
-    unsigned int index = (this+input[0]) (c->buffer->info[c->buffer->in_pos].codepoint);
+    unsigned int index = (this+input[0]) (c->buffer->info[c->buffer->i].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 

src/hb-shape.cc

@@ -49,9 +49,9 @@ hb_form_clusters (hb_buffer_t *buffer)
   unsigned int count;
 
   count = buffer->len;
-  for (buffer->in_pos = 1; buffer->in_pos < count; buffer->in_pos++)
-    if (buffer->unicode->get_general_category (buffer->info[buffer->in_pos].codepoint) == HB_CATEGORY_NON_SPACING_MARK)
-      buffer->info[buffer->in_pos].cluster = buffer->info[buffer->in_pos - 1].cluster;
+  for (buffer->i = 1; buffer->i < count; buffer->i++)
+    if (buffer->unicode->get_general_category (buffer->info[buffer->i].codepoint) == HB_CATEGORY_NON_SPACING_MARK)
+      buffer->info[buffer->i].cluster = buffer->info[buffer->i - 1].cluster;
 }
 
 static hb_direction_t
@@ -83,8 +83,8 @@ hb_mirror_chars (hb_buffer_t *buffer)
     return;
 
   count = buffer->len;
-  for (buffer->in_pos = 0; buffer->in_pos < count; buffer->in_pos++) {
-      buffer->info[buffer->in_pos].codepoint = get_mirroring (buffer->info[buffer->in_pos].codepoint);
+  for (buffer->i = 0; buffer->i < count; buffer->i++) {
+      buffer->info[buffer->i].codepoint = get_mirroring (buffer->info[buffer->i].codepoint);
   }
 }
 
@@ -98,15 +98,15 @@ hb_map_glyphs (hb_font_t    *font,
   if (unlikely (!buffer->len))
     return;
   count = buffer->len - 1;
-  for (buffer->in_pos = 0; buffer->in_pos < count; buffer->in_pos++) {
-    if (unlikely (is_variation_selector (buffer->info[buffer->in_pos + 1].codepoint))) {
-      buffer->info[buffer->in_pos].codepoint = hb_font_get_glyph (font, face, buffer->info[buffer->in_pos].codepoint, buffer->info[buffer->in_pos + 1].codepoint);
-      buffer->in_pos++;
+  for (buffer->i = 0; buffer->i < count; buffer->i++) {
+    if (unlikely (is_variation_selector (buffer->info[buffer->i + 1].codepoint))) {
+      buffer->info[buffer->i].codepoint = hb_font_get_glyph (font, face, buffer->info[buffer->i].codepoint, buffer->info[buffer->i + 1].codepoint);
+      buffer->i++;
     } else {
-      buffer->info[buffer->in_pos].codepoint = hb_font_get_glyph (font, face, buffer->info[buffer->in_pos].codepoint, 0);
+      buffer->info[buffer->i].codepoint = hb_font_get_glyph (font, face, buffer->info[buffer->i].codepoint, 0);
     }
   }
-  buffer->info[buffer->in_pos].codepoint = hb_font_get_glyph (font, face, buffer->info[buffer->in_pos].codepoint, 0);
+  buffer->info[buffer->i].codepoint = hb_font_get_glyph (font, face, buffer->info[buffer->i].codepoint, 0);
 }
 
 static void
@@ -155,11 +155,11 @@ hb_position_default (hb_font_t    *font,
   hb_buffer_clear_positions (buffer);
 
   count = buffer->len;
-  for (buffer->in_pos = 0; buffer->in_pos < count; buffer->in_pos++) {
+  for (buffer->i = 0; buffer->i < count; buffer->i++) {
     hb_glyph_metrics_t metrics;
-    hb_font_get_glyph_metrics (font, face, buffer->info[buffer->in_pos].codepoint, &metrics);
-    buffer->pos[buffer->in_pos].x_advance = metrics.x_advance;
-    buffer->pos[buffer->in_pos].y_advance = metrics.y_advance;
+    hb_font_get_glyph_metrics (font, face, buffer->info[buffer->i].codepoint, &metrics);
+    buffer->pos[buffer->i].x_advance = metrics.x_advance;
+    buffer->pos[buffer->i].y_advance = metrics.y_advance;
   }
 }
 
@@ -194,14 +194,14 @@ hb_truetype_kern (hb_font_t    *font,
 
   /* TODO Check for kern=0 */
   count = buffer->len;
-  for (buffer->in_pos = 1; buffer->in_pos < count; buffer->in_pos++) {
+  for (buffer->i = 1; buffer->i < count; buffer->i++) {
     hb_position_t kern, kern1, kern2;
-    kern = hb_font_get_kerning (font, face, buffer->info[buffer->in_pos - 1].codepoint, buffer->info[buffer->in_pos].codepoint);
+    kern = hb_font_get_kerning (font, face, buffer->info[buffer->i - 1].codepoint, buffer->info[buffer->i].codepoint);
     kern1 = kern >> 1;
     kern2 = kern - kern1;
-    buffer->pos[buffer->in_pos - 1].x_advance += kern1;
-    buffer->pos[buffer->in_pos].x_advance += kern2;
-    buffer->pos[buffer->in_pos].x_offset += kern2;
+    buffer->pos[buffer->i - 1].x_advance += kern1;
+    buffer->pos[buffer->i].x_advance += kern2;
+    buffer->pos[buffer->i].x_offset += kern2;
   }
 }