Update harfbuzz-ng to 1a5a91dc0d8bf4b72a2f22dc6300b06ad7000b79.

third_party/harfbuzz-ng/src/hb-open-type-private.hh

 /*
- * Copyright (C) 2007,2008,2009,2010  Red Hat, Inc.
+ * Copyright © 2007,2008,2009,2010  Red Hat, Inc.
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
  * all copies of this software.
  *
  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  *
  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  *
  * Red Hat Author(s): Behdad Esfahbod
  */
 
 #ifndef HB_OPEN_TYPE_PRIVATE_HH
 #define HB_OPEN_TYPE_PRIVATE_HH
 
-#include "hb-private.h"
+#include "hb-private.hh"
 
 #include "hb-blob.h"
 
-HB_BEGIN_DECLS
-HB_END_DECLS
 
 
 /*
  * Casts
  */
 
 /* Cast to struct T, reference to reference */
 template<typename Type, typename TObject>
 inline const Type& CastR(const TObject &X)
 { return reinterpret_cast<const Type&> (X); }
@@ skipping 91 matching lines @@
 template <> \
 inline const Type& Null<Type> (void) { \
   return *CastP<Type> (_Null##Type); \
 } /* The following line really exists such that we end in a place needing semicolon */ \
 ASSERT_STATIC (Type::min_size + 1 <= sizeof (_Null##Type))
 
 /* Accessor macro. */
 #define Null(Type) Null<Type>()
 
 
-/*
- * Trace
- */
-
-
-template <int max_depth>
-struct hb_trace_t {
-  explicit hb_trace_t (unsigned int *pdepth, const char *what, const char *function, const void *obj) : pdepth(pdepth) {
-    (void) (*pdepth < max_depth &&
-            fprintf (stderr, "%s(%p) %-*d-> %s\n", what, obj, *pdepth, *pdepth, function));
-    if (max_depth) ++*pdepth;
-  }
-  ~hb_trace_t (void) { if (max_depth) --*pdepth; }
-
-  private:
-  unsigned int *pdepth;
-};
-template <> /* Optimize when tracing is disabled */
-struct hb_trace_t<0> {
-  explicit hb_trace_t (unsigned int *pdepth HB_UNUSED, const char *what HB_UNUSED, const char *function HB_UNUSED, const void *obj HB_UNUSED) {}
-};
-
-
 
 /*
  * Sanitize
  */
 
 #ifndef HB_DEBUG_SANITIZE
 #define HB_DEBUG_SANITIZE (HB_DEBUG+0)
 #endif
 
 
 #define TRACE_SANITIZE() \
-        hb_trace_t<HB_DEBUG_SANITIZE> trace (&c->debug_depth, "SANITIZE", HB_FUNC, this); \
+        hb_auto_trace_t<HB_DEBUG_SANITIZE> trace (&c->debug_depth, "SANITIZE", this, NULL, HB_FUNC);
 
 
 struct hb_sanitize_context_t
 {
-  inline void init (hb_blob_t *blob)
+  inline void init (hb_blob_t *b)
   {
-    this->blob = hb_blob_reference (blob);
-    this->start = hb_blob_lock (blob);
-    this->end = this->start + hb_blob_get_length (blob);
-    this->writable = hb_blob_is_writable (blob);
+    this->blob = hb_blob_reference (b);
+    this->writable = false;
+  }
+
+  inline void setup (void)
+  {
+    this->start = hb_blob_get_data (this->blob, NULL);
+    this->end = this->start + hb_blob_get_length (this->blob);
     this->edit_count = 0;
     this->debug_depth = 0;
 
-    (void) (HB_DEBUG_SANITIZE &&
-      fprintf (stderr, "sanitize %p init [%p..%p] (%lu bytes)\n",
-               this->blob, this->start, this->end,
-               (unsigned long) (this->end - this->start)));
+    DEBUG_MSG (SANITIZE, this->blob,
+               "init [%p..%p] (%lu bytes)",
+               this->start, this->end,
+               (unsigned long) (this->end - this->start));
   }
 
   inline void finish (void)
   {
-    (void) (HB_DEBUG_SANITIZE &&
-      fprintf (stderr, "sanitize %p fini [%p..%p] %u edit requests\n",
-               this->blob, this->start, this->end, this->edit_count));
+    DEBUG_MSG (SANITIZE, this->blob,
+               "fini [%p..%p] %u edit requests",
+               this->start, this->end, this->edit_count);
 
-    hb_blob_unlock (this->blob);
     hb_blob_destroy (this->blob);
     this->blob = NULL;
     this->start = this->end = NULL;
   }
 
   inline bool check_range (const void *base, unsigned int len) const
   {
     const char *p = (const char *) base;
     bool ret = this->start <= p &&
                p <= this->end &&
                (unsigned int) (this->end - p) >= len;
 
-    (void) (HB_DEBUG_SANITIZE && (int) this->debug_depth < (int) HB_DEBUG_SANITIZE &&
-      fprintf (stderr, "SANITIZE(%p) %-*d-> range [%p..%p] (%d bytes) in [%p..%p] -> %s\n",
-               p,
-               this->debug_depth, this->debug_depth,
-               p, p + len, len,
-               this->start, this->end,
-               ret ? "pass" : "FAIL"));
+    DEBUG_MSG_LEVEL (SANITIZE, this->blob, this->debug_depth,
+                     "%-*d-> range [%p..%p] (%d bytes) in [%p..%p] -> %s",
+                     this->debug_depth, this->debug_depth,
+                     p, p + len, len,
+                     this->start, this->end,
+                     ret ? "pass" : "FAIL");
 
     return likely (ret);
   }
 
   inline bool check_array (const void *base, unsigned int record_size, unsigned int len) const
   {
     const char *p = (const char *) base;
-    bool overflows = record_size > 0 && len >= ((unsigned int) -1) / record_size;
+    bool overflows = _hb_unsigned_int_mul_overflows (len, record_size);
 
-    (void) (HB_DEBUG_SANITIZE && (int) this->debug_depth < (int) HB_DEBUG_SANITIZE &&
-      fprintf (stderr, "SANITIZE(%p) %-*d-> array [%p..%p] (%d*%d=%ld bytes) in [%p..%p] -> %s\n",
-               p,
-               this->debug_depth, this->debug_depth,
-               p, p + (record_size * len), record_size, len, (unsigned long) record_size * len,
-               this->start, this->end,
-               !overflows ? "does not overflow" : "OVERFLOWS FAIL"));
+    DEBUG_MSG_LEVEL (SANITIZE, this->blob, this->debug_depth,
+                     "%-*d-> array [%p..%p] (%d*%d=%ld bytes) in [%p..%p] -> %s",
+                     this->debug_depth, this->debug_depth,
+                     p, p + (record_size * len), record_size, len, (unsigned long) record_size * len,
+                     this->start, this->end,
+                     !overflows ? "does not overflow" : "OVERFLOWS FAIL");
 
     return likely (!overflows && this->check_range (base, record_size * len));
   }
 
   template <typename Type>
   inline bool check_struct (const Type *obj) const
   {
     return likely (this->check_range (obj, obj->min_size));
   }
 
   inline bool can_edit (const void *base HB_UNUSED, unsigned int len HB_UNUSED)
   {
     const char *p = (const char *) base;
     this->edit_count++;
 
-    (void) (HB_DEBUG_SANITIZE && (int) this->debug_depth < (int) HB_DEBUG_SANITIZE &&
-      fprintf (stderr, "SANITIZE(%p) %-*d-> edit(%u) [%p..%p] (%d bytes) in [%p..%p] -> %s\n",
-               p,
-               this->debug_depth, this->debug_depth,
-               this->edit_count,
-               p, p + len, len,
-               this->start, this->end,
-               this->writable ? "granted" : "REJECTED"));
+    DEBUG_MSG_LEVEL (SANITIZE, this->blob, this->debug_depth,
+                     "%-*d-> edit(%u) [%p..%p] (%d bytes) in [%p..%p] -> %s",
+                     this->debug_depth, this->debug_depth,
+                     this->edit_count,
+                     p, p + len, len,
+                     this->start, this->end,
+                     this->writable ? "granted" : "REJECTED");
 
     return this->writable;
   }
 
   unsigned int debug_depth;
   const char *start, *end;
   bool writable;
   unsigned int edit_count;
   hb_blob_t *blob;
 };
 
 
 
 /* Template to sanitize an object. */
 template <typename Type>
 struct Sanitizer
 {
   static hb_blob_t *sanitize (hb_blob_t *blob) {
     hb_sanitize_context_t c[1] = {{0}};
     bool sane;
 
     /* TODO is_sane() stuff */
 
-    if (!blob)
-      return hb_blob_create_empty ();
+    c->init (blob);
 
   retry:
-    (void) (HB_DEBUG_SANITIZE &&
-      fprintf (stderr, "Sanitizer %p start %s\n", blob, HB_FUNC));
+    DEBUG_MSG_FUNC (SANITIZE, blob, "start");
 
-    c->init (blob);
+    c->setup ();
 
     if (unlikely (!c->start)) {
       c->finish ();
       return blob;
     }
 
     Type *t = CastP<Type> (const_cast<char *> (c->start));
 
     sane = t->sanitize (c);
     if (sane) {
       if (c->edit_count) {
-        (void) (HB_DEBUG_SANITIZE &&
-          fprintf (stderr, "Sanitizer %p passed first round with %d edits; doing a second round %s\n",
-                   blob, c->edit_count, HB_FUNC));
+        DEBUG_MSG_FUNC (SANITIZE, blob, "passed first round with %d edits; going for second round", c->edit_count);
 
         /* sanitize again to ensure no toe-stepping */
         c->edit_count = 0;
         sane = t->sanitize (c);
         if (c->edit_count) {
-          (void) (HB_DEBUG_SANITIZE &&
-            fprintf (stderr, "Sanitizer %p requested %d edits in second round; FAILLING %s\n",
-                     blob, c->edit_count, HB_FUNC));
+          DEBUG_MSG_FUNC (SANITIZE, blob, "requested %d edits in second round; FAILLING", c->edit_count);
           sane = false;
         }
       }
-      c->finish ();
     } else {
       unsigned int edit_count = c->edit_count;
-      c->finish ();
-      if (edit_count && !hb_blob_is_writable (blob) && hb_blob_try_writable (blob)) {
-        /* ok, we made it writable by relocating.  try again */
-        (void) (HB_DEBUG_SANITIZE &&
-          fprintf (stderr, "Sanitizer %p retry %s\n", blob, HB_FUNC));
-        goto retry;
+      if (edit_count && !c->writable) {
+        c->start = hb_blob_get_data_writable (blob, NULL);
+        c->end = c->start + hb_blob_get_length (blob);
+
+        if (c->start) {
+          c->writable = true;
+          /* ok, we made it writable by relocating.  try again */
+          DEBUG_MSG_FUNC (SANITIZE, blob, "retry");
+          goto retry;
+        }
       }
     }
 
-    (void) (HB_DEBUG_SANITIZE &&
-      fprintf (stderr, "Sanitizer %p %s %s\n", blob, sane ? "passed" : "FAILED", HB_FUNC));
+    c->finish ();
+
+    DEBUG_MSG_FUNC (SANITIZE, blob, sane ? "PASSED" : "FAILED");
     if (sane)
       return blob;
     else {
       hb_blob_destroy (blob);
-      return hb_blob_create_empty ();
+      return hb_blob_get_empty ();
     }
   }
 
   static const Type* lock_instance (hb_blob_t *blob) {
-    const char *base = hb_blob_lock (blob);
+    hb_blob_make_immutable (blob);
+    const char *base = hb_blob_get_data (blob, NULL);
     return unlikely (!base) ? &Null(Type) : CastP<Type> (base);
   }
 };
 
 
 
 
 /*
  *
  * The OpenType Font File: Data Types
  */
 
 
 /* "The following data types are used in the OpenType font file.
  *  All OpenType fonts use Motorola-style byte ordering (Big Endian):" */
 
 /*
  * Int types
  */
 
 
-template <typename Type, int Bytes> class BEInt;
+template <typename Type, int Bytes> struct BEInt;
 
 /* LONGTERMTODO: On machines allowing unaligned access, we can make the
  * following tighter by using byteswap instructions on ints directly. */
 template <typename Type>
-class BEInt<Type, 2>
+struct BEInt<Type, 2>
 {
   public:
   inline void set (Type i) { hb_be_uint16_put (v,i); }
   inline operator Type (void) const { return hb_be_uint16_get (v); }
-  inline bool operator == (const BEInt<Type, 2>& o) const { return hb_be_uint16_cmp (v, o.v); }
+  inline bool operator == (const BEInt<Type, 2>& o) const { return hb_be_uint16_eq (v, o.v); }
   inline bool operator != (const BEInt<Type, 2>& o) const { return !(*this == o); }
   private: uint8_t v[2];
 };
 template <typename Type>
-class BEInt<Type, 4>
+struct BEInt<Type, 4>
 {
   public:
   inline void set (Type i) { hb_be_uint32_put (v,i); }
   inline operator Type (void) const { return hb_be_uint32_get (v); }
-  inline bool operator == (const BEInt<Type, 4>& o) const { return hb_be_uint32_cmp (v, o.v); }
+  inline bool operator == (const BEInt<Type, 4>& o) const { return hb_be_uint32_eq (v, o.v); }
   inline bool operator != (const BEInt<Type, 4>& o) const { return !(*this == o); }
   private: uint8_t v[4];
 };
 
 /* Integer types in big-endian order and no alignment requirement */
 template <typename Type>
 struct IntType
 {
   inline void set (Type i) { v.set (i); }
   inline operator Type(void) const { return v; }
   inline bool operator == (const IntType<Type> &o) const { return v == o.v; }
   inline bool operator != (const IntType<Type> &o) const { return v != o.v; }
   inline int cmp (Type a) const { Type b = v; return a < b ? -1 : a == b ? 0 : +1; }
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return likely (c->check_struct (this));
   }
   protected:
   BEInt<Type, sizeof (Type)> v;
   public:
   DEFINE_SIZE_STATIC (sizeof (Type));
 };
 
+/* Typedef these to avoid clash with windows.h */
+#define USHORT  HB_USHORT
+#define SHORT   HB_SHORT
+#define ULONG   HB_ULONG
+#define LONG    HB_LONG
 typedef IntType<uint16_t> USHORT;       /* 16-bit unsigned integer. */
 typedef IntType<int16_t>  SHORT;        /* 16-bit signed integer. */
 typedef IntType<uint32_t> ULONG;        /* 32-bit unsigned integer. */
 typedef IntType<int32_t>  LONG;         /* 32-bit signed integer. */
 
+/* 16-bit signed integer (SHORT) that describes a quantity in FUnits. */
+typedef SHORT FWORD;
+
+/* 16-bit unsigned integer (USHORT) that describes a quantity in FUnits. */
+typedef USHORT UFWORD;
+
 /* Date represented in number of seconds since 12:00 midnight, January 1,
  * 1904. The value is represented as a signed 64-bit integer. */
 struct LONGDATETIME
 {
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return likely (c->check_struct (this));
   }
   private:
   LONG major;
@@ skipping 46 matching lines @@
   DEFINE_SIZE_STATIC (4);
 };
 
 
 /*
  * Version Numbers
  */
 
 struct FixedVersion
 {
-  inline operator uint32_t (void) const { return (major << 16) + minor; }
+  inline uint32_t to_int (void) const { return (major << 16) + minor; }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return c->check_struct (this);
   }
 
   USHORT major;
   USHORT minor;
   public:
   DEFINE_SIZE_STATIC (4);
@@ skipping 212 matching lines @@
   DEFINE_SIZE_ARRAY (sizeof (USHORT), array);
 };
 
 
 /* An array with sorted elements.  Supports binary searching. */
 template <typename Type>
 struct SortedArrayOf : ArrayOf<Type> {
 
   template <typename SearchType>
   inline int search (const SearchType &x) const {
-    class Cmp {
-      public: static int cmp (const SearchType *a, const Type *b) { return b->cmp (*a); }
+    struct Cmp {
+      static int cmp (const SearchType *a, const Type *b) { return b->cmp (*a); }
     };
     const Type *p = (const Type *) bsearch (&x, this->array, this->len, sizeof (this->array[0]), (hb_compare_func_t) Cmp::cmp);
     return p ? p - this->array : -1;
   }
 };
 
 
-HB_BEGIN_DECLS
-HB_END_DECLS
 
 #endif /* HB_OPEN_TYPE_PRIVATE_HH */