third_party/harfbuzz-ng/src/hb-common.cc

   1 /*
   2  * Copyright © 2009,2010  Red Hat, Inc.
   3  * Copyright © 2011,2012  Google, Inc.
   4  *
   5  *  This is part of HarfBuzz, a text shaping library.
   6  *
   7  * Permission is hereby granted, without written agreement and without
   8  * license or royalty fees, to use, copy, modify, and distribute this
   9  * software and its documentation for any purpose, provided that the
  10  * above copyright notice and the following two paragraphs appear in
  11  * all copies of this software.
  12  *
  13  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  14  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  15  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  16  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  17  * DAMAGE.
  18  *
  19  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  20  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  21  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  22  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  23  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  24  *
  25  * Red Hat Author(s): Behdad Esfahbod
  26  * Google Author(s): Behdad Esfahbod
  27  */
  28
  29 #include "hb-private.hh"
  30
  31 #include "hb-version.h"
  32
  33 #include "hb-mutex-private.hh"
  34 #include "hb-object-private.hh"
  35
  36 #include <locale.h>
  37
  38
  39 /* hb_options_t */
  40
  41 hb_options_union_t _hb_options;
  42
  43 void
  44 _hb_options_init (void)
  45 {
  46   hb_options_union_t u;
  47   u.i = 0;
  48   u.opts.initialized = 1;
  49
  50   char *c = getenv ("HB_OPTIONS");
  51   u.opts.uniscribe_bug_compatible = c && strstr (c, "uniscribe-bug-compatible");
  52
  53   /* This is idempotent and threadsafe. */
  54   _hb_options = u;
  55 }
  56
  57
  58 /* hb_tag_t */
  59
  60 hb_tag_t
  61 hb_tag_from_string (const char *s, int len)
  62 {
  63   char tag[4];
  64   unsigned int i;
  65
  66   if (!s || !len || !*s)
  67     return HB_TAG_NONE;
  68
  69   if (len < 0 || len > 4)
  70     len = 4;
  71   for (i = 0; i < (unsigned) len && s[i]; i++)
  72     tag[i] = s[i];
  73   for (; i < 4; i++)
  74     tag[i] = ' ';
  75
  76   return HB_TAG_CHAR4 (tag);
  77 }
  78
  79 void
  80 hb_tag_to_string (hb_tag_t tag, char *buf)
  81 {
  82   buf[0] = (char) (uint8_t) (tag >> 24);
  83   buf[1] = (char) (uint8_t) (tag >> 16);
  84   buf[2] = (char) (uint8_t) (tag >>  8);
  85   buf[3] = (char) (uint8_t) (tag >>  0);
  86 }
  87
  88
  89 /* hb_direction_t */
  90
  91 const char direction_strings[][4] = {
  92   "ltr",
  93   "rtl",
  94   "ttb",
  95   "btt"
  96 };
  97
  98 hb_direction_t
  99 hb_direction_from_string (const char *str, int len)
 100 {
 101   if (unlikely (!str || !len || !*str))
 102     return HB_DIRECTION_INVALID;
 103
 104   /* Lets match loosely: just match the first letter, such that
 105    * all of "ltr", "left-to-right", etc work!
 106    */
 107   char c = TOLOWER (str[0]);
 108   for (unsigned int i = 0; i < ARRAY_LENGTH (direction_strings); i++)
 109     if (c == direction_strings[i][0])
 110       return (hb_direction_t) (HB_DIRECTION_LTR + i);
 111
 112   return HB_DIRECTION_INVALID;
 113 }
 114
 115 const char *
 116 hb_direction_to_string (hb_direction_t direction)
 117 {
 118   if (likely ((unsigned int) (direction - HB_DIRECTION_LTR)
 119               < ARRAY_LENGTH (direction_strings)))
 120     return direction_strings[direction - HB_DIRECTION_LTR];
 121
 122   return "invalid";
 123 }
 124
 125
 126 /* hb_language_t */
 127
 128 struct hb_language_impl_t {
 129   const char s[1];
 130 };
 131
 132 static const char canon_map[256] = {
 133    0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,
 134    0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,
 135    0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,  '-',  0,   0,
 136   '0', '1', '2', '3', '4', '5', '6', '7',  '8', '9',  0,   0,   0,   0,   0,   0,
 137   '-', 'a', 'b', 'c', 'd', 'e', 'f', 'g',  'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
 138   'p', 'q', 'r', 's', 't', 'u', 'v', 'w',  'x', 'y', 'z',  0,   0,   0,   0,  '-',
 139    0,  'a', 'b', 'c', 'd', 'e', 'f', 'g',  'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
 140   'p', 'q', 'r', 's', 't', 'u', 'v', 'w',  'x', 'y', 'z',  0,   0,   0,   0,   0
 141 };
 142
 143 static hb_bool_t
 144 lang_equal (hb_language_t  v1,
 145             const void    *v2)
 146 {
 147   const unsigned char *p1 = (const unsigned char *) v1;
 148   const unsigned char *p2 = (const unsigned char *) v2;
 149
 150   while (*p1 && *p1 == canon_map[*p2])
 151     p1++, p2++;
 152
 153   return *p1 == canon_map[*p2];
 154 }
 155
 156 #if 0
 157 static unsigned int
 158 lang_hash (const void *key)
 159 {
 160   const unsigned char *p = key;
 161   unsigned int h = 0;
 162   while (canon_map[*p])
 163     {
 164       h = (h << 5) - h + canon_map[*p];
 165       p++;
 166     }
 167
 168   return h;
 169 }
 170 #endif
 171
 172
 173 struct hb_language_item_t {
 174
 175   struct hb_language_item_t *next;
 176   hb_language_t lang;
 177
 178   inline bool operator == (const char *s) const {
 179     return lang_equal (lang, s);
 180   }
 181
 182   inline hb_language_item_t & operator = (const char *s) {
 183     lang = (hb_language_t) strdup (s);
 184     for (unsigned char *p = (unsigned char *) lang; *p; p++)
 185       *p = canon_map[*p];
 186
 187     return *this;
 188   }
 189
 190   void finish (void) { free (lang); }
 191 };
 192
 193
 194 /* Thread-safe lock-free language list */
 195
 196 static hb_language_item_t *langs;
 197
 198 static inline
 199 void free_langs (void)
 200 {
 201   while (langs) {
 202     hb_language_item_t *next = langs->next;
 203     langs->finish ();
 204     free (langs);
 205     langs = next;
 206   }
 207 }
 208
 209 static hb_language_item_t *
 210 lang_find_or_insert (const char *key)
 211 {
 212 retry:
 213   hb_language_item_t *first_lang = (hb_language_item_t *) hb_atomic_ptr_get (&langs);
 214
 215   for (hb_language_item_t *lang = first_lang; lang; lang = lang->next)
 216     if (*lang == key)
 217       return lang;
 218
 219   /* Not found; allocate one. */
 220   hb_language_item_t *lang = (hb_language_item_t *) calloc (1, sizeof (hb_language_item_t));
 221   if (unlikely (!lang))
 222     return NULL;
 223   lang->next = first_lang;
 224   *lang = key;
 225
 226   if (!hb_atomic_ptr_cmpexch (&langs, first_lang, lang)) {
 227     free (lang);
 228     goto retry;
 229   }
 230
 231 #ifdef HAVE_ATEXIT
 232   if (!first_lang)
 233     atexit (free_langs); /* First person registers atexit() callback. */
 234 #endif
 235
 236   return lang;
 237 }
 238
 239
 240 hb_language_t
 241 hb_language_from_string (const char *str, int len)
 242 {
 243   if (!str || !len || !*str)
 244     return HB_LANGUAGE_INVALID;
 245
 246   char strbuf[32];
 247   if (len >= 0) {
 248     len = MIN (len, (int) sizeof (strbuf) - 1);
 249     str = (char *) memcpy (strbuf, str, len);
 250     strbuf[len] = '\0';
 251   }
 252
 253   hb_language_item_t *item = lang_find_or_insert (str);
 254
 255   return likely (item) ? item->lang : HB_LANGUAGE_INVALID;
 256 }
 257
 258 const char *
 259 hb_language_to_string (hb_language_t language)
 260 {
 261   /* This is actually NULL-safe! */
 262   return language->s;
 263 }
 264
 265 hb_language_t
 266 hb_language_get_default (void)
 267 {
 268   static hb_language_t default_language = HB_LANGUAGE_INVALID;
 269
 270   hb_language_t language = (hb_language_t) hb_atomic_ptr_get (&default_language);
 271   if (unlikely (language == HB_LANGUAGE_INVALID)) {
 272     language = hb_language_from_string (setlocale (LC_CTYPE, NULL), -1);
 273     hb_atomic_ptr_cmpexch (&default_language, HB_LANGUAGE_INVALID, language);
 274   }
 275
 276   return default_language;
 277 }
 278
 279
 280 /* hb_script_t */
 281
 282 hb_script_t
 283 hb_script_from_iso15924_tag (hb_tag_t tag)
 284 {
 285   if (unlikely (tag == HB_TAG_NONE))
 286     return HB_SCRIPT_INVALID;
 287
 288   /* Be lenient, adjust case (one capital letter followed by three small letters) */
 289   tag = (tag & 0xDFDFDFDF) | 0x00202020;
 290
 291   switch (tag) {
 292
 293     /* These graduated from the 'Q' private-area codes, but
 294      * the old code is still aliased by Unicode, and the Qaai
 295      * one in use by ICU. */
 296     case HB_TAG('Q','a','a','i'): return HB_SCRIPT_INHERITED;
 297     case HB_TAG('Q','a','a','c'): return HB_SCRIPT_COPTIC;
 298
 299     /* Script variants from http://unicode.org/iso15924/ */
 300     case HB_TAG('C','y','r','s'): return HB_SCRIPT_CYRILLIC;
 301     case HB_TAG('L','a','t','f'): return HB_SCRIPT_LATIN;
 302     case HB_TAG('L','a','t','g'): return HB_SCRIPT_LATIN;
 303     case HB_TAG('S','y','r','e'): return HB_SCRIPT_SYRIAC;
 304     case HB_TAG('S','y','r','j'): return HB_SCRIPT_SYRIAC;
 305     case HB_TAG('S','y','r','n'): return HB_SCRIPT_SYRIAC;
 306   }
 307
 308   /* If it looks right, just use the tag as a script */
 309   if (((uint32_t) tag & 0xE0E0E0E0) == 0x40606060)
 310     return (hb_script_t) tag;
 311
 312   /* Otherwise, return unknown */
 313   return HB_SCRIPT_UNKNOWN;
 314 }
 315
 316 hb_script_t
 317 hb_script_from_string (const char *s, int len)
 318 {
 319   return hb_script_from_iso15924_tag (hb_tag_from_string (s, len));
 320 }
 321
 322 hb_tag_t
 323 hb_script_to_iso15924_tag (hb_script_t script)
 324 {
 325   return (hb_tag_t) script;
 326 }
 327
 328 hb_direction_t
 329 hb_script_get_horizontal_direction (hb_script_t script)
 330 {
 331   /* http://goo.gl/x9ilM */
 332   switch ((hb_tag_t) script)
 333   {
 334     /* Unicode-1.1 additions */
 335     case HB_SCRIPT_ARABIC:
 336     case HB_SCRIPT_HEBREW:
 337
 338     /* Unicode-3.0 additions */
 339     case HB_SCRIPT_SYRIAC:
 340     case HB_SCRIPT_THAANA:
 341
 342     /* Unicode-4.0 additions */
 343     case HB_SCRIPT_CYPRIOT:
 344
 345     /* Unicode-4.1 additions */
 346     case HB_SCRIPT_KHAROSHTHI:
 347
 348     /* Unicode-5.0 additions */
 349     case HB_SCRIPT_PHOENICIAN:
 350     case HB_SCRIPT_NKO:
 351
 352     /* Unicode-5.1 additions */
 353     case HB_SCRIPT_LYDIAN:
 354
 355     /* Unicode-5.2 additions */
 356     case HB_SCRIPT_AVESTAN:
 357     case HB_SCRIPT_IMPERIAL_ARAMAIC:
 358     case HB_SCRIPT_INSCRIPTIONAL_PAHLAVI:
 359     case HB_SCRIPT_INSCRIPTIONAL_PARTHIAN:
 360     case HB_SCRIPT_OLD_SOUTH_ARABIAN:
 361     case HB_SCRIPT_OLD_TURKIC:
 362     case HB_SCRIPT_SAMARITAN:
 363
 364     /* Unicode-6.0 additions */
 365     case HB_SCRIPT_MANDAIC:
 366
 367     /* Unicode-6.1 additions */
 368     case HB_SCRIPT_MEROITIC_CURSIVE:
 369     case HB_SCRIPT_MEROITIC_HIEROGLYPHS:
 370
 371       return HB_DIRECTION_RTL;
 372   }
 373
 374   return HB_DIRECTION_LTR;
 375 }
 376
 377
 378 /* hb_user_data_array_t */
 379
 380 bool
 381 hb_user_data_array_t::set (hb_user_data_key_t *key,
 382                            void *              data,
 383                            hb_destroy_func_t   destroy,
 384                            hb_bool_t           replace)
 385 {
 386   if (!key)
 387     return false;
 388
 389   if (replace) {
 390     if (!data && !destroy) {
 391       items.remove (key, lock);
 392       return true;
 393     }
 394   }
 395   hb_user_data_item_t item = {key, data, destroy};
 396   bool ret = !!items.replace_or_insert (item, lock, replace);
 397
 398   return ret;
 399 }
 400
 401 void *
 402 hb_user_data_array_t::get (hb_user_data_key_t *key)
 403 {
 404   hb_user_data_item_t item = {NULL };
 405
 406   return items.find (key, &item, lock) ? item.data : NULL;
 407 }
 408
 409
 410 /* hb_version */
 411
 412 void
 413 hb_version (unsigned int *major,
 414             unsigned int *minor,
 415             unsigned int *micro)
 416 {
 417   *major = HB_VERSION_MAJOR;
 418   *minor = HB_VERSION_MINOR;
 419   *micro = HB_VERSION_MICRO;
 420 }
 421
 422 const char *
 423 hb_version_string (void)
 424 {
 425   return HB_VERSION_STRING;
 426 }
 427
 428 hb_bool_t
 429 hb_version_check (unsigned int major,
 430                   unsigned int minor,
 431                   unsigned int micro)
 432 {
 433   return HB_VERSION_CHECK (major, minor, micro);
 434 }