Roll harfbuzz-ng to 1.0.5

third_party/harfbuzz-ng/src/hb-ot-cmap-table.hh

 /*
  * Copyright © 2014  Google, Inc.
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
  * all copies of this software.
@@ skipping 36 matching lines @@
     hb_codepoint_t gid = codepoint < 256 ? glyphIdArray[codepoint] : 0;
     if (!gid)
       return false;
     *glyph = gid;
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this));
+    return_trace (c->check_struct (this));
   }
 
   protected:
   USHORT        format;         /* Format number is set to 0. */
   USHORT        lengthZ;        /* Byte length of this subtable. */
   USHORT        languageZ;      /* Ignore. */
   BYTE          glyphIdArray[256];/* An array that maps character
                                  * code to glyph index values. */
   public:
   DEFINE_SIZE_STATIC (6 + 256);
@@ skipping 55 matching lines @@
     }
 
     *glyph = gid & 0xFFFFu;
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
     if (unlikely (!c->check_struct (this)))
-      return TRACE_RETURN (false);
+      return_trace (false);
 
     if (unlikely (!c->check_range (this, length)))
     {
       /* Some broken fonts have too long of a "length" value.
        * If that is the case, just change the value to truncate
        * the subtable at the end of the blob. */
       uint16_t new_length = (uint16_t) MIN ((uintptr_t) 65535,
                                             (uintptr_t) (c->end -
                                                          (char *) this));
       if (!c->try_set (&length, new_length))
-        return TRACE_RETURN (false);
+        return_trace (false);
     }
 
-    return TRACE_RETURN (16 + 4 * (unsigned int) segCountX2 <= length);
+    return_trace (16 + 4 * (unsigned int) segCountX2 <= length);
   }
 
   protected:
   USHORT        format;         /* Format number is set to 4. */
   USHORT        length;         /* This is the length in bytes of the
                                  * subtable. */
   USHORT        languageZ;      /* Ignore. */
   USHORT        segCountX2;     /* 2 x segCount. */
   USHORT        searchRangeZ;   /* 2 * (2**floor(log2(segCount))) */
   USHORT        entrySelectorZ; /* log2(searchRange/2) */
@@ skipping 22 matching lines @@
   int cmp (hb_codepoint_t codepoint) const
   {
     if (codepoint < startCharCode) return -1;
     if (codepoint > endCharCode)   return +1;
     return 0;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this));
+    return_trace (c->check_struct (this));
   }
 
   private:
   ULONG         startCharCode;  /* First character code in this group. */
   ULONG         endCharCode;    /* Last character code in this group. */
   ULONG         glyphID;        /* Glyph index; interpretation depends on
                                  * subtable format. */
   public:
   DEFINE_SIZE_STATIC (12);
 };
 
 template <typename UINT>
 struct CmapSubtableTrimmed
 {
   inline bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
   {
     /* Rely on our implicit array bound-checking. */
     hb_codepoint_t gid = glyphIdArray[codepoint - startCharCode];
     if (!gid)
       return false;
     *glyph = gid;
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this) && glyphIdArray.sanitize (c));
+    return_trace (c->check_struct (this) && glyphIdArray.sanitize (c));
   }
 
   protected:
   UINT          formatReserved; /* Subtable format and (maybe) padding. */
   UINT          lengthZ;        /* Byte length of this subtable. */
   UINT          languageZ;      /* Ignore. */
   UINT          startCharCode;  /* First character code covered. */
   ArrayOf<GlyphID, UINT>
                 glyphIdArray;   /* Array of glyph index values for character
                                  * codes in the range. */
@@ skipping 12 matching lines @@
     int i = groups.bsearch (codepoint);
     if (i == -1)
       return false;
     *glyph = T::group_get_glyph (groups[i], codepoint);
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this) && groups.sanitize (c));
+    return_trace (c->check_struct (this) && groups.sanitize (c));
   }
 
   protected:
   USHORT        format;         /* Subtable format; set to 12. */
   USHORT        reservedZ;      /* Reserved; set to 0. */
   ULONG         lengthZ;        /* Byte length of this subtable. */
   ULONG         languageZ;      /* Ignore. */
   SortedArrayOf<CmapSubtableLongGroup, ULONG>
                 groups;         /* Groupings. */
   public:
@@ skipping 26 matching lines @@
   inline int cmp (const hb_codepoint_t &codepoint) const
   {
     if (codepoint < startUnicodeValue) return -1;
     if (codepoint > startUnicodeValue + additionalCount) return +1;
     return 0;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this));
+    return_trace (c->check_struct (this));
   }
 
   UINT24        startUnicodeValue;      /* First value in this range. */
   BYTE          additionalCount;        /* Number of additional values in this
                                          * range. */
   public:
   DEFINE_SIZE_STATIC (4);
 };
 
 typedef SortedArrayOf<UnicodeValueRange, ULONG> DefaultUVS;
 
 struct UVSMapping
 {
   inline int cmp (const hb_codepoint_t &codepoint) const
   {
     return unicodeValue.cmp (codepoint);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this));
+    return_trace (c->check_struct (this));
   }
 
   UINT24        unicodeValue;   /* Base Unicode value of the UVS */
   GlyphID       glyphID;        /* Glyph ID of the UVS */
   public:
   DEFINE_SIZE_STATIC (5);
 };
 
 typedef SortedArrayOf<UVSMapping, ULONG> NonDefaultUVS;
 
@@ skipping 19 matching lines @@
   }
 
   inline int cmp (const hb_codepoint_t &variation_selector) const
   {
     return varSelector.cmp (variation_selector);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this) &&
-                         defaultUVS.sanitize (c, base) &&
-                         nonDefaultUVS.sanitize (c, base));
+    return_trace (c->check_struct (this) &&
+                  defaultUVS.sanitize (c, base) &&
+                  nonDefaultUVS.sanitize (c, base));
   }
 
   UINT24        varSelector;    /* Variation selector. */
   OffsetTo<DefaultUVS, ULONG>
                 defaultUVS;     /* Offset to Default UVS Table. May be 0. */
   OffsetTo<NonDefaultUVS, ULONG>
                 nonDefaultUVS;  /* Offset to Non-Default UVS Table. May be 0. */
   public:
   DEFINE_SIZE_STATIC (11);
 };
 
 struct CmapSubtableFormat14
 {
   inline glyph_variant_t get_glyph_variant (hb_codepoint_t codepoint,
                                             hb_codepoint_t variation_selector,
                                             hb_codepoint_t *glyph) const
   {
     return record[record.bsearch(variation_selector)].get_glyph (codepoint, glyph, this);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this) &&
-                         record.sanitize (c, this));
+    return_trace (c->check_struct (this) &&
+                  record.sanitize (c, this));
   }
 
   protected:
   USHORT        format;         /* Format number is set to 0. */
   ULONG         lengthZ;        /* Byte length of this subtable. */
   SortedArrayOf<VariationSelectorRecord, ULONG>
                 record;         /* Variation selector records; sorted
                                  * in increasing order of `varSelector'. */
   public:
   DEFINE_SIZE_ARRAY (10, record);
@@ skipping 24 matching lines @@
   {
     switch (u.format) {
     case 14: return u.format14.get_glyph_variant(codepoint, variation_selector, glyph);
     default: return GLYPH_VARIANT_NOT_FOUND;
     }
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    if (!u.format.sanitize (c)) return TRACE_RETURN (false);
+    if (!u.format.sanitize (c)) return_trace (false);
     switch (u.format) {
-    case  0: return TRACE_RETURN (u.format0 .sanitize (c));
-    case  4: return TRACE_RETURN (u.format4 .sanitize (c));
-    case  6: return TRACE_RETURN (u.format6 .sanitize (c));
-    case 10: return TRACE_RETURN (u.format10.sanitize (c));
-    case 12: return TRACE_RETURN (u.format12.sanitize (c));
-    case 13: return TRACE_RETURN (u.format13.sanitize (c));
-    case 14: return TRACE_RETURN (u.format14.sanitize (c));
-    default:return TRACE_RETURN (true);
+    case  0: return_trace (u.format0 .sanitize (c));
+    case  4: return_trace (u.format4 .sanitize (c));
+    case  6: return_trace (u.format6 .sanitize (c));
+    case 10: return_trace (u.format10.sanitize (c));
+    case 12: return_trace (u.format12.sanitize (c));
+    case 13: return_trace (u.format13.sanitize (c));
+    case 14: return_trace (u.format14.sanitize (c));
+    default:return_trace (true);
     }
   }
 
   protected:
   union {
   USHORT                format;         /* Format identifier */
   CmapSubtableFormat0   format0;
   CmapSubtableFormat4   format4;
   CmapSubtableFormat6   format6;
   CmapSubtableFormat10  format10;
@@ skipping 14 matching lines @@
     ret = platformID.cmp (other.platformID);
     if (ret) return ret;
     ret = encodingID.cmp (other.encodingID);
     if (ret) return ret;
     return 0;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this) &&
-                         subtable.sanitize (c, base));
+    return_trace (c->check_struct (this) &&
+                  subtable.sanitize (c, base));
   }
 
   USHORT        platformID;     /* Platform ID. */
   USHORT        encodingID;     /* Platform-specific encoding ID. */
   OffsetTo<CmapSubtable, ULONG>
                 subtable;       /* Byte offset from beginning of table to the subtable for this encoding. */
   public:
   DEFINE_SIZE_STATIC (8);
 };
 
@@ skipping 14 matching lines @@
     int result = encodingRecord./*bsearch*/lsearch (key);
     if (result == -1 || !encodingRecord[result].subtable)
       return NULL;
 
     return &(this+encodingRecord[result].subtable);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
-    return TRACE_RETURN (c->check_struct (this) &&
-                         likely (version == 0) &&
-                         encodingRecord.sanitize (c, this));
+    return_trace (c->check_struct (this) &&
+                  likely (version == 0) &&
+                  encodingRecord.sanitize (c, this));
   }
 
   USHORT                version;        /* Table version number (0). */
   SortedArrayOf<EncodingRecord>
                         encodingRecord; /* Encoding tables. */
   public:
   DEFINE_SIZE_ARRAY (4, encodingRecord);
 };
 
 
 } /* namespace OT */
 
 
 #endif /* HB_OT_CMAP_TABLE_HH */