Roll harfbuzz-ng 3b8fd9c48f4bde368bf2d465c148b9743a9216ee

third_party/harfbuzz-ng/src/hb-object-private.hh

 /*
  * Copyright © 2007  Chris Wilson
  * Copyright © 2009,2010  Red Hat, Inc.
  * Copyright © 2011  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
@@ skipping 16 matching lines @@
  *      Chris Wilson <chris@chris-wilson.co.uk>
  * Red Hat Author(s): Behdad Esfahbod
  * Google Author(s): Behdad Esfahbod
  */
 
 #ifndef HB_OBJECT_PRIVATE_HH
 #define HB_OBJECT_PRIVATE_HH
 
 #include "hb-private.hh"
 
+#include "hb-atomic-private.hh"
 #include "hb-mutex-private.hh"
 
 
-
 /* Debug */
 
 #ifndef HB_DEBUG_OBJECT
 #define HB_DEBUG_OBJECT (HB_DEBUG+0)
 #endif
 
 
-/* atomic_int */
-
-/* We need external help for these */
-
-#ifdef HAVE_GLIB
-
-#include <glib.h>
-
-typedef volatile int hb_atomic_int_t;
-#if GLIB_CHECK_VERSION(2,29,5)
-#define hb_atomic_int_add(AI, V)        g_atomic_int_add (&(AI), V)
-#else
-#define hb_atomic_int_add(AI, V)        g_atomic_int_exchange_and_add (&(AI), V)
-#endif
-#define hb_atomic_int_get(AI)           g_atomic_int_get (&(AI))
-#define hb_atomic_int_set(AI, V)        g_atomic_int_set (&(AI), V)
-
-
-#elif defined(_MSC_VER) && _MSC_VER >= 1600
-
-#include <intrin.h>
-
-typedef long hb_atomic_int_t;
-#define hb_atomic_int_add(AI, V)        _InterlockedExchangeAdd (&(AI), V)
-#define hb_atomic_int_get(AI)           (_ReadBarrier (), (AI))
-#define hb_atomic_int_set(AI, V)        ((void) _InterlockedExchange (&(AI), (V)))
-
-
-#else
-
-#ifdef _MSC_VER
-#pragma message("Could not find any system to define atomic_int macros, library will NOT be thread-safe")
-#else
-#warning "Could not find any system to define atomic_int macros, library will NOT be thread-safe"
-#endif
-
-typedef volatile int hb_atomic_int_t;
-#define hb_atomic_int_add(AI, V)        ((AI) += (V), (AI) - (V))
-#define hb_atomic_int_get(AI)           (AI)
-#define hb_atomic_int_set(AI, V)        ((void) ((AI) = (V)))
-
-
-#endif
-
-
-
-
 /* reference_count */
 
-typedef struct {
+struct hb_reference_count_t
+{
   hb_atomic_int_t ref_count;
 
 #define HB_REFERENCE_COUNT_INVALID_VALUE ((hb_atomic_int_t) -1)
 #define HB_REFERENCE_COUNT_INVALID {HB_REFERENCE_COUNT_INVALID_VALUE}
 
-  inline void init (int v) { ref_count = v; /* non-atomic is fine */ }
-  inline int inc (void) { return hb_atomic_int_add (ref_count,  1); }
-  inline int dec (void) { return hb_atomic_int_add (ref_count, -1); }
-  inline void set (int v) { hb_atomic_int_set (ref_count, v); }
+  inline void init (int v) { const_cast<hb_atomic_int_t &> (ref_count) = v; }
+  inline int inc (void) { return hb_atomic_int_add (const_cast<hb_atomic_int_t &> (ref_count),  1); }
+  inline int dec (void) { return hb_atomic_int_add (const_cast<hb_atomic_int_t &> (ref_count), -1); }
 
-  inline int get (void) const { return hb_atomic_int_get (ref_count); }
-  inline bool is_invalid (void) const { return get () == HB_REFERENCE_COUNT_INVALID_VALUE; }
+  inline bool is_invalid (void) const { return ref_count == HB_REFERENCE_COUNT_INVALID_VALUE; }
 
-} hb_reference_count_t;
+};
 
 
 /* user_data */
 
-struct hb_user_data_array_t {
-
+struct hb_user_data_array_t
+{
   struct hb_user_data_item_t {
     hb_user_data_key_t *key;
     void *data;
     hb_destroy_func_t destroy;
 
     inline bool operator == (hb_user_data_key_t *other_key) const { return key == other_key; }
     inline bool operator == (hb_user_data_item_t &other) const { return key == other.key; }
 
     void finish (void) { if (destroy) destroy (data); }
   };
 
   hb_lockable_set_t<hb_user_data_item_t, hb_static_mutex_t> items;
 
   HB_INTERNAL bool set (hb_user_data_key_t *key,
                         void *              data,
                         hb_destroy_func_t   destroy,
                         hb_bool_t           replace);
 
   HB_INTERNAL void *get (hb_user_data_key_t *key);
 
   HB_INTERNAL void finish (void);
 };
 
 
 /* object_header */
 
-typedef struct _hb_object_header_t hb_object_header_t;
-
-struct _hb_object_header_t {
+struct hb_object_header_t
+{
   hb_reference_count_t ref_count;
   hb_user_data_array_t user_data;
 
 #define HB_OBJECT_HEADER_STATIC {HB_REFERENCE_COUNT_INVALID}
 
   static inline void *create (unsigned int size) {
     hb_object_header_t *obj = (hb_object_header_t *) calloc (1, size);
 
     if (likely (obj))
       obj->init ();
@@ skipping 36 matching lines @@
       return false;
 
     return user_data.set (key, data, destroy_func, replace);
   }
 
   inline void *get_user_data (hb_user_data_key_t *key) {
     return user_data.get (key);
   }
 
   inline void trace (const char *function) const {
+    if (unlikely (!this)) return;
+    /* XXX We cannot use DEBUG_MSG_FUNC here since that one currecntly only
+     * prints the class name and throws away the template info. */
     DEBUG_MSG (OBJECT, (void *) this,
-               "refcount=%d %s",
-               this ? ref_count.get () : 0,
-               function);
+               "%s refcount=%d",
+               function,
+               this ? ref_count.ref_count : 0);
   }
 
 };
 
 
-
-
 /* object */
 
 template <typename Type>
 static inline void hb_object_trace (const Type *obj, const char *function)
 {
   obj->header.trace (function);
 }
 template <typename Type>
 static inline Type *hb_object_create (void)
 {
@@ skipping 30 matching lines @@
 }
 
 template <typename Type>
 static inline void *hb_object_get_user_data (Type               *obj,
                                              hb_user_data_key_t *key)
 {
   return obj->header.get_user_data (key);
 }
 
 
-
-
-
 #endif /* HB_OBJECT_PRIVATE_HH */