walkero
/
harfbuzz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

This commit is contained in:
Behdad Esfahbod 2010-05-14 22:10:39 -04:00
parent 29427c5c51
commit 36b73c80df
6 changed files with 141 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/hb-buffer-private.hh
View File

@ -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;

52
src/hb-buffer.cc
View File

@ -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++;
}

94
src/hb-ot-layout-gpos-private.hh
View File

@ -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;

48
src/hb-ot-layout-gsub-private.hh
View File

@ -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;

46
src/hb-ot-layout-gsubgpos-private.hh
View File

@ -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;

40
src/hb-shape.cc
View File

@ -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;
}
}