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

Cosmetic: Rename HB_LIKELY/HB_UNLIKELY to likely/unlikely

Browse Source
This commit is contained in:
Behdad Esfahbod 2010-05-03 22:51:19 -04:00
parent fa3b3d5844
commit 64d3fc8d0d
17 changed files with 147 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/hb-buffer.c
View File

@ -258,7 +258,7 @@ hb_buffer_clear_positions (hb_buffer_t *buffer)
buffer->have_output = FALSE;
buffer->have_positions = TRUE;
if (HB_UNLIKELY (!buffer->positions))
if (unlikely (!buffer->positions))
{
buffer->positions = calloc (buffer->allocated, sizeof (buffer->positions[0]));
return;
@ -510,7 +510,7 @@ reverse_range (hb_buffer_t *buffer,
void
hb_buffer_reverse (hb_buffer_t *buffer)
{
if (HB_UNLIKELY (!buffer->in_length))
if (unlikely (!buffer->in_length))
return;
reverse_range (buffer, 0, buffer->in_length);
@ -521,7 +521,7 @@ hb_buffer_reverse_clusters (hb_buffer_t *buffer)
{
unsigned int i, start, count, last_cluster;
if (HB_UNLIKELY (!buffer->in_length))
if (unlikely (!buffer->in_length))
return;
hb_buffer_reverse (buffer);
@ -569,7 +569,7 @@ hb_utf8_next (const uint8_t *text,
unsigned int mask, len;
UTF8_COMPUTE (c, mask, len);
if (HB_UNLIKELY (!len || (unsigned int) (end - text) < len)) {
if (unlikely (!len || (unsigned int) (end - text) < len)) {
*unicode = -1;
return text + 1;
} else {
@ -578,7 +578,7 @@ hb_utf8_next (const uint8_t *text,
result = c & mask;
for (i = 1; i < len; i++)
{
if (HB_UNLIKELY ((text[i] & 0xc0) != 0x80))
if (unlikely ((text[i] & 0xc0) != 0x80))
{
*unicode = -1;
return text + 1;
@ -610,10 +610,10 @@ hb_utf16_next (const uint16_t *text,
{
uint16_t c = *text++;
if (HB_UNLIKELY (c >= 0xd800 && c < 0xdc00)) {
if (unlikely (c >= 0xd800 && c < 0xdc00)) {
/* high surrogate */
uint16_t l;
if (text < end && ((l = *text), HB_UNLIKELY (l >= 0xdc00 && l < 0xe000))) {
if (text < end && ((l = *text), unlikely (l >= 0xdc00 && l < 0xe000))) {
/* low surrogate */
*unicode = ((hb_codepoint_t) ((c) - 0xd800) * 0x400 + (l) - 0xdc00 + 0x10000);
text++;

6
src/hb-font.cc
View File

@ -274,7 +274,7 @@ _hb_face_for_data_closure_create (hb_blob_t *blob, unsigned int index)
hb_face_for_data_closure_t *closure;
closure = (hb_face_for_data_closure_t *) malloc (sizeof (hb_face_for_data_closure_t));
if (HB_UNLIKELY (!closure))
if (unlikely (!closure))
return &_hb_face_for_data_closure_nil;
closure->blob = hb_blob_reference (blob);
@ -286,7 +286,7 @@ _hb_face_for_data_closure_create (hb_blob_t *blob, unsigned int index)
static void
_hb_face_for_data_closure_destroy (hb_face_for_data_closure_t *closure)
{
if (HB_LIKELY (closure != &_hb_face_for_data_closure_nil)) {
if (likely (closure != &_hb_face_for_data_closure_nil)) {
hb_blob_destroy (closure->blob);
free (closure);
}
@ -361,7 +361,7 @@ hb_face_get_table (hb_face_t *face,
{
hb_blob_t *blob;
if (HB_UNLIKELY (!face || !face->get_table))
if (unlikely (!face || !face->get_table))
return &_hb_blob_nil;
blob = face->get_table (tag, face->user_data);

14
src/hb-ft.c
View File

@ -43,7 +43,7 @@ hb_ft_get_glyph (hb_font_t *font HB_UNUSED,
FT_Face ft_face = (FT_Face) user_data;
#ifdef HAVE_FT_FACE_GETCHARVARIANTINDEX
if (HB_UNLIKELY (variation_selector)) {
if (unlikely (variation_selector)) {
hb_codepoint_t glyph = FT_Face_GetCharVariantIndex (ft_face, unicode, variation_selector);
if (glyph)
return glyph;
@ -67,13 +67,13 @@ hb_ft_get_contour_point (hb_font_t *font HB_UNUSED,
/* TODO: load_flags, embolden, etc */
if (HB_UNLIKELY (FT_Load_Glyph (ft_face, glyph, load_flags)))
if (unlikely (FT_Load_Glyph (ft_face, glyph, load_flags)))
return FALSE;
if (HB_UNLIKELY (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE))
if (unlikely (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE))
return FALSE;
if (HB_UNLIKELY (point_index >= (unsigned int) ft_face->glyph->outline.n_points))
if (unlikely (point_index >= (unsigned int) ft_face->glyph->outline.n_points))
return FALSE;
*x = ft_face->glyph->outline.points[point_index].x;
@ -97,7 +97,7 @@ hb_ft_get_glyph_metrics (hb_font_t *font HB_UNUSED,
metrics->x_advance = metrics->y_advance = 0;
metrics->x_offset = metrics->y_offset = 0;
metrics->width = metrics->height = 0;
if (HB_LIKELY (!FT_Load_Glyph (ft_face, glyph, load_flags)))
if (likely (!FT_Load_Glyph (ft_face, glyph, load_flags)))
{
/* TODO: A few negations should be in order here, not sure. */
metrics->x_advance = ft_face->glyph->advance.x;
@ -152,7 +152,7 @@ _get_table (hb_tag_t tag, void *user_data)
FT_ULong length = 0;
FT_Error error;
if (HB_UNLIKELY (tag == HB_TAG_NONE))
if (unlikely (tag == HB_TAG_NONE))
return hb_blob_create_empty ();
error = FT_Load_Sfnt_Table (ft_face, tag, 0, NULL, &length);
@ -206,7 +206,7 @@ hb_ft_face_finalize (FT_Face ft_face)
hb_face_t *
hb_ft_face_create_cached (FT_Face ft_face)
{
if (HB_UNLIKELY (!ft_face->generic.data || ft_face->generic.finalizer != (FT_Generic_Finalizer) hb_ft_face_finalize))
if (unlikely (!ft_face->generic.data || ft_face->generic.finalizer != (FT_Generic_Finalizer) hb_ft_face_finalize))
{
if (ft_face->generic.finalizer)
ft_face->generic.finalizer (ft_face);

2
src/hb-language.c
View File

@ -89,7 +89,7 @@ hb_language_from_string (const char *str)
if (lang_equal (str, langs[i]))
return langs[i];
if (HB_UNLIKELY (num_langs == num_alloced)) {
if (unlikely (num_langs == num_alloced)) {
unsigned int new_alloced = 2 * (8 + num_alloced);
const char **new_langs = realloc (langs, new_alloced * sizeof (langs[0]));
if (!new_langs)

10
src/hb-object-private.h
View File

@ -82,7 +82,7 @@ _hb_object_debug_out (const void *obj,
/* Object allocation and lifecycle manamgement macros */
#define HB_OBJECT_IS_INERT(obj) \
(HB_UNLIKELY (HB_REFERENCE_COUNT_IS_INVALID ((obj)->ref_count)))
(unlikely (HB_REFERENCE_COUNT_IS_INVALID ((obj)->ref_count)))
#define HB_OBJECT_DO_INIT_EXPR(obj) \
HB_REFERENCE_COUNT_INIT (obj->ref_count, 1)
@ -93,7 +93,7 @@ _hb_object_debug_out (const void *obj,
} HB_STMT_END
#define HB_OBJECT_DO_CREATE(Type, obj) \
HB_LIKELY (( \
likely (( \
(void) ( \
((obj) = (Type *) calloc (1, sizeof (Type))) && \
HB_OBJECT_DO_INIT_EXPR (obj) && \
@ -105,7 +105,7 @@ _hb_object_debug_out (const void *obj,
#define HB_OBJECT_DO_REFERENCE(obj) \
HB_STMT_START { \
int old_count; \
if (HB_UNLIKELY (!(obj) || HB_OBJECT_IS_INERT (obj))) \
if (unlikely (!(obj) || HB_OBJECT_IS_INERT (obj))) \
return obj; \
HB_OBJECT_DEBUG_OUT (obj); \
old_count = hb_reference_count_inc (obj->ref_count); \
@ -115,7 +115,7 @@ _hb_object_debug_out (const void *obj,
#define HB_OBJECT_DO_GET_REFERENCE_COUNT(obj) \
HB_STMT_START { \
if (HB_UNLIKELY (!(obj) || HB_OBJECT_IS_INERT (obj))) \
if (unlikely (!(obj) || HB_OBJECT_IS_INERT (obj))) \
return 0; \
return HB_REFERENCE_COUNT_GET_VALUE (obj->ref_count); \
} HB_STMT_END
@ -123,7 +123,7 @@ _hb_object_debug_out (const void *obj,
#define HB_OBJECT_DO_DESTROY(obj) \
HB_STMT_START { \
int old_count; \
if (HB_UNLIKELY (!(obj) || HB_OBJECT_IS_INERT (obj))) \
if (unlikely (!(obj) || HB_OBJECT_IS_INERT (obj))) \
return; \
HB_OBJECT_DEBUG_OUT (obj); \
old_count = hb_reference_count_dec (obj->ref_count); \

2
src/hb-open-file-private.hh
View File

@ -70,7 +70,7 @@ typedef struct OffsetTable
{ return numTables; }
inline const TableDirectory& get_table (unsigned int i) const
{
if (HB_UNLIKELY (i >= numTables)) return Null(TableDirectory);
if (unlikely (i >= numTables)) return Null(TableDirectory);
return tableDir[i];
}
inline bool find_table_index (hb_tag_t tag, unsigned int *table_index) const

38
src/hb-open-type-private.hh
View File

@ -205,7 +205,7 @@ _hb_sanitize_array (SANITIZE_ARG_DEF,
context->start, context->end,
!overflows ? "does not overflow" : "OVERFLOWS FAIL");
return HB_LIKELY (!overflows) && _hb_sanitize_check (SANITIZE_ARG, base, record_size * len);
return likely (!overflows) && _hb_sanitize_check (SANITIZE_ARG, base, record_size * len);
}
static inline bool
@ -227,22 +227,22 @@ _hb_sanitize_edit (SANITIZE_ARG_DEF,
return context->writable;
}
#define SANITIZE(X) HB_LIKELY ((X).sanitize (SANITIZE_ARG))
#define SANITIZE(X) likely ((X).sanitize (SANITIZE_ARG))
#define SANITIZE2(X,Y) (SANITIZE (X) && SANITIZE (Y))
#define SANITIZE_THIS(X) HB_LIKELY ((X).sanitize (SANITIZE_ARG, CharP(this)))
#define SANITIZE_THIS(X) likely ((X).sanitize (SANITIZE_ARG, CharP(this)))
#define SANITIZE_THIS2(X,Y) (SANITIZE_THIS (X) && SANITIZE_THIS (Y))
#define SANITIZE_THIS3(X,Y,Z) (SANITIZE_THIS (X) && SANITIZE_THIS (Y) && SANITIZE_THIS(Z))
#define SANITIZE_BASE(X,B) HB_LIKELY ((X).sanitize (SANITIZE_ARG, B))
#define SANITIZE_BASE(X,B) likely ((X).sanitize (SANITIZE_ARG, B))
#define SANITIZE_BASE2(X,Y,B) (SANITIZE_BASE (X,B) && SANITIZE_BASE (Y,B))
#define SANITIZE_SELF() SANITIZE_OBJ (*this)
#define SANITIZE_OBJ(X) SANITIZE_MEM(&(X), sizeof (X))
#define SANITIZE_MEM(B,L) HB_LIKELY (_hb_sanitize_check (SANITIZE_ARG, CharP(B), (L)))
#define SANITIZE_MEM(B,L) likely (_hb_sanitize_check (SANITIZE_ARG, CharP(B), (L)))
#define SANITIZE_ARRAY(A,S,L) HB_LIKELY (_hb_sanitize_array (SANITIZE_ARG, CharP(A), S, L))
#define SANITIZE_ARRAY(A,S,L) likely (_hb_sanitize_array (SANITIZE_ARG, CharP(A), S, L))
#define NEUTER(Obj, Val) \
(SANITIZE_OBJ (Obj) && \
@ -445,7 +445,7 @@ struct GenericOffsetTo : OffsetType
inline const Type& operator () (const void *base) const
{
unsigned int offset = *this;
if (HB_UNLIKELY (!offset)) return Null(Type);
if (unlikely (!offset)) return Null(Type);
return StructAtOffset<Type> (*CharP(base), offset);
}
@ -453,21 +453,21 @@ struct GenericOffsetTo : OffsetType
TRACE_SANITIZE ();
if (!SANITIZE_SELF ()) return false;
unsigned int offset = *this;
if (HB_UNLIKELY (!offset)) return true;
if (unlikely (!offset)) return true;
return SANITIZE (StructAtOffset<Type> (*CharP(base), offset)) || NEUTER (*this, 0);
}
inline bool sanitize (SANITIZE_ARG_DEF, void *base, void *base2) {
TRACE_SANITIZE ();
if (!SANITIZE_SELF ()) return false;
unsigned int offset = *this;
if (HB_UNLIKELY (!offset)) return true;
if (unlikely (!offset)) return true;
return SANITIZE_BASE (StructAtOffset<Type> (*CharP(base), offset), base2) || NEUTER (*this, 0);
}
inline bool sanitize (SANITIZE_ARG_DEF, void *base, unsigned int user_data) {
TRACE_SANITIZE ();
if (!SANITIZE_SELF ()) return false;
unsigned int offset = *this;
if (HB_UNLIKELY (!offset)) return true;
if (unlikely (!offset)) return true;
return SANITIZE_BASE (StructAtOffset<Type> (*CharP(base), offset), user_data) || NEUTER (*this, 0);
}
};
@ -494,7 +494,7 @@ struct GenericArrayOf
const Type *sub_array (unsigned int start_offset, unsigned int *pcount /* IN/OUT */) const
{
unsigned int count = len;
if (HB_UNLIKELY (start_offset > count))
if (unlikely (start_offset > count))
count = 0;
else
count -= start_offset;
@ -505,7 +505,7 @@ struct GenericArrayOf
inline const Type& operator [] (unsigned int i) const
{
if (HB_UNLIKELY (i >= len)) return Null(Type);
if (unlikely (i >= len)) return Null(Type);
return array()[i];
}
inline unsigned int get_size () const
@ -518,7 +518,7 @@ struct GenericArrayOf
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
if (!HB_LIKELY (sanitize_shallow (SANITIZE_ARG))) return false;
if (!likely (sanitize_shallow (SANITIZE_ARG))) return false;
/* Note: for structs that do not reference other structs,
* we do not need to call their sanitize() as we already did
* a bound check on the aggregate array size, hence the return.
@ -535,7 +535,7 @@ struct GenericArrayOf
}
inline bool sanitize (SANITIZE_ARG_DEF, void *base) {
TRACE_SANITIZE ();
if (!HB_LIKELY (sanitize_shallow (SANITIZE_ARG))) return false;
if (!likely (sanitize_shallow (SANITIZE_ARG))) return false;
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
if (!array()[i].sanitize (SANITIZE_ARG, base))
@ -544,7 +544,7 @@ struct GenericArrayOf
}
inline bool sanitize (SANITIZE_ARG_DEF, void *base, void *base2) {
TRACE_SANITIZE ();
if (!HB_LIKELY (sanitize_shallow (SANITIZE_ARG))) return false;
if (!likely (sanitize_shallow (SANITIZE_ARG))) return false;
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
if (!array()[i].sanitize (SANITIZE_ARG, base, base2))
@ -553,7 +553,7 @@ struct GenericArrayOf
}
inline bool sanitize (SANITIZE_ARG_DEF, void *base, unsigned int user_data) {
TRACE_SANITIZE ();
if (!HB_LIKELY (sanitize_shallow (SANITIZE_ARG))) return false;
if (!likely (sanitize_shallow (SANITIZE_ARG))) return false;
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
if (!array()[i].sanitize (SANITIZE_ARG, base, user_data))
@ -591,7 +591,7 @@ struct OffsetListOf : OffsetArrayOf<Type>
{
inline const Type& operator [] (unsigned int i) const
{
if (HB_UNLIKELY (i >= this->len)) return Null(Type);
if (unlikely (i >= this->len)) return Null(Type);
return this+this->array()[i];
}
@ -616,7 +616,7 @@ struct HeadlessArrayOf
inline const Type& operator [] (unsigned int i) const
{
if (HB_UNLIKELY (i >= len || !i)) return Null(Type);
if (unlikely (i >= len || !i)) return Null(Type);
return array()[i-1];
}
inline unsigned int get_size () const
@ -629,7 +629,7 @@ struct HeadlessArrayOf
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
if (!HB_LIKELY (sanitize_shallow (SANITIZE_ARG))) return false;
if (!likely (sanitize_shallow (SANITIZE_ARG))) return false;
/* Note: for structs that do not reference other structs,
* we do not need to call their sanitize() as we already did
* a bound check on the aggregate array size, hence the return.

16
src/hb-ot-layout-common-private.hh
View File

@ -68,7 +68,7 @@ template <typename Type>
struct RecordArrayOf : ArrayOf<Record<Type> > {
inline const Tag& get_tag (unsigned int i) const
{
if (HB_UNLIKELY (i >= this->len)) return Null(Tag);
if (unlikely (i >= this->len)) return Null(Tag);
return (*this)[i].tag;
}
inline unsigned int get_tags (unsigned int start_offset,
@ -120,7 +120,7 @@ struct IndexArray : ArrayOf<USHORT>
{
inline unsigned int operator [] (unsigned int i) const
{
if (HB_UNLIKELY (i >= this->len))
if (unlikely (i >= this->len))
return NO_INDEX;
return this->array()[i];
}
@ -272,7 +272,7 @@ struct Lookup
inline unsigned int get_flag (void) const
{
unsigned int flag = lookupFlag;
if (HB_UNLIKELY (flag & LookupFlag::UseMarkFilteringSet))
if (unlikely (flag & LookupFlag::UseMarkFilteringSet))
{
const USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
flag += (markFilteringSet << 16);
@ -283,8 +283,8 @@ struct Lookup
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
/* Real sanitize of the subtables is done by GSUB/GPOS/... */
if (!(SANITIZE_SELF () && HB_LIKELY (subTable.sanitize (SANITIZE_ARG)))) return false;
if (HB_UNLIKELY (lookupFlag & LookupFlag::UseMarkFilteringSet))
if (!(SANITIZE_SELF () && likely (subTable.sanitize (SANITIZE_ARG)))) return false;
if (unlikely (lookupFlag & LookupFlag::UseMarkFilteringSet))
{
USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
if (!SANITIZE (markFilteringSet)) return false;
@ -317,7 +317,7 @@ struct CoverageFormat1
private:
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
{
if (HB_UNLIKELY (glyph_id > 0xFFFF))
if (unlikely (glyph_id > 0xFFFF))
return NOT_COVERED;
GlyphID gid;
gid.set (glyph_id);
@ -563,7 +563,7 @@ struct Device
inline int get_delta (unsigned int ppem_size) const
{
unsigned int f = deltaFormat;
if (HB_UNLIKELY (f < 1 || f > 3))
if (unlikely (f < 1 || f > 3))
return 0;
if (ppem_size < startSize || ppem_size > endSize)
@ -586,7 +586,7 @@ struct Device
inline unsigned int get_size () const
{
unsigned int f = deltaFormat;
if (HB_UNLIKELY (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::get_size ();
if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::get_size ();
return USHORT::get_size () * (4 + ((endSize - startSize) >> (4 - f)));
}

2
src/hb-ot-layout-gdef-private.hh
View File

@ -349,7 +349,7 @@ struct GDEF
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
if (!SANITIZE (version)) return false;
if (HB_UNLIKELY (version.major != 1)) return false;
if (unlikely (version.major != 1)) return false;
return SANITIZE_THIS2 (glyphClassDef, attachList) &&
SANITIZE_THIS2 (ligCaretList, markAttachClassDef) &&
(version < 0x00010002 || SANITIZE_THIS (markGlyphSetsDef[0]));

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

@ -326,14 +326,14 @@ struct Anchor
struct AnchorMatrix
{
inline const Anchor& get_anchor (unsigned int row, unsigned int col, unsigned int cols) const {
if (HB_UNLIKELY (row >= rows || col >= cols)) return Null(Anchor);
if (unlikely (row >= rows || col >= cols)) return Null(Anchor);
return this+matrix[row * cols + col];
}
inline bool sanitize (SANITIZE_ARG_DEF, unsigned int cols) {
TRACE_SANITIZE ();
if (!SANITIZE_SELF ()) return false;
if (HB_UNLIKELY (cols >= ((unsigned int) -1) / rows)) return false;
if (unlikely (cols >= ((unsigned int) -1) / rows)) return false;
unsigned int count = rows * cols;
if (!SANITIZE_ARRAY (matrix, matrix[0].get_size (), count)) return false;
for (unsigned int i = 0; i < count; i++)
@ -422,7 +422,7 @@ struct SinglePosFormat1
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
valueFormat.apply_value (layout_context, CharP(this), values, CURPOSITION ());
@ -459,10 +459,10 @@ struct SinglePosFormat2
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
if (HB_LIKELY (index >= valueCount))
if (likely (index >= valueCount))
return false;
valueFormat.apply_value (layout_context, CharP(this),
@ -568,17 +568,17 @@ struct PairPosFormat1
{
TRACE_APPLY ();
unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length);
if (HB_UNLIKELY (buffer->in_pos + 2 > end))
if (unlikely (buffer->in_pos + 2 > end))
return false;
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
unsigned int j = buffer->in_pos + 1;
while (_hb_ot_layout_skip_mark (layout_context->face, IN_INFO (j), context->lookup_flag, NULL))
{
if (HB_UNLIKELY (j == end))
if (unlikely (j == end))
return false;
j++;
}
@ -614,7 +614,7 @@ struct PairPosFormat1
unsigned int len2 = valueFormat2.get_len ();
if (!(SANITIZE_SELF () && SANITIZE_THIS (coverage) &&
HB_LIKELY (pairSet.sanitize (SANITIZE_ARG, CharP(this), len1 + len2)))) return false;
likely (pairSet.sanitize (SANITIZE_ARG, CharP(this), len1 + len2)))) return false;
if (!(valueFormat1.has_device () || valueFormat2.has_device ())) return true;
@ -660,17 +660,17 @@ struct PairPosFormat2
{
TRACE_APPLY ();
unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length);
if (HB_UNLIKELY (buffer->in_pos + 2 > end))
if (unlikely (buffer->in_pos + 2 > end))
return false;
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
unsigned int j = buffer->in_pos + 1;
while (_hb_ot_layout_skip_mark (layout_context->face, IN_INFO (j), context->lookup_flag, NULL))
{
if (HB_UNLIKELY (j == end))
if (unlikely (j == end))
return false;
j++;
}
@ -681,7 +681,7 @@ struct PairPosFormat2
unsigned int klass1 = (this+classDef1) (IN_CURGLYPH ());
unsigned int klass2 = (this+classDef2) (IN_GLYPH (j));
if (HB_UNLIKELY (klass1 >= class1Count || klass2 >= class2Count))
if (unlikely (klass1 >= class1Count || klass2 >= class2Count))
return false;
const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
@ -927,7 +927,7 @@ struct CursivePosFormat1
return false;
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const EntryExitRecord &record = entryExitRecord[index];
@ -1034,7 +1034,7 @@ struct MarkBasePosFormat1
{
TRACE_APPLY ();
unsigned int mark_index = (this+markCoverage) (IN_CURGLYPH ());
if (HB_LIKELY (mark_index == NOT_COVERED))
if (likely (mark_index == NOT_COVERED))
return false;
/* now we search backwards for a non-mark glyph */
@ -1042,7 +1042,7 @@ struct MarkBasePosFormat1
unsigned int j = buffer->in_pos;
do
{
if (HB_UNLIKELY (!j))
if (unlikely (!j))
return false;
j--;
} while (_hb_ot_layout_skip_mark (layout_context->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
@ -1063,7 +1063,7 @@ struct MarkBasePosFormat1
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
return SANITIZE_SELF () && SANITIZE_THIS3 (markCoverage, baseCoverage, markArray) &&
HB_LIKELY (baseArray.sanitize (SANITIZE_ARG, CharP(this), classCount));
likely (baseArray.sanitize (SANITIZE_ARG, CharP(this), classCount));
}
private:
@ -1134,7 +1134,7 @@ struct MarkLigPosFormat1
{
TRACE_APPLY ();
unsigned int mark_index = (this+markCoverage) (IN_CURGLYPH ());
if (HB_LIKELY (mark_index == NOT_COVERED))
if (likely (mark_index == NOT_COVERED))
return false;
/* now we search backwards for a non-mark glyph */
@ -1142,7 +1142,7 @@ struct MarkLigPosFormat1
unsigned int j = buffer->in_pos;
do
{
if (HB_UNLIKELY (!j))
if (unlikely (!j))
return false;
j--;
} while (_hb_ot_layout_skip_mark (layout_context->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
@ -1162,7 +1162,7 @@ struct MarkLigPosFormat1
/* Find component to attach to */
unsigned int comp_count = lig_attach.rows;
if (HB_UNLIKELY (!comp_count))
if (unlikely (!comp_count))
return false;
unsigned int comp_index;
/* We must now check whether the ligature ID of the current mark glyph
@ -1184,7 +1184,7 @@ struct MarkLigPosFormat1
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
return SANITIZE_SELF () && SANITIZE_THIS3 (markCoverage, ligatureCoverage, markArray) &&
HB_LIKELY (ligatureArray.sanitize (SANITIZE_ARG, CharP(this), classCount));
likely (ligatureArray.sanitize (SANITIZE_ARG, CharP(this), classCount));
}
private:
@ -1251,7 +1251,7 @@ struct MarkMarkPosFormat1
{
TRACE_APPLY ();
unsigned int mark1_index = (this+mark1Coverage) (IN_CURGLYPH ());
if (HB_LIKELY (mark1_index == NOT_COVERED))
if (likely (mark1_index == NOT_COVERED))
return false;
/* now we search backwards for a suitable mark glyph until a non-mark glyph */
@ -1259,7 +1259,7 @@ struct MarkMarkPosFormat1
unsigned int j = buffer->in_pos;
do
{
if (HB_UNLIKELY (!j))
if (unlikely (!j))
return false;
j--;
} while (_hb_ot_layout_skip_mark (layout_context->face, IN_INFO (j), context->lookup_flag, &property));
@ -1284,7 +1284,7 @@ struct MarkMarkPosFormat1
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
return SANITIZE_SELF () && SANITIZE_THIS3 (mark1Coverage, mark2Coverage, mark1Array) &&
HB_LIKELY (mark2Array.sanitize (SANITIZE_ARG, CharP(this), classCount));
likely (mark2Array.sanitize (SANITIZE_ARG, CharP(this), classCount));
}
private:
@ -1373,7 +1373,7 @@ struct ExtensionPos : Extension
inline const struct PosLookupSubTable& get_subtable (void) const
{
unsigned int offset = get_offset ();
if (HB_UNLIKELY (!offset)) return Null(PosLookupSubTable);
if (unlikely (!offset)) return Null(PosLookupSubTable);
return StructAtOffset<PosLookupSubTable> (*this, offset);
}
@ -1488,7 +1488,7 @@ struct PosLookup : Lookup
{
bool ret = false;
if (HB_UNLIKELY (!buffer->in_length))
if (unlikely (!buffer->in_length))
return false;
layout_context->info.gpos.last = HB_OT_LAYOUT_GPOS_NO_LAST; /* no last valid glyph for cursive pos. */
@ -1519,7 +1519,7 @@ struct PosLookup : Lookup
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
if (HB_UNLIKELY (!Lookup::sanitize (SANITIZE_ARG))) return false;
if (unlikely (!Lookup::sanitize (SANITIZE_ARG))) return false;
OffsetArrayOf<PosLookupSubTable> &list = CastR<OffsetArrayOf<PosLookupSubTable> > (subTable);
return SANITIZE_THIS (list);
}
@ -1547,7 +1547,7 @@ struct GPOS : GSUBGPOS
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
if (HB_UNLIKELY (!GSUBGPOS::sanitize (SANITIZE_ARG))) return false;
if (unlikely (!GSUBGPOS::sanitize (SANITIZE_ARG))) return false;
OffsetTo<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
return SANITIZE_THIS (list);
}
@ -1566,9 +1566,9 @@ inline bool ExtensionPos::apply (APPLY_ARG_DEF) const
inline bool ExtensionPos::sanitize (SANITIZE_ARG_DEF)
{
TRACE_SANITIZE ();
if (HB_UNLIKELY (!Extension::sanitize (SANITIZE_ARG))) return false;
if (unlikely (!Extension::sanitize (SANITIZE_ARG))) return false;
unsigned int offset = get_offset ();
if (HB_UNLIKELY (!offset)) return true;
if (unlikely (!offset)) return true;
return SANITIZE (StructAtOffset<PosLookupSubTable> (*this, offset));
}
@ -1577,10 +1577,10 @@ static inline bool position_lookup (APPLY_ARG_DEF, unsigned int lookup_index)
const GPOS &gpos = *(layout_context->face->ot_layout.gpos);
const PosLookup &l = gpos.get_lookup (lookup_index);
if (HB_UNLIKELY (context->nesting_level_left == 0))
if (unlikely (context->nesting_level_left == 0))
return false;
if (HB_UNLIKELY (context_length < 1))
if (unlikely (context_length < 1))
return false;
return l.apply_once (layout_context, buffer, context_length, context->nesting_level_left - 1, apply_depth + 1);

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

@ -41,7 +41,7 @@ struct SingleSubstFormat1
TRACE_APPLY ();
hb_codepoint_t glyph_id = IN_CURGLYPH ();
unsigned int index = (this+coverage) (glyph_id);
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
glyph_id += deltaGlyphID;
@ -80,10 +80,10 @@ struct SingleSubstFormat2
TRACE_APPLY ();
hb_codepoint_t glyph_id = IN_CURGLYPH ();
unsigned int index = (this+coverage) (glyph_id);
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
if (HB_UNLIKELY (index >= substitute.len))
if (unlikely (index >= substitute.len))
return false;
glyph_id = substitute[index];
@ -155,7 +155,7 @@ struct Sequence
inline bool apply (APPLY_ARG_DEF) const
{
TRACE_APPLY ();
if (HB_UNLIKELY (!substitute.len))
if (unlikely (!substitute.len))
return false;
_hb_buffer_add_output_glyphs_be16 (buffer, 1,
@ -200,7 +200,7 @@ struct MultipleSubstFormat1
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
return (this+sequence[index]).apply (APPLY_ARG);
@ -270,12 +270,12 @@ struct AlternateSubstFormat1
hb_codepoint_t glyph_id = IN_CURGLYPH ();
unsigned int index = (this+coverage) (glyph_id);
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const AlternateSet &alt_set = this+alternateSet[index];
if (HB_UNLIKELY (!alt_set.len))
if (unlikely (!alt_set.len))
return false;
unsigned int alt_index = 0;
@ -287,7 +287,7 @@ struct AlternateSubstFormat1
alt_set.len, alt_set.array);
*/
if (HB_UNLIKELY (alt_index >= alt_set.len))
if (unlikely (alt_index >= alt_set.len))
return false;
glyph_id = alt_set[alt_index];
@ -360,7 +360,7 @@ struct Ligature
unsigned int i, j;
unsigned int count = component.len;
unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length);
if (HB_UNLIKELY (buffer->in_pos + count > end))
if (unlikely (buffer->in_pos + count > end))
return false;
for (i = 1, j = buffer->in_pos + 1; i < count; i++, j++)
@ -368,7 +368,7 @@ struct Ligature
unsigned int property;
while (_hb_ot_layout_skip_mark (layout_context->face, IN_INFO (j), context->lookup_flag, &property))
{
if (HB_UNLIKELY (j + count - i == end))
if (unlikely (j + count - i == end))
return false;
j++;
}
@ -376,7 +376,7 @@ struct Ligature
if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_MARK))
is_mark = false;
if (HB_LIKELY (IN_GLYPH (j) != component[i]))
if (likely (IN_GLYPH (j) != component[i]))
return false;
}
/* This is just a guess ... */
@ -477,7 +477,7 @@ struct LigatureSubstFormat1
bool first_is_mark = !!(context->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK);
unsigned int index = (this+coverage) (glyph_id);
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const LigatureSet &lig_set = this+ligatureSet[index];
@ -568,7 +568,7 @@ struct ExtensionSubst : Extension
inline const struct SubstLookupSubTable& get_subtable (void) const
{
unsigned int offset = get_offset ();
if (HB_UNLIKELY (!offset)) return Null(SubstLookupSubTable);
if (unlikely (!offset)) return Null(SubstLookupSubTable);
return StructAtOffset<SubstLookupSubTable> (*this, offset);
}
@ -588,11 +588,11 @@ struct ReverseChainSingleSubstFormat1
inline bool apply (APPLY_ARG_DEF) const
{
TRACE_APPLY ();
if (HB_UNLIKELY (context_length != NO_CONTEXT))
if (unlikely (context_length != NO_CONTEXT))
return false; /* No chaining to this type */
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
@ -753,7 +753,7 @@ struct SubstLookup : Lookup
inline bool is_reverse (void) const
{
unsigned int type = get_type ();
if (HB_UNLIKELY (type == SubstLookupSubTable::Extension))
if (unlikely (type == SubstLookupSubTable::Extension))
return CastR<ExtensionSubst> (get_subtable(0)).is_reverse ();
return lookup_type_is_reverse (type);
}
@ -774,7 +774,7 @@ struct SubstLookup : Lookup
if (!_hb_ot_layout_check_glyph_property (layout_context->face, IN_CURINFO (), context->lookup_flag, &context->property))
return false;
if (HB_UNLIKELY (lookup_type == SubstLookupSubTable::Extension))
if (unlikely (lookup_type == SubstLookupSubTable::Extension))
{
/* The spec says all subtables should have the same type.
* This is specially important if one has a reverse type!
@ -802,10 +802,10 @@ struct SubstLookup : Lookup
{
bool ret = false;
if (HB_UNLIKELY (!buffer->in_length))
if (unlikely (!buffer->in_length))
return false;
if (HB_LIKELY (!is_reverse ()))
if (likely (!is_reverse ()))
{
/* in/out forward substitution */
_hb_buffer_clear_output (buffer);
@ -843,7 +843,7 @@ struct SubstLookup : Lookup
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
if (HB_UNLIKELY (!Lookup::sanitize (SANITIZE_ARG))) return false;
if (unlikely (!Lookup::sanitize (SANITIZE_ARG))) return false;
OffsetArrayOf<SubstLookupSubTable> &list = CastR<OffsetArrayOf<SubstLookupSubTable> > (subTable);
return SANITIZE_THIS (list);
}
@ -872,7 +872,7 @@ struct GSUB : GSUBGPOS
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
if (HB_UNLIKELY (!GSUBGPOS::sanitize (SANITIZE_ARG))) return false;
if (unlikely (!GSUBGPOS::sanitize (SANITIZE_ARG))) return false;
OffsetTo<SubstLookupList> &list = CastR<OffsetTo<SubstLookupList> > (lookupList);
return SANITIZE_THIS (list);
}
@ -891,16 +891,16 @@ inline bool ExtensionSubst::apply (APPLY_ARG_DEF) const
inline bool ExtensionSubst::sanitize (SANITIZE_ARG_DEF)
{
TRACE_SANITIZE ();
if (HB_UNLIKELY (!Extension::sanitize (SANITIZE_ARG))) return false;
if (unlikely (!Extension::sanitize (SANITIZE_ARG))) return false;
unsigned int offset = get_offset ();
if (HB_UNLIKELY (!offset)) return true;
if (unlikely (!offset)) return true;
return SANITIZE (StructAtOffset<SubstLookupSubTable> (*this, offset));
}
inline bool ExtensionSubst::is_reverse (void) const
{
unsigned int type = get_type ();
if (HB_UNLIKELY (type == SubstLookupSubTable::Extension))
if (unlikely (type == SubstLookupSubTable::Extension))
return CastR<ExtensionSubst> (get_subtable()).is_reverse ();
return SubstLookup::lookup_type_is_reverse (type);
}
@ -910,10 +910,10 @@ static inline bool substitute_lookup (APPLY_ARG_DEF, unsigned int lookup_index)
const GSUB &gsub = *(layout_context->face->ot_layout.gsub);
const SubstLookup &l = gsub.get_lookup (lookup_index);
if (HB_UNLIKELY (context->nesting_level_left == 0))
if (unlikely (context->nesting_level_left == 0))
return false;
if (HB_UNLIKELY (context_length < 1))
if (unlikely (context_length < 1))
return false;
return l.apply_once (layout_context, buffer, context_length, context->nesting_level_left - 1, apply_depth + 1);

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

@ -100,19 +100,19 @@ static inline bool match_input (APPLY_ARG_DEF,
{
unsigned int i, j;
unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length);
if (HB_UNLIKELY (buffer->in_pos + count > end))
if (unlikely (buffer->in_pos + count > end))
return false;
for (i = 1, j = buffer->in_pos + 1; i < count; i++, j++)
{
while (_hb_ot_layout_skip_mark (layout_context->face, IN_INFO (j), context->lookup_flag, NULL))
{
if (HB_UNLIKELY (j + count - i == end))
if (unlikely (j + count - i == end))
return false;
j++;
}
if (HB_LIKELY (!match_func (IN_GLYPH (j), input[i - 1], match_data)))
if (likely (!match_func (IN_GLYPH (j), input[i - 1], match_data)))
return false;
}
@ -127,19 +127,19 @@ static inline bool match_backtrack (APPLY_ARG_DEF,
match_func_t match_func,
const char *match_data)
{
if (HB_UNLIKELY (buffer->out_pos < count))
if (unlikely (buffer->out_pos < count))
return false;
for (unsigned int i = 0, j = buffer->out_pos - 1; i < count; i++, j--)
{
while (_hb_ot_layout_skip_mark (layout_context->face, OUT_INFO (j), context->lookup_flag, NULL))
{
if (HB_UNLIKELY (j + 1 == count - i))
if (unlikely (j + 1 == count - i))
return false;
j--;
}
if (HB_LIKELY (!match_func (OUT_GLYPH (j), backtrack[i], match_data)))
if (likely (!match_func (OUT_GLYPH (j), backtrack[i], match_data)))
return false;
}
@ -155,19 +155,19 @@ static inline bool match_lookahead (APPLY_ARG_DEF,
{
unsigned int i, j;
unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length);
if (HB_UNLIKELY (buffer->in_pos + offset + count > end))
if (unlikely (buffer->in_pos + offset + count > end))
return false;
for (i = 0, j = buffer->in_pos + offset; i < count; i++, j++)
{
while (_hb_ot_layout_skip_mark (layout_context->face, OUT_INFO (j), context->lookup_flag, NULL))
{
if (HB_UNLIKELY (j + count - i == end))
if (unlikely (j + count - i == end))
return false;
j++;
}
if (HB_LIKELY (!match_func (IN_GLYPH (j), lookahead[i], match_data)))
if (likely (!match_func (IN_GLYPH (j), lookahead[i], match_data)))
return false;
}
@ -198,7 +198,7 @@ static inline bool apply_lookup (APPLY_ARG_DEF,
apply_lookup_func_t apply_func)
{
unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length);
if (HB_UNLIKELY (buffer->in_pos + count > end))
if (unlikely (buffer->in_pos + count > end))
return false;
/* TODO We don't support lookupRecord arrays that are not increasing:
@ -212,7 +212,7 @@ static inline bool apply_lookup (APPLY_ARG_DEF,
{
while (_hb_ot_layout_skip_mark (layout_context->face, IN_CURINFO (), context->lookup_flag, NULL))
{
if (HB_UNLIKELY (buffer->in_pos == end))
if (unlikely (buffer->in_pos == end))
return true;
/* No lookup applied for this index */
_hb_buffer_next_glyph (buffer);
@ -229,7 +229,7 @@ static inline bool apply_lookup (APPLY_ARG_DEF,
lookupCount--;
/* Err, this is wrong if the lookup jumped over some glyphs */
i += buffer->in_pos - old_pos;
if (HB_UNLIKELY (buffer->in_pos == end))
if (unlikely (buffer->in_pos == end))
return true;
if (!done)
@ -345,7 +345,7 @@ struct ContextFormat1
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const RuleSet &rule_set = this+ruleSet[index];
@ -382,7 +382,7 @@ struct ContextFormat2
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const ClassDef &class_def = this+classDef;
@ -427,7 +427,7 @@ struct ContextFormat3
{
TRACE_APPLY ();
unsigned int index = (this+coverage[0]) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const LookupRecord &lookupRecord = StructAtOffset<LookupRecord> (coverage, coverage[0].get_size () * glyphCount);
@ -520,7 +520,7 @@ static inline bool chain_context_lookup (APPLY_ARG_DEF,
ChainContextLookupContext &lookup_context)
{
/* First guess */
if (HB_UNLIKELY (buffer->out_pos < backtrackCount ||
if (unlikely (buffer->out_pos < backtrackCount ||
buffer->in_pos + inputCount + lookaheadCount > buffer->in_length ||
inputCount + lookaheadCount > context_length))
return false;
@ -629,7 +629,7 @@ struct ChainContextFormat1
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const ChainRuleSet &rule_set = this+ruleSet[index];
@ -665,7 +665,7 @@ struct ChainContextFormat2
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const ClassDef &backtrack_class_def = this+backtrackClassDef;
@ -728,7 +728,7 @@ struct ChainContextFormat3
const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
unsigned int index = (this+input[0]) (IN_CURGLYPH ());
if (HB_LIKELY (index == NOT_COVERED))
if (likely (index == NOT_COVERED))
return false;
const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
@ -912,7 +912,7 @@ struct GSUBGPOS
inline bool sanitize (SANITIZE_ARG_DEF) {
TRACE_SANITIZE ();
if (!SANITIZE (version)) return false;
if (HB_UNLIKELY (version.major != 1)) return false;
if (unlikely (version.major != 1)) return false;
return SANITIZE_THIS3 (scriptList, featureList, lookupList);
}

12
src/hb-ot-layout.cc
View File

@ -75,19 +75,19 @@ _hb_ot_layout_fini (hb_face_t *face)
static const GDEF&
_get_gdef (hb_face_t *face)
{
return HB_LIKELY (face->ot_layout.gdef) ? *face->ot_layout.gdef : Null(GDEF);
return likely (face->ot_layout.gdef) ? *face->ot_layout.gdef : Null(GDEF);
}
static const GSUB&
_get_gsub (hb_face_t *face)
{
return HB_LIKELY (face->ot_layout.gsub) ? *face->ot_layout.gsub : Null(GSUB);
return likely (face->ot_layout.gsub) ? *face->ot_layout.gsub : Null(GSUB);
}
static const GPOS&
_get_gpos (hb_face_t *face)
{
return HB_LIKELY (face->ot_layout.gpos) ? *face->ot_layout.gpos : Null(GPOS);
return likely (face->ot_layout.gpos) ? *face->ot_layout.gpos : Null(GPOS);
}
@ -219,7 +219,7 @@ _hb_ot_layout_set_glyph_class (hb_face_t *face,
hb_ot_layout_class_t gdef_klass;
unsigned int len = layout->new_gdef.len;
if (HB_UNLIKELY (glyph > 65535))
if (unlikely (glyph > 65535))
return;
/* XXX this is not threadsafe */
@ -235,7 +235,7 @@ _hb_ot_layout_set_glyph_class (hb_face_t *face,
new_len = 65536;
new_klasses = (unsigned char *) realloc (layout->new_gdef.klasses, new_len * sizeof (unsigned char));
if (HB_UNLIKELY (!new_klasses))
if (unlikely (!new_klasses))
return;
memset (new_klasses + len, 0, new_len - len);
@ -290,7 +290,7 @@ hb_ot_layout_build_glyph_classes (hb_face_t *face,
hb_ot_layout_t *layout = &face->ot_layout;
if (HB_UNLIKELY (!count || !glyphs || !klasses))
if (unlikely (!count || !glyphs || !klasses))
return;
if (layout->new_gdef.len == 0) {

2
src/hb-ot-tag.c
View File

@ -128,7 +128,7 @@ hb_ot_tags_from_script (hb_script_t script)
{
static const hb_tag_t def_tag[] = {HB_OT_TAG_DEFAULT_SCRIPT, HB_TAG_NONE};
if (HB_UNLIKELY ((unsigned int) script >= ARRAY_LENGTH (ot_scripts)))
if (unlikely ((unsigned int) script >= ARRAY_LENGTH (ot_scripts)))
return def_tag;
return ot_scripts[script];

8
src/hb-private.h
View File

@ -104,11 +104,11 @@
_hb_boolean_var_ = 0; \
_hb_boolean_var_; \
})
#define HB_LIKELY(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 1))
#define HB_UNLIKELY(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 0))
#define likely(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 1))
#define unlikely(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 0))
#else
#define HB_LIKELY(expr) (expr)
#define HB_UNLIKELY(expr) (expr)
#define likely(expr) (expr)
#define unlikely(expr) (expr)
#endif
#ifndef __GNUC__

10
src/hb-shape.c
View File

@ -38,9 +38,9 @@
static inline hb_bool_t
is_variation_selector (hb_codepoint_t unicode)
{
return HB_UNLIKELY ((unicode >= 0x180B && unicode <= 0x180D) || /* MONGOLIAN FREE VARIATION SELECTOR ONE..THREE */
(unicode >= 0xFE00 && unicode <= 0xFE0F) || /* VARIATION SELECTOR-1..16 */
(unicode >= 0xE0100 && unicode <= 0xE01EF)); /* VARIATION SELECTOR-17..256 */
return unlikely ((unicode >= 0x180B && unicode <= 0x180D) || /* MONGOLIAN FREE VARIATION SELECTOR ONE..THREE */
(unicode >= 0xFE00 && unicode <= 0xFE0F) || /* VARIATION SELECTOR-1..16 */
(unicode >= 0xE0100 && unicode <= 0xE01EF)); /* VARIATION SELECTOR-17..256 */
}
static void
@ -95,11 +95,11 @@ hb_map_glyphs (hb_font_t *font,
{
unsigned int count;
if (HB_UNLIKELY (!buffer->in_length))
if (unlikely (!buffer->in_length))
return;
count = buffer->in_length - 1;
for (buffer->in_pos = 0; buffer->in_pos < count; buffer->in_pos++) {
if (HB_UNLIKELY (is_variation_selector (IN_NEXTGLYPH()))) {
if (unlikely (is_variation_selector (IN_NEXTGLYPH()))) {
IN_CURGLYPH() = hb_font_get_glyph (font, face, IN_CURGLYPH(), IN_NEXTGLYPH());
buffer->in_pos++;
} else {

2
src/hb-unicode.c
View File

@ -294,7 +294,7 @@ const hb_direction_t horiz_dir[] =
HB_INTERNAL hb_direction_t
_hb_script_get_horizontal_direction (hb_script_t script)
{
if (HB_UNLIKELY ((unsigned int) script >= ARRAY_LENGTH (horiz_dir)))
if (unlikely ((unsigned int) script >= ARRAY_LENGTH (horiz_dir)))
return HB_DIRECTION_LTR;
return horiz_dir[script];